deps/lightning/lib/jit_riscv-cpu.c

   1 /*
   2  * Copyright (C) 2019  Free Software Foundation, Inc.
   3  *
   4  * This file is part of GNU lightning.
   5  *
   6  * GNU lightning is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 3, or (at your option)
   9  * any later version.
  10  *
  11  * GNU lightning is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  14  * License for more details.
  15  *
  16  * Authors:
  17  *      Paulo Cesar Pereira de Andrade
  18  */
  19
  20 #if PROTO
  21 #define _ZERO_REGNO             0
  22 #define _RA_REGNO               1
  23 #define _SP_REGNO               2
  24 #define _FP_REGNO               8
  25 typedef union {
  26 #  define ui                    jit_uint32_t
  27     struct  {
  28         ui opcode       : 7;
  29         ui rd           : 5;
  30         ui funct3       : 3;
  31         ui rs1          : 5;
  32         ui rs2          : 5;
  33         ui funct7       : 7;
  34     } R;
  35     struct  {
  36         ui opcode       : 7;
  37         ui rd           : 5;
  38         ui funct3       : 3;
  39         ui rs1          : 5;
  40         ui rs2          : 5;
  41         ui funct2       : 2;
  42         ui rs3          : 5;
  43     } R4;
  44     struct  {
  45         ui opcode       : 7;
  46         ui rd           : 5;
  47         ui funct3       : 3;
  48         ui rs1          : 5;
  49         ui imm11_0      : 12;
  50     } I;
  51 #  if __WORDSIZE == 64
  52     struct  {
  53         ui opcode       : 7;
  54         ui rd           : 5;
  55         ui funct3       : 3;
  56         ui rs1          : 5;
  57         ui shamt        : 6;
  58         ui imm6_0       : 6;
  59     } IS;
  60 #  endif
  61     struct  {
  62         ui opcode       : 7;
  63         ui imm4_0       : 5;
  64         ui funct3       : 3;
  65         ui rs1          : 5;
  66         ui rs2          : 5;
  67         ui imm11_5      : 7;
  68     } S;
  69     struct  {
  70         ui opcode       : 7;
  71         ui imm11        : 1;
  72         ui imm4_1       : 4;
  73         ui funct3       : 3;
  74         ui rs1          : 5;
  75         ui rs2          : 5;
  76         ui imm10_5      : 6;
  77         ui imm12        : 1;
  78     } B;
  79     struct  {
  80         ui opcode       : 7;
  81         ui rd           : 5;
  82         ui imm12_31     : 20;
  83     } U;
  84     struct  {
  85         ui opcode       : 7;
  86         ui rd           : 5;
  87         ui imm19_12     : 8;
  88         ui imm11        : 1;
  89         ui imm10_1      : 10;
  90         ui imm20        : 1;
  91     } J;
  92     jit_int32_t         w;
  93 #  undef ui
  94 } instr_t;
  95 #  define ii(i)                         *_jit->pc.ui++ = i
  96 /* FIXME could jit_rewind_prolog() to only use extra 64 bytes
  97  * if a variadic jit function that have variadic arguments in
  98  * registers */
  99 #  define stack_framesize               (200 + 64)
 100 #  define ldr(r0, r1)                   ldr_l(r0, r1)
 101 #  define ldi(r0, im)                   ldi_l(r0, im)
 102 #  define ldxr(r0, r1, r2)              ldxr_l(r0, r1, r2)
 103 #  define ldxi(r0, r1, im)              ldxi_l(r0, r1, im)
 104 #  define str(r0, r1)                   str_l(r0, r1)
 105 #  define sti(im, r0)                   sti_l(im, r0)
 106 #  define stxr(r0, r1, r2)              stxr_l(r0, r1, r2)
 107 #  define stxi(im, r0, r1)              stxi_l(im, r0, r1)
 108 #  define simm6_p(im)                   ((im) <= 31 && (im) >= -32)
 109 #  define simm12_p(im)                  ((im) <= 2047 && (im) >= -2048)
 110 #  define simm20_p(im)                  ((im) <= 524287 && (im) >= -524288)
 111 #  define simm32_p(im)                  ((im) <= 2147483647LL && (im) >= -2147483648LL)
 112
 113 /*
 114  * RV32I Base Instruction Set
 115  */
 116 #  define LUI(rd, imm)                  Utype(55, rd, imm)
 117 #  define AUIPC(rd, imm)                Utype(23, rd, imm)
 118 #  define JAL(rd, imm)                  Jtype(111, rd, imm)
 119 #  define JALR(rd, rs1, imm)            Itype(103, rd, 0, rs1, imm)
 120 #  define BEQ(rs1, rs2, imm)            Btype(99, 0, rs1, rs2, imm)
 121 #  define BNE(rs1, rs2, imm)            Btype(99, 1, rs1, rs2, imm)
 122 #  define BLT(rs1, rs2, imm)            Btype(99, 4, rs1, rs2, imm)
 123 #  define BGE(rs1, rs2, imm)            Btype(99, 5, rs1, rs2, imm)
 124 #  define BLTU(rs1, rs2, imm)           Btype(99, 6, rs1, rs2, imm)
 125 #  define BGEU(rs1, rs2, imm)           Btype(99, 7, rs1, rs2, imm)
 126 #  define LB(rd, rs1, imm)              Itype(3, rd, 0, rs1, imm)
 127 #  define LH(rd, rs1, imm)              Itype(3, rd, 1, rs1, imm)
 128 #  define LW(rd, rs1, imm)              Itype(3, rd, 2, rs1, imm)
 129 #  define LBU(rd, rs1, imm)             Itype(3, rd, 4, rs1, imm)
 130 #  define LHU(rd, rs1, imm)             Itype(3, rd, 5, rs1, imm)
 131 #  define SB(rs1, rs2, imm)             Stype(35, 0, rs1, rs2, imm)
 132 #  define SH(rs1, rs2, imm)             Stype(35, 1, rs1, rs2, imm)
 133 #  define SW(rs1, rs2, imm)             Stype(35, 2, rs1, rs2, imm)
 134 #  define ADDI(rd, rs1, imm)            Itype(19, rd, 0, rs1, imm)
 135 #  define SLTI(rd, rs1, imm)            Itype(19, rd, 2, rs1, imm)
 136 #  define SLTIU(rd, rs1, imm)           Itype(19, rd, 3, rs1, imm)
 137 #  define XORI(rd, rs1, imm)            Itype(19, rd, 4, rs1, imm)
 138 #  define ORI(rd, rs1, imm)             Itype(19, rd, 6, rs1, imm)
 139 #  define ANDI(rd, rs1, imm)            Itype(19, rd, 7, rs1, imm)
 140 #  if __WORDSIZE == 32
 141 #    define SLLI(rd, rs1, imm)          Rtype(19, rd, 1, rs1, imm, 0)
 142 #    define SRLI(rd, rs1, imm)          Rtype(19, rd, 5, rs1, imm, 0)
 143 #    define SRAI(rd, rs1, imm)          Rtype(19, rd, 5, rs1, imm, 32)
 144 #  endif
 145 #  define ADD(rd, rs1, rs2)             Rtype(51, rd, 0, rs1, rs2, 0)
 146 #  define SUB(rd, rs1, rs2)             Rtype(51, rd, 0, rs1, rs2, 32)
 147 #  define SLL(rd, rs1, rs2)             Rtype(51, rd, 1, rs1, rs2, 0)
 148 #  define SLT(rd, rs1, rs2)             Rtype(51, rd, 2, rs1, rs2, 0)
 149 #  define SLTU(rd, rs1, rs2)            Rtype(51, rd, 3, rs1, rs2, 0)
 150 #  define XOR(rd, rs1, rs2)             Rtype(51, rd, 4, rs1, rs2, 0)
 151 #  define SRL(rd, rs1, rs2)             Rtype(51, rd, 5, rs1, rs2, 0)
 152 #  define SRA(rd, rs1, rs2)             Rtype(51, rd, 5, rs1, rs2, 32)
 153 #  define OR(rd, rs1, rs2)              Rtype(51, rd, 6, rs1, rs2, 0)
 154 #  define AND(rd, rs1, rs2)             Rtype(51, rd, 7, rs1, rs2, 0)
 155 #  define FENCE(imm)                    Itype(15, 0, 0, 0, im)
 156 #  define FENCE_I(imm)                  Itype(15, 0, 1, 0, im)
 157 #  define ECALL()                       Itype(115, 0, 0, 0, 0)
 158 #  define EBREAK()                      Itype(115, 0, 0, 0, 1)
 159 #  define CSRRW(rd, rs1, csr)           Itype(115, rd, 1, rs1, csr)
 160 #  define CSRRS(rd, rs1, csr)           Itype(115, rd, 2, rs1, csr)
 161 #  define CSRRC(rd, rs1, csr)           Itype(115, rd, 3, rs1, csr)
 162 #  define CSRRWI(rd, zimm, csr)         Itype(115, rd, 5, zimm, csr)
 163 #  define CSRRSI(rd, zimm, csr)         Itype(115, rd, 6, zimm, csr)
 164 #  define CSRRCI(rd, zimm, csr)         Itype(115, rd, 7, zimm, csr)
 165 /*
 166  * RV64I Base Instruction Set (in addition to RV32I)
 167  */
 168 #  define LWU(rd, rs1, imm)             Itype(3, rd, 6, rs1, imm)
 169 #  define LD(rd, rs1, imm)              Itype(3, rd, 3, rs1, imm)
 170 #  define SD(rs1, rs2, imm)             Stype(35, 3, rs1, rs2, imm)
 171 #  if __WORDSIZE == 64
 172 #    define SLLI(rd, rs1, sh)           IStype(19, rd, 1, rs1, sh, 0)
 173 #    define SRLI(rd, rs1, sh)           IStype(19, rd, 5, rs1, sh, 0)
 174 #    define SRAI(rd, rs1, sh)           IStype(19, rd, 5, rs1, sh, 16)
 175 #  endif
 176 #  define ADDIW(rd, rs1, imm)           Itype(27, rd, 0, rs1, imm)
 177 #  define SLLIW(rd, rs1, imm)           Rtype(27, rd, 1, rs1, imm, 0)
 178 #  define SRLIW(rd, rs1, imm)           Rtype(27, rd, 3, rs1, imm, 0)
 179 #  define SRAIW(rd, rs1, imm)           Rtype(27, rd, 3, rs1, imm, 32)
 180 #  define ADDW(rd, rs1, imm)            Rtype(59, rd, 0, rs1, imm, 0)
 181 #  define SUBW(rd, rs1, imm)            Rtype(59, rd, 0, rs1, imm, 32)
 182 #  define SLLW(rd, rs1, imm)            Rtype(59, rd, 1, rs1, imm, 0)
 183 #  define SRLW(rd, rs1, imm)            Rtype(59, rd, 5, rs1, imm, 0)
 184 #  define SRAW(rd, rs1, imm)            Rtype(59, rd, 5, rs1, imm, 32)
 185 /*
 186  * RV32M Standard Extension
 187  */
 188 #  define MUL(rd, rs1, rs2)             Rtype(51, rd, 0, rs1, rs2, 1)
 189 #  define MULH(rd, rs1, rs2)            Rtype(51, rd, 1, rs1, rs2, 1)
 190 #  define MULHSU(rd, rs1, rs2)          Rtype(51, rd, 2, rs1, rs2, 1)
 191 #  define MULHU(rd, rs1, rs2)           Rtype(51, rd, 3, rs1, rs2, 1)
 192 #  define DIV(rd, rs1, rs2)             Rtype(51, rd, 4, rs1, rs2, 1)
 193 #  define DIVU(rd, rs1, rs2)            Rtype(51, rd, 5, rs1, rs2, 1)
 194 #  define REM(rd, rs1, rs2)             Rtype(51, rd, 6, rs1, rs2, 1)
 195 #  define REMU(rd, rs1, rs2)            Rtype(51, rd, 7, rs1, rs2, 1)
 196 /*
 197  * RV64M Standard Extension (in addition to RV32M)
 198  */
 199 #  define MULW(rd, rs1, rs2)            Rtype(59, rd, 0, rs1, rs2, 1)
 200 #  define DIVW(rd, rs1, rs2)            Rtype(59, rd, 4, rs1, rs2, 1)
 201 #  define DIVUW(rd, rs1, rs2)           Rtype(59, rd, 5, rs1, rs2, 1)
 202 #  define REMW(rd, rs1, rs2)            Rtype(59, rd, 6, rs1, rs2, 1)
 203 #  define REMUW(rd, rs1, rs2)           Rtype(59, rd, 7, rs1, rs2, 1)
 204 /*
 205  * RV32A Standard Extension
 206  */
 207 #  define LR_W(rd, rs1)                 R4type(47, rd, 2, rs1, 0, 0, 2)
 208 #  define SC_W(rd, rs1, rs2)            R4type(47, rd, 2, rs1, rs2, 0, 3)
 209 #  define AMOSWAP_W(rd, rs1, rs2)       R4type(47, rd, 2, rs1, rs2, 0, 1)
 210 #  define AMOADD_W(rd, rs1, rs2)        R4type(47, rd, 2, rs1, rs2, 0, 0)
 211 #  define AMOXOR_W(rd, rs1, rs2)        R4type(47, rd, 2, rs1, rs2, 0, 4)
 212 #  define AMOAND_W(rd, rs1, rs2)        R4type(47, rd, 2, rs1, rs2, 0, 12)
 213 #  define AMOOR_W(rd, rs1, rs2)         R4type(47, rd, 2, rs1, rs2, 0, 8)
 214 #  define AMOMIN_W(rd, rs1, rs2)        R4type(47, rd, 2, rs1, rs2, 0, 16)
 215 #  define AMOMAX_W(rd, rs1, rs2)        R4type(47, rd, 2, rs1, rs2, 0, 20)
 216 #  define AMOMINU_W(rd, rs1, rs2)       R4type(47, rd, 2, rs1, rs2, 0, 24)
 217 #  define AMOMAXU_W(rd, rs1, rs2)       R4type(47, rd, 2, rs1, rs2, 0, 28)
 218 /*
 219  * RV64A Standard Extension (in addition to RV32A)
 220  */
 221 #  define LR_D(rd, rs1)                 R4type(47, rd, 3, rs1, 0, 0, 2)
 222 #  define SC_D(rd, rs1, rs2)            R4type(47, rd, 3, rs1, rs2, 0, 3)
 223 #  define AMOSWAP_D(rd, rs1, rs2)       R4type(47, rd, 3, rs1, rs2, 0, 1)
 224 #  define AMOADD_D(rd, rs1, rs2)        R4type(47, rd, 3, rs1, rs2, 0, 0)
 225 #  define AMOXOR_D(rd, rs1, rs2)        R4type(47, rd, 3, rs1, rs2, 0, 4)
 226 #  define AMOAND_D(rd, rs1, rs2)        R4type(47, rd, 3, rs1, rs2, 0, 12)
 227 #  define AMOOR_D(rd, rs1, rs2)         R4type(47, rd, 3, rs1, rs2, 0, 8)
 228 #  define AMOMIN_D(rd, rs1, rs2)        R4type(47, rd, 3, rs1, rs2, 0, 16)
 229 #  define AMOMAX_D(rd, rs1, rs2)        R4type(47, rd, 3, rs1, rs2, 0, 20)
 230 #  define AMOMINU_D(rd, rs1, rs2)       R4type(47, rd, 3, rs1, rs2, 0, 24)
 231 #  define AMOMAXU_D(rd, rs1, rs2)       R4type(47, rd, 3, rs1, rs2, 0, 28)
 232 /*
 233  * Pseudo Instructions
 234  */
 235 #  define NOP()                         ADDI(_ZERO_REGNO, _ZERO_REGNO, 0)
 236 #  define MV(r0, r1)                    ADDI(r0, r1, 0)
 237 #  define NOT(r0, r1)                   XORI(r0, r1, -1)
 238 #  define NEG(r0, r1)                   SUB(r0, _ZERO_REGNO, r1)
 239 #  define NEGW(r0, r1)                  SUBW(r0, _ZERO_REGNO, r1)
 240 #  define SEXT_W(r0, r1)                ADDIW(r0, r1, 0)
 241 #  define RET()                         JALR(0, 1, 0)
 242
 243 /*
 244  * Enconding functions
 245  */
 246 #  define Rtype(op, rd, fct, rs1, rs2, fct2)                    \
 247         _Rtype(_jit, op, rd, fct, rs1, rs2, fct2)
 248 static void _Rtype(jit_state_t*, jit_int32_t, jit_int32_t,
 249                    jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 250 #  define R4type(op, rd, fct, rs1,rs2,fct2,rs3)                 \
 251         _R4type(_jit, op, rd, fct, rs1, rs2, fct2, rs3)
 252 static void _R4type(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t,
 253                     jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
 254 #  define Itype(op, rd, fct, rs1, imm)                          \
 255         _Itype(_jit, op, rd, fct, rs1, imm)
 256 static void _Itype(jit_state_t*, jit_int32_t, jit_int32_t,
 257                    jit_int32_t, jit_int32_t, jit_int32_t);
 258 #  if __WORDSIZE == 64
 259 #  define IStype(op, rd, fct, rs1, sh, imm)                     \
 260         _IStype(_jit, op, rd, fct, rs1, sh, imm)
 261 static void _IStype(jit_state_t*, jit_int32_t, jit_int32_t,
 262                    jit_int32_t, jit_int32_t, jit_int32_t,jit_int32_t);
 263 #  endif
 264 #  define Stype(op, fct, rs1, rs2, imm)                         \
 265         _Stype(_jit, op, fct, rs1, rs2, imm)
 266 static void _Stype(jit_state_t*, jit_int32_t, jit_int32_t,
 267                    jit_int32_t, jit_int32_t, jit_int32_t);
 268 #  define Btype(op, fct, rs1, rs2, imm)                         \
 269         _Btype(_jit, op, fct, rs1, rs2, imm)
 270 static void _Btype(jit_state_t*, jit_int32_t, jit_int32_t,
 271                    jit_int32_t, jit_int32_t, jit_int32_t);
 272 #  define Utype(op, rd, imm)            _Utype(_jit, op, rd, imm)
 273 static void _Utype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 274 #  define Jtype(op, rd, imm)            _Jtype(_jit, op, rd, imm)
 275 static void _Jtype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
 276 /*
 277  * Lightning instructions
 278  */
 279 #  define nop(im)                       _nop(_jit, im)
 280 static void _nop(jit_state_t*, jit_int32_t);
 281 #  define addr(r0, r1, r2)              ADD(r0, r1, r2)
 282 #  define addi(r0, r1, im)              _addi(_jit, r0, r1, im)
 283 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 284 #  define addcr(r0, r1, r2)             _addcr(_jit, r0, r1, r2)
 285 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 286 #  define addci(r0, r1, im)             _addci(_jit, r0, r1, im)
 287 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 288 #  define addxr(r0, r1, r2)             _addxr(_jit, r0, r1, r2)
 289 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 290 #  define addxi(r0, r1, im)             _addxi(_jit, r0, r1, im)
 291 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 292 #  define subr(r0, r1, r2)              SUB(r0, r1, r2)
 293 #  define subi(r0, r1, im)              _subi(_jit, r0, r1, im)
 294 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 295 #  define subcr(r0, r1, r2)             _subcr(_jit, r0, r1, r2)
 296 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 297 #  define subci(r0, r1, im)             _subci(_jit, r0, r1, im)
 298 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 299 #  define subxr(r0, r1, r2)             _subxr(_jit, r0, r1, r2)
 300 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 301 #  define subxi(r0, r1, im)             _subxi(_jit, r0, r1, im)
 302 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 303 #  define rsbi(r0, r1, im)              _rsbi(_jit, r0, r1, im)
 304 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 305 #  define mulr(r0, r1, r2)              MUL(r0, r1, r2)
 306 #  define muli(r0, r1, im)              _muli(_jit, r0, r1, im)
 307 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 308 #  define divr(r0, r1, r2)              DIV(r0, r1, r2)
 309 #  define divi(r0, r1, im)              _divi(_jit, r0, r1, im)
 310 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 311 #  define divr_u(r0, r1, r2)            DIVU(r0, r1, r2)
 312 #  define divi_u(r0, r1, im)            _divi_u(_jit, r0, r1, im)
 313 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 314 #  define remr(r0, r1, r2)              REM(r0, r1, r2)
 315 #  define remi(r0, r1, im)              _remi(_jit, r0, r1, im)
 316 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 317 #  define remr_u(r0, r1, r2)            REMU(r0, r1, r2)
 318 #  define remi_u(r0, r1, im)            _remi_u(_jit, r0, r1, im)
 319 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 320 #  define qmulr(r0, r1, r2, r3)         _qmulr(_jit,r0,r1,r2,r3)
 321 static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 322 #  define qmuli(r0, r1, r2, i0)         _qmuli(_jit,r0,r1,r2,i0)
 323 static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 324 #  define qmulr_u(r0, r1, r2, r3)       _qmulr_u(_jit,r0,r1,r2,r3)
 325 static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 326 #  define qmuli_u(r0, r1, r2, i0)       _qmuli_u(_jit,r0,r1,r2,i0)
 327 static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
 328 static void _iqdivr(jit_state_t*,jit_bool_t,
 329                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 330 #  define qdivr(r0,r1,r2,r3)            _iqdivr(_jit,1,r0,r1,r2,r3)
 331 #  define qdivr_u(r0,r1,r2,r3)          _iqdivr(_jit,0,r0,r1,r2,r3)
 332 static void _iqdivr(jit_state_t*,jit_bool_t,
 333                     jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
 334 #  define qdivi(r0,r1,r2,i0)            _qdivi(_jit,r0,r1,r2,i0)
 335 static void _qdivi(jit_state_t*,jit_int32_t,
 336                    jit_int32_t,jit_int32_t,jit_word_t);
 337 #  define qdivi_u(r0,r1,r2,i0)          _qdivi_u(_jit,r0,r1,r2,i0)
 338 static void _qdivi_u(jit_state_t*,jit_int32_t,
 339                      jit_int32_t,jit_int32_t,jit_word_t);
 340 #  define lshr(r0, r1, r2)              SLL(r0, r1, r2)
 341 #  define lshi(r0, r1, im)              _lshi(_jit, r0, r1, im)
 342 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 343 #  define rshr(r0, r1, r2)              SRA(r0, r1, r2)
 344 #  define rshi(r0, r1, im)              _rshi(_jit, r0, r1, im)
 345 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 346 #  define rshr_u(r0, r1, r2)            SRL(r0, r1, r2)
 347 #  define rshi_u(r0, r1, im)            _rshi_u(_jit, r0, r1, im)
 348 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 349 #  define negr(r0, r1)                  NEG(r0, r1)
 350 #  define comr(r0, r1)                  NOT(r0, r1)
 351 #  define andr(r0, r1, r2)              AND(r0, r1, r2)
 352 #  define andi(r0, r1, im)              _andi(_jit, r0, r1, im)
 353 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 354 #  define orr(r0, r1, r2)               OR(r0, r1, r2)
 355 #  define ori(r0, r1, im)               _ori(_jit, r0, r1, im)
 356 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 357 #  define xorr(r0, r1, r2)              XOR(r0, r1, r2)
 358 #  define xori(r0, r1, im)              _xori(_jit, r0, r1, im)
 359 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 360 #  define ldr_c(r0, r1)                 LB(r0, r1, 0)
 361 #  define ldi_c(r0, im)                 _ldi_c(_jit, r0, im)
 362 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
 363 #  define ldr_uc(r0, r1)                LBU(r0, r1, 0)
 364 #  define ldi_uc(r0, im)                _ldi_uc(_jit, r0, im)
 365 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
 366 #  define ldr_s(r0, r1)                 LH(r0, r1, 0)
 367 #  define ldi_s(r0, im)                 _ldi_s(_jit, r0, im)
 368 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
 369 #  define ldr_us(r0, r1)                LHU(r0, r1, 0)
 370 #  define ldi_us(r0, im)                _ldi_us(_jit, r0, im)
 371 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
 372 #  define ldr_i(r0, r1)                 LW(r0, r1, 0)
 373 #  define ldi_i(r0, im)                 _ldi_i(_jit, r0, im)
 374 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
 375 #  define ldr_ui(r0, r1)                LWU(r0, r1, 0)
 376 #  define ldi_ui(r0, im)                _ldi_ui(_jit, r0, im)
 377 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
 378 #  define ldr_l(r0, r1)                 LD(r0, r1, 0)
 379 #  define ldi_l(r0, im)                 _ldi_l(_jit, r0, im)
 380 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
 381 #  define ldxr_c(r0, r1, r2)            _ldxr_c(_jit, r0, r1, r2)
 382 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 383 #  define ldxi_c(r0, r1, im)            _ldxi_c(_jit, r0, r1, im)
 384 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 385 #  define ldxr_uc(r0, r1, r2)           _ldxr_uc(_jit, r0, r1, r2)
 386 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 387 #  define ldxi_uc(r0, r1, im)           _ldxi_uc(_jit, r0, r1, im)
 388 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 389 #  define ldxr_s(r0, r1, r2)            _ldxr_s(_jit, r0, r1, r2)
 390 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 391 #  define ldxi_s(r0, r1, im)            _ldxi_s(_jit, r0, r1, im)
 392 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 393 #  define ldxr_us(r0, r1, r2)           _ldxr_us(_jit, r0, r1, r2)
 394 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 395 #  define ldxi_us(r0, r1, im)           _ldxi_us(_jit, r0, r1, im)
 396 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 397 #  define ldxr_i(r0, r1, r2)            _ldxr_i(_jit, r0, r1, r2)
 398 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 399 #  define ldxi_i(r0, r1, im)            _ldxi_i(_jit, r0, r1, im)
 400 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 401 #  define ldxr_ui(r0, r1, r2)           _ldxr_ui(_jit, r0, r1, r2)
 402 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 403 #  define ldxi_ui(r0, r1, im)           _ldxi_ui(_jit, r0, r1, im)
 404 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 405 #  define ldxr_l(r0, r1, r2)            _ldxr_l(_jit, r0, r1, r2)
 406 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 407 #  define ldxi_l(r0, r1, im)            _ldxi_l(_jit, r0, r1, im)
 408 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 409 #  define str_c(r0, r1)                 SB(r0, r1, 0)
 410 #  define sti_c(im, r0)                 _sti_c(_jit, im, r0)
 411 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
 412 #  define str_s(r0, r1)                 SH(r0, r1, 0)
 413 #  define sti_s(im, r0)                 _sti_s(_jit, im, r0)
 414 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
 415 #  define str_i(r0, r1)                 SW(r0, r1, 0)
 416 #  define sti_i(im, r0)                 _sti_i(_jit, im, r0)
 417 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
 418 #  define str_l(r0, r1)                 SD(r0, r1, 0)
 419 #  define sti_l(im, r0)                 _sti_l(_jit, im, r0)
 420 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
 421 #  define stxr_c(r0, r1, r2)            _stxr_c(_jit, r0, r1, r2)
 422 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 423 #  define stxi_c(i0, r0, r1)            _stxi_c(_jit, i0, r0, r1)
 424 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 425 #  define stxr_s(r0, r1, r2)            _stxr_s(_jit, r0, r1, r2)
 426 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 427 #  define stxi_s(i0, r0, r1)            _stxi_s(_jit, i0, r0, r1)
 428 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 429 #  define stxr_i(r0, r1, r2)            _stxr_i(_jit, r0, r1, r2)
 430 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 431 #  define stxi_i(i0, r0, r1)            _stxi_i(_jit, i0, r0, r1)
 432 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 433 #  define stxr_l(r0, r1, r2)            _stxr_l(_jit, r0, r1, r2)
 434 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 435 #  define stxi_l(i0, r0, r1)            _stxi_l(_jit, i0, r0, r1)
 436 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 437 #  define bswapr_us(r0, r1)             generic_bswapr_us(_jit, r0, r1)
 438 #  define bswapr_ui(r0, r1)             generic_bswapr_ui(_jit, r0, r1)
 439 #  define bswapr_ul(r0, r1)             generic_bswapr_ul(_jit, r0, r1)
 440 #  define extr_c(r0, r1)                _extr_c(_jit, r0, r1)
 441 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
 442 #  define extr_uc(r0, r1)               andi(r0, r1, 0xff)
 443 #  define extr_s(r0, r1)                _extr_s(_jit, r0, r1)
 444 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
 445 #  define extr_us(r0, r1)               _extr_us(_jit, r0, r1)
 446 static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
 447 #  define extr_i(r0, r1)                SEXT_W(r0, r1)
 448 #  define extr_ui(r0, r1)               _extr_ui(_jit, r0, r1)
 449 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
 450 #  define movr(r0, r1)                  MV(r0, r1)
 451 #  define movi(r0, im)                  _movi(_jit, r0, im)
 452 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
 453 #  define movi_p(r0, im)                _movi_p(_jit, r0, im)
 454 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
 455 #  define movnr(r0,r1,r2)               _movnr(_jit,r0,r1,r2)
 456 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 457 #  define movzr(r0,r1,r2)               _movzr(_jit,r0,r1,r2)
 458 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 459   define casx(r0, r1, r2, r3, i0)       _casx(_jit, r0, r1, r2, r3, i0)
 460 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
 461                   jit_int32_t,jit_int32_t,jit_word_t);
 462 #define casr(r0, r1, r2, r3)            casx(r0, r1, r2, r3, 0)
 463 #define casi(r0, i0, r1, r2)            casx(r0, _NOREG, r1, r2, i0)
 464 #  define ltr(r0, r1, r2)               SLT(r0, r1, r2)
 465 #  define lti(r0, r1, im)               _lti(_jit, r0, r1, im)
 466 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 467 #  define ltr_u(r0, r1, r2)             SLTU(r0, r1, r2)
 468 #  define lti_u(r0, r1, im)             _lti_u(_jit, r0, r1, im)
 469 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 470 #  define ler(r0, r1, r2)               _ler(_jit, r0, r1, r2)
 471 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 472 #  define lei(r0, r1, im)               _lei(_jit, r0, r1, im)
 473 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 474 #  define ler_u(r0, r1, r2)             _ler_u(_jit, r0, r1, r2)
 475 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 476 #  define lei_u(r0, r1, im)             _lei_u(_jit, r0, r1, im)
 477 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 478 #  define eqr(r0, r1, r2)               _eqr(_jit, r0, r1, r2)
 479 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 480 #  define eqi(r0, r1, im)               _eqi(_jit, r0, r1, im)
 481 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 482 #  define ger(r0, r1, r2)               _ger(_jit, r0, r1, r2)
 483 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 484 #  define gei(r0, r1, r2)               _gei(_jit, r0, r1, r2)
 485 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 486 #  define ger_u(r0, r1, r2)             _ger_u(_jit, r0, r1, r2)
 487 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 488 #  define gei_u(r0, r1, im)             _gei_u(_jit, r0, r1, im)
 489 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 490 #  define gtr(r0, r1, r2)               SLT(r0, r2, r1)
 491 #  define gti(r0, r1, im)               _gti(_jit, r0, r1, im)
 492 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 493 #  define gtr_u(r0, r1, r2)             SLTU(r0, r2, r1)
 494 #  define gti_u(r0, r1, im)             _gti_u(_jit, r0, r1, im)
 495 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 496 #  define ner(r0, r1, r2)               _ner(_jit, r0, r1, r2)
 497 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 498 #  define nei(r0, r1, im)               _nei(_jit, r0, r1, im)
 499 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 500 #  define bltr(br, r0, r1)              _bltr(_jit, br, r0, r1)
 501 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 502 #  define blti(br, r0, im)              _blti(_jit, br, r0, im)
 503 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 504 #  define bltr_u(br, r0, r1)            _bltr_u(_jit, br, r0, r1)
 505 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 506 #  define blti_u(br, r0, im)            _blti_u(_jit, br, r0, im)
 507 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 508 #  define bler(br, r0, r1)              _bler(_jit, br, r0, r1)
 509 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 510 #  define blei(br, r0, im)              _blei(_jit, br, r0, im)
 511 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 512 #  define bler_u(br, r0, r1)            _bler_u(_jit, br, r0, r1)
 513 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 514 #  define blei_u(br, r0, im)            _blei_u(_jit, br, r0, im)
 515 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 516 #  define beqr(br, r0, r1)              _beqr(_jit, br, r0, r1)
 517 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 518 #  define beqi(br, r0, im)              _beqi(_jit, br, r0, im)
 519 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 520 #  define bger(br, r0, r1)              _bger(_jit, br, r0, r1)
 521 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 522 #  define bgei(br, r0, im)              _bgei(_jit, br, r0, im)
 523 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 524 #  define bger_u(br, r0, r1)            _bger_u(_jit, br, r0, r1)
 525 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 526 #  define bgei_u(br, r0, im)            _bgei_u(_jit, br, r0, im)
 527 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 528 #  define bgtr(br, r0, r1)              _bgtr(_jit, br, r0, r1)
 529 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 530 #  define bgti(br, r0, im)              _bgti(_jit, br, r0, im)
 531 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 532 #  define bgtr_u(br, r0, r1)            _bgtr_u(_jit, br, r0, r1)
 533 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 534 #  define bgti_u(br, r0, im)            _bgti_u(_jit, br, r0, im)
 535 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 536 #  define bner(br, r0, r1)              _bner(_jit, br, r0, r1)
 537 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 538 #  define bnei(br, r0, im)              _bnei(_jit, br, r0, im)
 539 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 540 #  define boaddr(br, r0, r1)            _boaddr(_jit, br, r0, r1)
 541 #  define boaddi(br, r0, im)            _boaddi(_jit, br, r0, im)
 542 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 543 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 544 #  define boaddr_u(br, r0, r1)          _boaddr_u(_jit, br, r0, r1)
 545 #  define boaddi_u(br, r0, im)          _boaddi_u(_jit, br, r0, im)
 546 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 547 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 548 #  define bxaddr(br, r0, r1)            _bxaddr(_jit, br, r0, r1)
 549 #  define bxaddi(br, r0, im)            _bxaddi(_jit, br, r0, im)
 550 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 551 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 552 #  define bxaddr_u(br, r0, r1)          _bxaddr_u(_jit, br, r0, r1)
 553 #  define bxaddi_u(br, r0, im)          _bxaddi_u(_jit, br, r0, im)
 554 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 555 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 556 #  define bosubr(br, r0, r1)            _bosubr(_jit, br, r0, r1)
 557 #  define bosubi(br, r0, im)            _bosubi(_jit, br, r0, im)
 558 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 559 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 560 #  define bosubr_u(br, r0, r1)          _bosubr_u(_jit, br, r0, r1)
 561 #  define bosubi_u(br, r0, im)          _bosubi_u(_jit, br, r0, im)
 562 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 563 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 564 #  define bxsubr(br, r0, r1)            _bxsubr(_jit, br, r0, r1)
 565 #  define bxsubi(br, r0, im)            _bxsubi(_jit, br, r0, im)
 566 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 567 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 568 #  define bxsubr_u(br, r0, r1)          _bxsubr_u(_jit, br, r0, r1)
 569 #  define bxsubi_u(br, r0, im)          _bxsubi_u(_jit, br, r0, im)
 570 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 571 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 572 #  define bmsr(br, r0, r1)              _bmsr(_jit, br, r0, r1)
 573 #  define bmsi(br, r0, im)              _bmsi(_jit, br, r0, im)
 574 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 575 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 576 #  define bmcr(br, r0, r1)              _bmcr(_jit, br, r0, r1)
 577 #  define bmci(br, r0, im)              _bmci(_jit, br, r0, im)
 578 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 579 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 580 #  define jmpr(r0)                      JALR(_ZERO_REGNO, r0, 0)
 581 #  define jmpi(im)                      _jmpi(_jit, im)
 582 static void _jmpi(jit_state_t*,jit_word_t);
 583 #  define jmpi_p(im)                    _jmpi_p(_jit, im)
 584 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 585 #  define callr(r0)                     JALR(_RA_REGNO, r0, 0)
 586 #  define calli(im)                     _calli(_jit, im)
 587 static void _calli(jit_state_t*,jit_word_t);
 588 #  define calli_p(im)           _calli_p(_jit, im)
 589 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 590 #  define prolog(i0)                    _prolog(_jit,i0)
 591 static void _prolog(jit_state_t*,jit_node_t*);
 592 #  define epilog(i0)                    _epilog(_jit,i0)
 593 static void _epilog(jit_state_t*,jit_node_t*);
 594 #  define vastart(r0)                   _vastart(_jit, r0)
 595 static void _vastart(jit_state_t*, jit_int32_t);
 596 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
 597 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 598 #define patch_abs(instr,label)          _patch_at(_jit,instr,label)
 599 #define patch_at(instr,label)           _patch_at(_jit,instr,label)
 600 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 601 #endif          /* PROTO */
 602
 603 #if CODE
 604 static void
 605 _Rtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
 606        jit_int32_t fct, jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2)
 607 {
 608     instr_t     i;
 609     assert(!(op   & ~0x7f));
 610     assert(!(rd   & ~0x1f));
 611     assert(!(fct  & ~0x07));
 612     assert(!(rs1  & ~0x1f));
 613     assert(!(rs2  & ~0x1f));
 614     assert(!(fct2 & ~0x7f));
 615     i.R.opcode  = op;
 616     i.R.rd      = rd;
 617     i.R.funct3  = fct;
 618     i.R.rs1     = rs1;
 619     i.R.rs2     = rs2;
 620     i.R.funct7  = fct2;
 621     ii(i.w);
 622 }
 623
 624 static void
 625 _R4type(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t fct,
 626         jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2, jit_int32_t rs3)
 627 {
 628     instr_t     i;
 629     assert(!(op   & ~0x7f));
 630     assert(!(rd   & ~0x1f));
 631     assert(!(fct  & ~0x07));
 632     assert(!(rs1  & ~0x1f));
 633     assert(!(rs2  & ~0x1f));
 634     assert(!(fct2 & ~0x03));
 635     assert(!(rs3  & ~0x1f));
 636     i.R4.opcode = op;
 637     i.R4.rd     = rd;
 638     i.R4.funct3 = fct;
 639     i.R4.rs1    = rs1;
 640     i.R4.rs2    = rs2;
 641     i.R4.funct2 = fct2;
 642     i.R4.rs3    = rs3;
 643     ii(i.w);
 644 }
 645
 646 static void
 647 _Itype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
 648        jit_int32_t fct, jit_int32_t rs1, jit_int32_t imm)
 649 {
 650     instr_t     i;
 651     assert(!(op  &  ~0x7f));
 652     assert(!(rd  &  ~0x1f));
 653     assert(!(fct &  ~0x07));
 654     assert(!(rs1 &  ~0x1f));
 655     assert(simm12_p(imm));
 656     i.I.opcode  = op;
 657     i.I.rd      = rd;
 658     i.I.funct3  = fct;
 659     i.I.rs1     = rs1;
 660     i.I.imm11_0 = imm;
 661     ii(i.w);
 662 }
 663
 664 #  if __WORDSIZE == 64
 665 static void
 666 _IStype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
 667        jit_int32_t fct, jit_int32_t rs1, jit_int32_t sh, jit_int32_t imm)
 668 {
 669     instr_t     i;
 670     assert(!(op  &  ~0x7f));
 671     assert(!(rd  &  ~0x1f));
 672     assert(!(fct &  ~0x07));
 673     assert(!(rs1 &  ~0x1f));
 674     assert(!(sh  &  ~0x3f));
 675     assert(simm6_p(imm));
 676     i.IS.opcode = op;
 677     i.IS.rd     = rd;
 678     i.IS.funct3 = fct;
 679     i.IS.rs1    = rs1;
 680     i.IS.shamt  = sh;
 681     i.IS.imm6_0 = imm;
 682     ii(i.w);
 683 }
 684 #  endif
 685
 686 static void
 687 _Stype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
 688        jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
 689 {
 690     instr_t     i;
 691     assert(!(op  &  ~0x7f));
 692     assert(!(fct &  ~0x07));
 693     assert(!(rs1 &  ~0x1f));
 694     assert(!(rs2 &  ~0x1f));
 695     assert(simm12_p(imm));
 696     i.S.opcode  = op;
 697     i.S.imm4_0  = imm & 0x1f;
 698     i.S.funct3  = fct;
 699     i.S.rs1     = rs1;
 700     i.S.rs2     = rs2;
 701     i.S.imm11_5 = (imm >> 5) & 0x7f;
 702     ii(i.w);
 703 }
 704
 705 static void
 706 _Btype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
 707        jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
 708 {
 709     instr_t     i;
 710     assert(!(op  & ~0x7f));
 711     assert(!(fct & ~0x07));
 712     assert(!(rs1 & ~0x1f));
 713     assert(!(rs2 & ~0x1f));
 714     assert(!(imm & 1) && simm12_p(imm));
 715     i.B.opcode  = op;
 716     i.B.imm11   = (imm >> 11) & 0x1;
 717     i.B.imm4_1  = (imm >>  1) & 0xf;
 718     i.B.funct3  = fct;
 719     i.B.rs1     = rs1;
 720     i.B.rs2     = rs2;
 721     i.B.imm10_5 = (imm >>  5) & 0x3f;
 722     i.B.imm12   = (imm >> 12) & 0x1;
 723     ii(i.w);
 724 }
 725
 726 static void
 727 _Utype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
 728 {
 729     instr_t     i;
 730     assert(!(op & ~0x7f));
 731     assert(!(rd & ~0x1f));
 732     assert(simm20_p(imm));
 733     i.U.opcode  = op;
 734     i.U.rd      = rd;
 735     i.U.imm12_31= imm;
 736     ii(i.w);
 737 }
 738
 739 static void
 740 _Jtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
 741 {
 742     instr_t     i;
 743     assert(!(op & ~0x7f));
 744     assert(!(rd & ~0x1f));
 745     assert(!(imm & 1) && imm <= 1048575 && imm >= -1048576);
 746     i.J.opcode  = op;
 747     i.J.rd      = rd;
 748     i.J.imm19_12= (imm >> 12) &  0xff;
 749     i.J.imm11   = (imm >> 11) &   0x1;
 750     i.J.imm10_1 = (imm >>  1) & 0x3ff;
 751     i.J.imm20   = (imm >> 20) &   0x1;
 752     ii(i.w);
 753 }
 754
 755 static void
 756 _nop(jit_state_t *_jit, jit_int32_t im)
 757 {
 758     for (; im > 0; im -= 4)
 759         NOP();
 760     assert(im == 0);
 761 }
 762
 763 static void
 764 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 765 {
 766     if (simm12_p(i0))
 767         ADDI(r0, r1, i0);
 768     else {
 769         jit_int32_t     t0;
 770         t0 = jit_get_reg(jit_class_gpr);
 771         movi(rn(t0), i0);
 772         addr(r0, r1, rn(t0));
 773         jit_unget_reg(t0);
 774     }
 775 }
 776
 777 static void
 778 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 779 {
 780     jit_int32_t         t0;
 781     if (jit_carry == _NOREG)
 782         jit_carry = jit_get_reg(jit_class_gpr);
 783     if (r0 == r1) {
 784         t0 = jit_get_reg(jit_class_gpr);
 785         addr(rn(t0), r1, r2);
 786         SLTU(rn(jit_carry), rn(t0), r1);
 787         movr(r0, rn(t0));
 788         jit_unget_reg(t0);
 789     }
 790     else {
 791         addr(r0, r1, r2);
 792         SLTU(rn(jit_carry), r0, r1);
 793     }
 794 }
 795
 796 static void
 797 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 798 {
 799     jit_int32_t         t0;
 800     if (jit_carry == _NOREG)
 801         jit_carry = jit_get_reg(jit_class_gpr);
 802     if (r0 == r1) {
 803         t0 = jit_get_reg(jit_class_gpr);
 804         addi(rn(t0), r1, i0);
 805         SLTU(rn(jit_carry), rn(t0), r1);
 806         movr(r0, rn(t0));
 807         jit_unget_reg(t0);
 808     }
 809     else {
 810         addi(r0, r1, i0);
 811         SLTU(rn(jit_carry), r0, r1);
 812     }
 813 }
 814
 815 static void
 816 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 817 {
 818     jit_int32_t         t0;
 819     assert(jit_carry != _NOREG);
 820     t0 = jit_get_reg(jit_class_gpr);
 821     movr(rn(t0), rn(jit_carry));
 822     addcr(r0, r1, r2);
 823     addcr(r0, r0, rn(t0));
 824     jit_unget_reg(t0);
 825 }
 826
 827 static void
 828 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 829 {
 830     jit_int32_t         t0;
 831     assert(jit_carry != _NOREG);
 832     t0 = jit_get_reg(jit_class_gpr);
 833     movr(rn(t0), rn(jit_carry));
 834     addci(r0, r1, i0);
 835     addcr(r0, r0, rn(t0));
 836     jit_unget_reg(t0);
 837 }
 838
 839 static void
 840 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 841 {
 842     if (simm12_p(-i0))
 843         ADDI(r0, r1, -i0);
 844     else {
 845         jit_int32_t     t0;
 846         t0 = jit_get_reg(jit_class_gpr);
 847         movi(rn(t0), i0);
 848         subr(r0, r1, rn(t0));
 849         jit_unget_reg(t0);
 850     }
 851 }
 852
 853 static void
 854 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 855 {
 856     jit_int32_t         t0;
 857     if (jit_carry == _NOREG)
 858         jit_carry = jit_get_reg(jit_class_gpr);
 859     if (r0 == r1) {
 860         t0 = jit_get_reg(jit_class_gpr);
 861         subr(rn(t0), r1, r2);
 862         SLTU(rn(jit_carry), r1, rn(t0));
 863         movr(r0, rn(t0));
 864         jit_unget_reg(t0);
 865     }
 866     else {
 867         subr(r0, r1, r2);
 868         SLTU(rn(jit_carry), r1, r0);
 869     }
 870 }
 871
 872 static void
 873 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 874 {
 875     jit_int32_t         t0;
 876     if (jit_carry == _NOREG)
 877         jit_carry = jit_get_reg(jit_class_gpr);
 878     if (r0 == r1) {
 879         t0 = jit_get_reg(jit_class_gpr);
 880         subi(rn(t0), r1, i0);
 881         SLTU(rn(jit_carry), r1, rn(t0));
 882         movr(r0, rn(t0));
 883         jit_unget_reg(t0);
 884     }
 885     else {
 886         subi(r0, r1, i0);
 887         SLTU(rn(jit_carry), r1, r0);
 888     }
 889 }
 890
 891 static void
 892 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 893 {
 894     jit_int32_t         t0;
 895     assert(jit_carry != _NOREG);
 896     t0 = jit_get_reg(jit_class_gpr);
 897     movr(rn(t0), rn(jit_carry));
 898     subcr(r0, r1, r2);
 899     subcr(r0, r0, rn(t0));
 900     jit_unget_reg(t0);
 901 }
 902
 903 static void
 904 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 905 {
 906     jit_int32_t         t0;
 907     assert(jit_carry != _NOREG);
 908     t0 = jit_get_reg(jit_class_gpr);
 909     movr(rn(t0), rn(jit_carry));
 910     subci(r0, r1, i0);
 911     subcr(r0, r0, rn(t0));
 912     jit_unget_reg(t0);
 913 }
 914
 915 static void
 916 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 917 {
 918     subi(r0, r1, i0);
 919     negr(r0, r0);
 920 }
 921
 922 static void
 923 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 924 {
 925     jit_int32_t         t0;
 926     t0 = jit_get_reg(jit_class_gpr);
 927     movi(rn(t0), i0);
 928     mulr(r0, r1, rn(t0));
 929     jit_unget_reg(t0);
 930 }
 931
 932 static void
 933 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 934 {
 935     jit_int32_t         t0;
 936     t0 = jit_get_reg(jit_class_gpr);
 937     movi(rn(t0), i0);
 938     divr(r0, r1, rn(t0));
 939     jit_unget_reg(t0);
 940 }
 941
 942 static void
 943 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 944 {
 945     jit_int32_t         t0;
 946     t0 = jit_get_reg(jit_class_gpr);
 947     movi(rn(t0), i0);
 948     divr_u(r0, r1, rn(t0));
 949     jit_unget_reg(t0);
 950 }
 951
 952 static void
 953 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 954 {
 955     jit_int32_t         t0;
 956     t0 = jit_get_reg(jit_class_gpr);
 957     movi(rn(t0), i0);
 958     remr(r0, r1, rn(t0));
 959     jit_unget_reg(t0);
 960 }
 961
 962 static void
 963 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 964 {
 965     jit_int32_t         t0;
 966     t0 = jit_get_reg(jit_class_gpr);
 967     movi(rn(t0), i0);
 968     remr_u(r0, r1, rn(t0));
 969     jit_unget_reg(t0);
 970 }
 971
 972 static void
 973 _qmulr(jit_state_t *_jit, jit_int32_t r0,
 974        jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 975 {
 976     jit_int32_t         t0;
 977     if (r0 == r2 || r0 == r3) {
 978         t0 = jit_get_reg(jit_class_gpr);
 979         mulr(rn(t0), r2, r3);
 980     }
 981     else
 982         mulr(r0, r2, r3);
 983     MULH(r1, r2, r3);
 984     if (r0 == r2 || r0 == r3) {
 985         movr(r0, rn(t0));
 986         jit_unget_reg(t0);
 987     }
 988 }
 989
 990 static void
 991 _qmuli(jit_state_t *_jit, jit_int32_t r0,
 992        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 993 {
 994     jit_int32_t         t0;
 995     t0 = jit_get_reg(jit_class_gpr);
 996     movi(rn(t0), i0);
 997     qmulr(r0, r1, r2, rn(t0));
 998     jit_unget_reg(t0);
 999 }
1000
1001 static void
1002 _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
1003          jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1004 {
1005     jit_int32_t         t0;
1006     if (r0 == r2 || r0 == r3) {
1007         t0 = jit_get_reg(jit_class_gpr);
1008         mulr(rn(t0), r2, r3);
1009     }
1010     else
1011         mulr(r0, r2, r3);
1012     MULHU(r1, r2, r3);
1013     if (r0 == r2 || r0 == r3) {
1014         movr(r0, rn(t0));
1015         jit_unget_reg(t0);
1016     }
1017 }
1018
1019 static void
1020 _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
1021          jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1022 {
1023     jit_int32_t         t0;
1024     t0 = jit_get_reg(jit_class_gpr);
1025     movi(rn(t0), i0);
1026     qmulr_u(r0, r1, r2, rn(t0));
1027     jit_unget_reg(t0);
1028 }
1029
1030 static void
1031 _iqdivr(jit_state_t *_jit, jit_bool_t sign,
1032         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1033 {
1034     jit_int32_t         sv0, rg0;
1035     jit_int32_t         sv1, rg1;
1036     if (r0 == r2 || r0 == r3) {
1037         sv0 = jit_get_reg(jit_class_gpr);
1038         rg0 = rn(sv0);
1039     }
1040     else
1041         rg0 = r0;
1042     if (r1 == r2 || r1 == r3) {
1043         sv1 = jit_get_reg(jit_class_gpr);
1044         rg1 = rn(sv1);
1045     }
1046     else
1047         rg1 = r1;
1048     if (sign)
1049         divr(rg0, r2, r3);
1050     else
1051         divr_u(rg0, r2, r3);
1052     mulr(rg1, r3, rg0);
1053     subr(rg1, r2, rg1);
1054     if (rg0 != r0) {
1055         movr(r0, rg0);
1056         jit_unget_reg(sv0);
1057     }
1058     if (rg1 != r1) {
1059         movr(r1, rg1);
1060         jit_unget_reg(sv1);
1061     }
1062 }
1063
1064 static void
1065 _qdivi(jit_state_t *_jit, jit_int32_t r0,
1066        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1067 {
1068     jit_int32_t         t0;
1069     t0 = jit_get_reg(jit_class_gpr);
1070     movi(rn(t0), i0);
1071     qdivr(r0, r1, r2, rn(t0));
1072     jit_unget_reg(t0);
1073 }
1074
1075 static void
1076 _qdivi_u(jit_state_t *_jit, jit_int32_t r0,
1077          jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1078 {
1079     jit_int32_t         t0;
1080     t0 = jit_get_reg(jit_class_gpr);
1081     movi(rn(t0), i0);
1082     qdivr_u(r0, r1, r2, rn(t0));
1083     jit_unget_reg(t0);
1084 }
1085
1086 static void
1087 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1088 {
1089     if (i0 == 0)
1090         movr(r0, r1);
1091     else {
1092         assert(i0 > 0 && i0 < 64);
1093         SLLI(r0, r1, i0);
1094     }
1095 }
1096
1097 static void
1098 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1099 {
1100     if (i0 == 0)
1101         movr(r0, r1);
1102     else {
1103         assert(i0 > 0 && i0 < 64);
1104         SRAI(r0, r1, i0);
1105     }
1106 }
1107
1108 static void
1109 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1110 {
1111     if (i0 == 0)
1112         movr(r0, r1);
1113     else {
1114         assert(i0 > 0 && i0 < 64);
1115         SRLI(r0, r1, i0);
1116     }
1117 }
1118
1119 static void
1120 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1121 {
1122     if (simm12_p(i0))
1123         ANDI(r0, r1, i0);
1124     else {
1125         jit_int32_t     t0;
1126         t0 = jit_get_reg(jit_class_gpr);
1127         movi(rn(t0), i0);
1128         andr(r0, r1, rn(t0));
1129         jit_unget_reg(t0);
1130     }
1131 }
1132
1133 static void
1134 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1135 {
1136     if (simm12_p(i0))
1137         ORI(r0, r1, i0);
1138     else {
1139         jit_int32_t     t0;
1140         t0 = jit_get_reg(jit_class_gpr);
1141         movi(rn(t0), i0);
1142         orr(r0, r1, rn(t0));
1143         jit_unget_reg(t0);
1144     }
1145 }
1146
1147 static void
1148 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1149 {
1150     if (simm12_p(i0))
1151         XORI(r0, r1, i0);
1152     else {
1153         jit_int32_t     t0;
1154         t0 = jit_get_reg(jit_class_gpr);
1155         movi(rn(t0), i0);
1156         xorr(r0, r1, rn(t0));
1157         jit_unget_reg(t0);
1158     }
1159 }
1160
1161 #  define DEFLD(T,O)                                                    \
1162 static void                                                             \
1163 _ldi_##T(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)              \
1164 {                                                                       \
1165     if (simm12_p(i0))                                                   \
1166         L##O(r0, _ZERO_REGNO, i0);                                      \
1167     else {                                                              \
1168         jit_int32_t     t0;                                             \
1169         t0 = jit_get_reg(jit_class_gpr);                                \
1170         movi(rn(t0), i0);                                               \
1171         ldr_##T(r0, rn(t0));                                            \
1172         jit_unget_reg(t0);                                              \
1173     }                                                                   \
1174 }                                                                       \
1175                                                                         \
1176 static void                                                             \
1177 _ldxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1178 {                                                                       \
1179     jit_int32_t t0;                                                     \
1180     t0 = jit_get_reg(jit_class_gpr);                                    \
1181     addr(rn(t0), r1, r2);                                               \
1182     ldr_##T(r0, rn(t0));                                                \
1183     jit_unget_reg(t0);                                                  \
1184 }                                                                       \
1185                                                                         \
1186 static void                                                             \
1187 _ldxi_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)\
1188 {                                                                       \
1189     if (simm12_p(i0))                                                   \
1190         L##O(r0, r1, i0);                                               \
1191     else {                                                              \
1192         jit_int32_t     t0;                                             \
1193         t0 = jit_get_reg(jit_class_gpr);                                \
1194         addi(rn(t0), r1, i0);                                           \
1195         ldr_##T(r0, rn(t0));                                            \
1196         jit_unget_reg(t0);                                              \
1197     }                                                                   \
1198 }
1199
1200 DEFLD(c,B)
1201 DEFLD(uc,BU)
1202 DEFLD(s,H)
1203 DEFLD(us,HU)
1204 DEFLD(i,W)
1205 DEFLD(ui,WU)
1206 DEFLD(l,D)
1207
1208 #  define DEFST(T, O)                                                   \
1209 static void                                                             \
1210 _sti_##T(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)              \
1211 {                                                                       \
1212     if (simm12_p(i0))                                                   \
1213         S##O(_ZERO_REGNO, r0, i0);                                      \
1214     else {                                                              \
1215         jit_int32_t     t0;                                             \
1216         t0 = jit_get_reg(jit_class_gpr);                                \
1217         movi(rn(t0), i0);                                               \
1218         str_##T(rn(t0), r0);                                            \
1219         jit_unget_reg(t0);                                              \
1220     }                                                                   \
1221 }                                                                       \
1222                                                                         \
1223 static void                                                             \
1224 _stxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1225 {                                                                       \
1226     jit_int32_t t0;                                                     \
1227     t0 = jit_get_reg(jit_class_gpr);                                    \
1228     addr(rn(t0), r0, r1);                                               \
1229     str_##T(rn(t0), r2);                                                \
1230     jit_unget_reg(t0);                                                  \
1231 }                                                                       \
1232                                                                         \
1233 static void                                                             \
1234 _stxi_##T(jit_state_t *_jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)\
1235 {                                                                       \
1236     if (simm12_p(i0))                                                   \
1237         S##O(r0, r1, i0);                                               \
1238     else {                                                              \
1239         jit_int32_t     t0;                                             \
1240         t0 = jit_get_reg(jit_class_gpr);                                \
1241         addi(rn(t0), r0, i0);                                           \
1242         str_##T(rn(t0), r1);                                            \
1243         jit_unget_reg(t0);                                              \
1244     }                                                                   \
1245 }
1246
1247 DEFST(c, B)
1248 DEFST(s, H)
1249 DEFST(i, W)
1250 DEFST(l, D)
1251
1252 static void
1253 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1254 {
1255     lshi(r0, r1, 56);
1256     rshi(r0, r0, 56);
1257 }
1258
1259 static void
1260 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1261 {
1262     lshi(r0, r1, 48);
1263     rshi(r0, r0, 48);
1264 }
1265
1266 static void
1267 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1268 {
1269     lshi(r0, r1, 48);
1270     rshi_u(r0, r0, 48);
1271 }
1272
1273 static void
1274 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1275 {
1276     lshi(r0, r1, 32);
1277     rshi_u(r0, r0, 32);
1278 }
1279
1280 static void
1281 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1282 {
1283     if (simm32_p(i0)) {
1284         jit_int32_t     lo = (jit_int32_t)i0 << 20 >> 20;
1285         jit_int32_t     hi = i0 - lo;
1286         if (hi) {
1287             LUI(r0, hi >> 12);
1288             if (lo)
1289                 ADDIW(r0, r0, lo);
1290         }
1291         else
1292             ADDIW(r0, _ZERO_REGNO, lo);
1293     }
1294     else {
1295         jit_int32_t     lo = i0 << 32 >> 32;
1296         jit_word_t      hi = i0 - lo;
1297         jit_int32_t     t0 = jit_get_reg(jit_class_gpr);
1298         movi(rn(t0), (jit_int32_t)(hi >> 32));
1299         movi(r0, lo);
1300         lshi(rn(t0), rn(t0), 32);
1301         addr(r0, r0, rn(t0));
1302         jit_unget_reg(t0);
1303     }
1304 }
1305
1306 static jit_word_t
1307 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1308 {
1309     jit_word_t          w;
1310     jit_int32_t         t0;
1311     jit_int32_t         ww = i0 << 32 >> 32;
1312     jit_int32_t         lo = ww << 20 >> 20;
1313     jit_int32_t         hi = ww - lo;
1314     w = _jit->pc.w;
1315     t0 = jit_get_reg(jit_class_gpr);
1316     LUI(r0, hi >> 12);
1317     ADDIW(r0, r0, lo);
1318     ww = i0 >> 32;
1319     lo = ww << 20 >> 20;
1320     hi = ww - lo;
1321     LUI(rn(t0), hi >> 12);
1322     ADDIW(rn(t0), rn(t0), lo);
1323     SLLI(rn(t0), rn(t0), 32);
1324     ADD(r0, r0, rn(t0));
1325     jit_unget_reg(t0);
1326     return (w);
1327 }
1328
1329 static void
1330 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1331 {
1332     jit_word_t  w;
1333     w = beqi(_jit->pc.w, r2, 0);
1334     movr(r1, r0);
1335     patch_at(w, _jit->pc.w);
1336 }
1337
1338 static void
1339 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1340 {
1341     jit_word_t  w;
1342     w = bnei(_jit->pc.w, r2, 0);
1343     movr(r1, r0);
1344     patch_at(w, _jit->pc.w);
1345 }
1346
1347 static void
1348 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1349       jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1350 {
1351     fallback_casx(r0, r1, r2, r3, i0);
1352 }
1353
1354 static void
1355 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1356 {
1357     if (simm12_p(i0))
1358         SLTI(r0, r1, i0);
1359     else {
1360         jit_int32_t     t0;
1361         t0 = jit_get_reg(jit_class_gpr);
1362         movi(r0, i0);
1363         ltr(r0, r1, rn(t0));
1364         jit_unget_reg(t0);
1365     }
1366 }
1367
1368 static void
1369 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1370 {
1371     if (simm12_p(i0))
1372         SLTIU(r0, r1, i0);
1373     else {
1374         jit_int32_t     t0;
1375         t0 = jit_get_reg(jit_class_gpr);
1376         movi(r0, i0);
1377         ltr_u(r0, r1, rn(t0));
1378         jit_unget_reg(t0);
1379     }
1380 }
1381
1382 static void
1383 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1384 {
1385     SLT(r0, r2, r1);
1386     XORI(r0, r0, 1);
1387 }
1388
1389 static void
1390 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1391 {
1392     jit_int32_t         t0;
1393     if (i0 == 0) {
1394         SLT(r0, _ZERO_REGNO, r1);
1395         XORI(r0, r0, 1);
1396     }
1397     else {
1398         t0 = jit_get_reg(jit_class_gpr);
1399         movi(rn(t0), i0);
1400         ler(r0, r1, rn(t0));
1401         jit_unget_reg(t0);
1402     }
1403 }
1404
1405 static void
1406 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1407 {
1408     SLTU(r0, r2, r1);
1409     XORI(r0, r0, 1);
1410 }
1411
1412 static void
1413 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1414 {
1415     jit_int32_t         t0;
1416     if (i0 == 0) {
1417         SLTU(r0, _ZERO_REGNO, r1);
1418         XORI(r0, r0, 1);
1419     }
1420     else {
1421         t0 = jit_get_reg(jit_class_gpr);
1422         movi(rn(t0), i0);
1423         ler_u(r0, r1, rn(t0));
1424         jit_unget_reg(t0);
1425     }
1426 }
1427
1428 static void
1429 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1430 {
1431     subr(r0, r1, r2);
1432     SLTU(r0, _ZERO_REGNO, r0);
1433     XORI(r0, r0, 1);
1434 }
1435
1436 static void
1437 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1438 {
1439     if (i0) {
1440         subi(r0, r1, i0);
1441         SLTU(r0, _ZERO_REGNO, r0);
1442     }
1443     else
1444         SLTU(r0, _ZERO_REGNO, r1);
1445     XORI(r0, r0, 1);
1446 }
1447
1448 static void
1449 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1450 {
1451     SLT(r0, r1, r2);
1452     XORI(r0, r0, 1);
1453 }
1454
1455 static void
1456 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1457 {
1458     jit_int32_t         t0;
1459     t0 = jit_get_reg(jit_class_gpr);
1460     movi(rn(t0), i0);
1461     ger(r0, r1, rn(t0));
1462     jit_unget_reg(t0);
1463 }
1464
1465 static void
1466 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1467 {
1468     SLTU(r0, r1, r2);
1469     XORI(r0, r0, 1);
1470 }
1471
1472 static void
1473 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1474 {
1475     jit_int32_t         t0;
1476     t0 = jit_get_reg(jit_class_gpr);
1477     movi(rn(t0), i0);
1478     ger_u(r0, r1, rn(t0));
1479     jit_unget_reg(t0);
1480 }
1481
1482 static void
1483 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1484 {
1485     jit_int32_t t0;
1486     t0 = jit_get_reg(jit_class_gpr);
1487     movi(r0, i0);
1488     ltr(r0, rn(t0), r1);
1489     jit_unget_reg(t0);
1490 }
1491
1492 static void
1493 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1494 {
1495     jit_int32_t t0;
1496     t0 = jit_get_reg(jit_class_gpr);
1497     movi(r0, i0);
1498     ltr_u(r0, rn(t0), r1);
1499     jit_unget_reg(t0);
1500 }
1501
1502 static void
1503 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1504 {
1505     subr(r0, r1, r2);
1506     SLTU(r0, _ZERO_REGNO, r0);
1507 }
1508
1509 static void
1510 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1511 {
1512     if (i0) {
1513         subi(r0, r1, i0);
1514         SLTU(r0, _ZERO_REGNO, r0);
1515     }
1516     else
1517         SLTU(r0, _ZERO_REGNO, r1);
1518 }
1519
1520 static jit_word_t
1521 _bltr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1522 {
1523     jit_word_t          w;
1524     w = _jit->pc.w;
1525     BLT(r0, r1, br - w);
1526     return (w);
1527 }
1528
1529 static jit_word_t
1530 _blti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1531 {
1532     jit_word_t          w;
1533     jit_reg_t           t0;
1534     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1535     movi(rn(t0), i0);
1536     w = bltr(br, r0, rn(t0));
1537     jit_unget_reg(t0);
1538     return (w);
1539 }
1540
1541 static jit_word_t
1542 _bltr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1543 {
1544     jit_word_t          w;
1545     w = _jit->pc.w;
1546     BLTU(r0, r1, br - w);
1547     return (w);
1548 }
1549
1550 static jit_word_t
1551 _blti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1552 {
1553     jit_word_t          w;
1554     jit_reg_t           t0;
1555     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1556     movi(rn(t0), i0);
1557     w = bltr_u(br, r0, rn(t0));
1558     jit_unget_reg(t0);
1559     return (w);
1560 }
1561
1562 static jit_word_t
1563 _bler(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1564 {
1565     jit_word_t          w;
1566     w = _jit->pc.w;
1567     BGE(r1, r0, br - w);
1568     return (w);
1569 }
1570
1571 static jit_word_t
1572 _blei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1573 {
1574     jit_word_t          w;
1575     jit_reg_t           t0;
1576     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1577     movi(rn(t0), i0);
1578     w = bler(br, r0, rn(t0));
1579     jit_unget_reg(t0);
1580     return (w);
1581 }
1582
1583 static jit_word_t
1584 _bler_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1585 {
1586     jit_word_t          w;
1587     w = _jit->pc.w;
1588     BGEU(r1, r0, br - w);
1589     return (w);
1590 }
1591
1592 static jit_word_t
1593 _blei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1594 {
1595     jit_word_t          w;
1596     jit_reg_t           t0;
1597     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1598     movi(rn(t0), i0);
1599     w = bler_u(br, r0, rn(t0));
1600     jit_unget_reg(t0);
1601     return (w);
1602 }
1603
1604 static jit_word_t
1605 _beqr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1606 {
1607     jit_word_t          w;
1608     w = _jit->pc.w;
1609     BEQ(r1, r0, br - w);
1610     return (w);
1611 }
1612
1613 static jit_word_t
1614 _beqi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1615 {
1616     jit_word_t          w;
1617     jit_reg_t           t0;
1618     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1619     movi(rn(t0), i0);
1620     w = beqr(br, r0, rn(t0));
1621     jit_unget_reg(t0);
1622     return (w);
1623 }
1624
1625 static jit_word_t
1626 _bger(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1627 {
1628     jit_word_t          w;
1629     w = _jit->pc.w;
1630     BGE(r0, r1, br - w);
1631     return (w);
1632 }
1633
1634 static jit_word_t
1635 _bgei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1636 {
1637     jit_word_t          w;
1638     jit_reg_t           t0;
1639     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1640     movi(rn(t0), i0);
1641     w = bger(br, r0, rn(t0));
1642     jit_unget_reg(t0);
1643     return (w);
1644 }
1645
1646 static jit_word_t
1647 _bger_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1648 {
1649     jit_word_t          w;
1650     w = _jit->pc.w;
1651     BGEU(r0, r1, br - w);
1652     return (w);
1653 }
1654
1655 static jit_word_t
1656 _bgei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1657 {
1658     jit_word_t          w;
1659     jit_reg_t           t0;
1660     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1661     movi(rn(t0), i0);
1662     w = bger_u(br, r0, rn(t0));
1663     jit_unget_reg(t0);
1664     return (w);
1665 }
1666
1667 static jit_word_t
1668 _bgtr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1669 {
1670     jit_word_t          w;
1671     w = _jit->pc.w;
1672     BLT(r1, r0, br - w);
1673     return (w);
1674 }
1675
1676 static jit_word_t
1677 _bgti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1678 {
1679     jit_word_t          w;
1680     jit_reg_t           t0;
1681     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1682     movi(rn(t0), i0);
1683     w = bgtr(br, r0, rn(t0));
1684     jit_unget_reg(t0);
1685     return (w);
1686 }
1687
1688 static jit_word_t
1689 _bgtr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1690 {
1691     jit_word_t          w;
1692     w = _jit->pc.w;
1693     BLTU(r1, r0, br - w);
1694     return (w);
1695 }
1696
1697 static jit_word_t
1698 _bgti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1699 {
1700     jit_word_t          w;
1701     jit_reg_t           t0;
1702     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1703     movi(rn(t0), i0);
1704     w = bgtr_u(br, r0, rn(t0));
1705     jit_unget_reg(t0);
1706     return (w);
1707 }
1708
1709 static jit_word_t
1710 _bner(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1711 {
1712     jit_word_t          w;
1713     w = _jit->pc.w;
1714     BNE(r1, r0, br - w);
1715     return (w);
1716 }
1717
1718 static jit_word_t
1719 _bnei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1720 {
1721     jit_word_t          w;
1722     jit_reg_t           t0;
1723     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1724     movi(rn(t0), i0);
1725     w = bner(br, r0, rn(t0));
1726     jit_unget_reg(t0);
1727     return (w);
1728 }
1729
1730 static jit_word_t
1731 _boaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1732 {
1733     jit_word_t          w, jal;
1734     jit_int32_t         t0, t1;
1735     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1736     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1737     /* t0 = r1 < 0; */
1738     SLT(rn(t0), r1, _ZERO_REGNO);
1739     /* t1 = r0 */
1740     movr(rn(t1), r0);
1741     /* r0 = r0 + r1 */
1742     addr(r0, r0, r1);
1743     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1744     w = _jit->pc.w;
1745     BNE(rn(t0), _ZERO_REGNO, 0);
1746     /* r1 >= 0 */
1747     SLT(rn(t1), r0, rn(t1));
1748     jal = _jit->pc.w;
1749     JAL(_ZERO_REGNO, 0);
1750     /* r1 < 0 */
1751     patch_at(w, _jit->pc.w);
1752     SLT(rn(t1), rn(t1), r0);
1753     /**/
1754     patch_at(jal, _jit->pc.w);
1755     w = _jit->pc.w;
1756     BNE(rn(t1), _ZERO_REGNO, br - w);
1757     jit_unget_reg(t1);
1758     jit_unget_reg(t0);
1759     return (w);
1760 }
1761
1762 static jit_word_t
1763 _boaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1764 {
1765     jit_word_t          w;
1766     jit_int32_t         t0;
1767     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1768     movi(rn(t0), i0);
1769     w = boaddr(br, r0, rn(t0));
1770     jit_unget_reg(t0);
1771     return (w);
1772 }
1773
1774 static jit_word_t
1775 _boaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1776 {
1777     jit_word_t          w;
1778     jit_int32_t         t0, t1;
1779     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1780     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1781     addr(rn(t0), r0, r1);
1782     SLTU(rn(t1), rn(t0), r0);
1783     movr(r0, rn(t0));
1784     w = _jit->pc.w;
1785     BNE(_ZERO_REGNO, rn(t1), br - w);
1786     jit_unget_reg(t1);
1787     jit_unget_reg(t0);
1788     return (w);
1789 }
1790
1791 static jit_word_t
1792 _boaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1793 {
1794     jit_word_t          w;
1795     jit_int32_t         t0;
1796     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1797     movi(rn(t0), i0);
1798     w = boaddr_u(br, r0, rn(t0));
1799     jit_unget_reg(t0);
1800     return (w);
1801 }
1802
1803 static jit_word_t
1804 _bxaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1805 {
1806     jit_word_t          w, jal;
1807     jit_int32_t         t0, t1;
1808     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1809     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1810     /* t0 = r1 < 0; */
1811     SLT(rn(t0), r1, _ZERO_REGNO);
1812     /* t1 = r0 */
1813     movr(rn(t1), r0);
1814     /* r0 = r0 + r1 */
1815     addr(r0, r0, r1);
1816     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1817     w = _jit->pc.w;
1818     BNE(rn(t0), _ZERO_REGNO, 0);
1819     /* r1 >= 0 */
1820     SLT(rn(t1), r0, rn(t1));
1821     jal = _jit->pc.w;
1822     JAL(_ZERO_REGNO, 0);
1823     /* r1 < 0 */
1824     patch_at(w, _jit->pc.w);
1825     SLT(rn(t1), rn(t1), r0);
1826     /**/
1827     patch_at(jal, _jit->pc.w);
1828     w = _jit->pc.w;
1829     BEQ(rn(t1), _ZERO_REGNO, br - w);
1830     jit_unget_reg(t1);
1831     jit_unget_reg(t0);
1832     return (w);
1833 }
1834
1835 static jit_word_t
1836 _bxaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1837 {
1838     jit_word_t          w;
1839     jit_int32_t         t0;
1840     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1841     movi(rn(t0), i0);
1842     w = bxaddr(br, r0, rn(t0));
1843     jit_unget_reg(t0);
1844     return (w);
1845 }
1846
1847 static jit_word_t
1848 _bxaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1849 {
1850     jit_word_t          w;
1851     jit_int32_t         t0, t1;
1852     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1853     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1854     addr(rn(t0), r0, r1);
1855     SLTU(rn(t1), rn(t0), r0);
1856     movr(r0, rn(t0));
1857     w = _jit->pc.w;
1858     BEQ(_ZERO_REGNO, rn(t1), br - w);
1859     jit_unget_reg(t1);
1860     jit_unget_reg(t0);
1861     return (w);
1862 }
1863
1864 static jit_word_t
1865 _bxaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1866 {
1867     jit_word_t          w;
1868     jit_int32_t         t0;
1869     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1870     movi(rn(t0), i0);
1871     w = bxaddr_u(br, r0, rn(t0));
1872     jit_unget_reg(t0);
1873     return (w);
1874 }
1875
1876 static jit_word_t
1877 _bosubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1878 {
1879     jit_word_t          w, jal;
1880     jit_int32_t         t0, t1;
1881     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1882     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1883     /* t0 = 0 < r1; */
1884     SLT(rn(t0), _ZERO_REGNO, r1);
1885     /* t1 = r0 */
1886     movr(rn(t1), r0);
1887     /* r0 = r0 - r1 */
1888     subr(r0, r0, r1);
1889     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1890     w = _jit->pc.w;
1891     BNE(rn(t0), _ZERO_REGNO, 0);
1892     /* r1 >= 0 */
1893     SLT(rn(t1), r0, rn(t1));
1894     jal = _jit->pc.w;
1895     JAL(_ZERO_REGNO, 0);
1896     /* r1 < 0 */
1897     patch_at(w, _jit->pc.w);
1898     SLT(rn(t1), rn(t1), r0);
1899     /**/
1900     patch_at(jal, _jit->pc.w);
1901     w = _jit->pc.w;
1902     BNE(rn(t1), _ZERO_REGNO, br - w);
1903     jit_unget_reg(t1);
1904     jit_unget_reg(t0);
1905     return (w);
1906 }
1907
1908 static jit_word_t
1909 _bosubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1910 {
1911     jit_word_t          w;
1912     jit_int32_t         t0;
1913     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1914     movi(rn(t0), i0);
1915     w = bosubr(br, r0, rn(t0));
1916     jit_unget_reg(t0);
1917     return (w);
1918 }
1919
1920 static jit_word_t
1921 _bosubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1922 {
1923     jit_word_t          w;
1924     jit_int32_t         t0, t1;
1925     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1926     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1927     subr(rn(t0), r0, r1);
1928     SLTU(rn(t1), r0, rn(t0));
1929     movr(r0, rn(t0));
1930     w = _jit->pc.w;
1931     BNE(_ZERO_REGNO, rn(t1), br - w);
1932     jit_unget_reg(t1);
1933     jit_unget_reg(t0);
1934     return (w);
1935 }
1936
1937 static jit_word_t
1938 _bosubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1939 {
1940     jit_word_t          w;
1941     jit_int32_t         t0;
1942     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1943     movi(rn(t0), i0);
1944     w = bosubr_u(br, r0, rn(t0));
1945     jit_unget_reg(t0);
1946     return (w);
1947 }
1948
1949 static jit_word_t
1950 _bxsubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1951 {
1952     jit_word_t          w, jal;
1953     jit_int32_t         t0, t1;
1954     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1955     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1956     /* t0 = r1 < 0; */
1957     SLT(rn(t0), _ZERO_REGNO, r1);
1958     /* t1 = r0 */
1959     movr(rn(t1), r0);
1960     /* r0 = r0 - r1 */
1961     subr(r0, r0, r1);
1962     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1963     w = _jit->pc.w;
1964     BNE(rn(t0), _ZERO_REGNO, 0);
1965     /* r1 >= 0 */
1966     SLT(rn(t1), r0, rn(t1));
1967     jal = _jit->pc.w;
1968     JAL(_ZERO_REGNO, 0);
1969     /* r1 < 0 */
1970     patch_at(w, _jit->pc.w);
1971     SLT(rn(t1), rn(t1), r0);
1972     /**/
1973     patch_at(jal, _jit->pc.w);
1974     w = _jit->pc.w;
1975     BEQ(rn(t1), _ZERO_REGNO, br - w);
1976     jit_unget_reg(t1);
1977     jit_unget_reg(t0);
1978     return (w);
1979 }
1980
1981 static jit_word_t
1982 _bxsubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1983 {
1984     jit_word_t          w;
1985     jit_int32_t         t0;
1986     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1987     movi(rn(t0), i0);
1988     w = bxsubr(br, r0, rn(t0));
1989     jit_unget_reg(t0);
1990     return (w);
1991 }
1992
1993 static jit_word_t
1994 _bxsubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1995 {
1996     jit_word_t          w;
1997     jit_int32_t         t0, t1;
1998     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1999     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2000     subr(rn(t0), r0, r1);
2001     SLTU(rn(t1), r0, rn(t0));
2002     movr(r0, rn(t0));
2003     w = _jit->pc.w;
2004     BEQ(_ZERO_REGNO, rn(t1), br - w);
2005     jit_unget_reg(t1);
2006     jit_unget_reg(t0);
2007     return (w);
2008 }
2009
2010 static jit_word_t
2011 _bxsubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2012 {
2013     jit_word_t          w;
2014     jit_int32_t         t0;
2015     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2016     movi(rn(t0), i0);
2017     w = bxsubr_u(br, r0, rn(t0));
2018     jit_unget_reg(t0);
2019     return (w);
2020 }
2021
2022 static jit_word_t
2023 _bmsr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2024 {
2025     jit_word_t          w;
2026     jit_int32_t         t0;
2027     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2028     AND(rn(t0), r0, r1);
2029     w = _jit->pc.w;
2030     BNE(_ZERO_REGNO, rn(t0), br - w);
2031     jit_unget_reg(t0);
2032     return (w);
2033 }
2034
2035 static jit_word_t
2036 _bmsi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2037 {
2038     jit_word_t          w;
2039     jit_int32_t         t0;
2040     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2041     movi(rn(t0), i0);
2042     w = bmsr(br, r0, rn(t0));
2043     jit_unget_reg(t0);
2044     return (w);
2045 }
2046
2047 static jit_word_t
2048 _bmcr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2049 {
2050     jit_word_t          w;
2051     jit_int32_t         t0;
2052     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2053     AND(rn(t0), r0, r1);
2054     w = _jit->pc.w;
2055     BEQ(_ZERO_REGNO, rn(t0), br - w);
2056     jit_unget_reg(t0);
2057     return (w);
2058 }
2059
2060 static jit_word_t
2061 _bmci(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2062 {
2063     jit_word_t          w;
2064     jit_int32_t         t0;
2065     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2066     movi(rn(t0), i0);
2067     w = bmcr(br, r0, rn(t0));
2068     jit_unget_reg(t0);
2069     return (w);
2070 }
2071
2072 static void
2073 _jmpi(jit_state_t *_jit, jit_word_t i0)
2074 {
2075     jit_int32_t         t0;
2076     jit_word_t          dsp;
2077     dsp = i0 - _jit->pc.w;
2078     if (simm20_p(dsp))
2079         JAL(_ZERO_REGNO, dsp);
2080     else {
2081         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2082         movi(rn(t0), i0);
2083         jmpr(rn(t0));
2084         jit_unget_reg(t0);
2085     }
2086 }
2087
2088 static jit_word_t
2089 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2090 {
2091     jit_word_t          w;
2092     jit_int32_t         t0;
2093     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2094     w = movi_p(rn(t0), i0);
2095     jmpr(rn(t0));
2096     jit_unget_reg(t0);
2097     return (w);
2098 }
2099
2100 static void
2101 _calli(jit_state_t *_jit, jit_word_t i0)
2102 {
2103     jit_int32_t         t0;
2104     jit_word_t          dsp;
2105     dsp = i0 - _jit->pc.w;
2106     if (simm20_p(dsp))
2107         JAL(_RA_REGNO, dsp);
2108     else {
2109         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2110         movi(rn(t0), i0);
2111         callr(rn(t0));
2112         jit_unget_reg(t0);
2113     }
2114 }
2115
2116 static jit_word_t
2117 _calli_p(jit_state_t *_jit, jit_word_t i0)
2118 {
2119     jit_word_t          w;
2120     jit_int32_t         t0;
2121     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2122     w = movi_p(rn(t0), i0);
2123     callr(rn(t0));
2124     jit_unget_reg(t0);
2125     return (w);
2126 }
2127
2128 static void
2129 _prolog(jit_state_t *_jit, jit_node_t *node)
2130 {
2131     jit_int32_t         reg;
2132     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2133         jit_int32_t     frame = -_jitc->function->frame;
2134         assert(_jitc->function->self.aoff >= frame);
2135         if (_jitc->function->assume_frame)
2136             return;
2137         _jitc->function->self.aoff = frame;
2138     }
2139     if (_jitc->function->allocar)
2140         _jitc->function->self.aoff &= -16;
2141     _jitc->function->stack = ((_jitc->function->self.alen -
2142                               /* align stack at 16 bytes */
2143                               _jitc->function->self.aoff) + 15) & -16;
2144     subi(_SP_REGNO, _SP_REGNO, stack_framesize);
2145     stxi(0, _SP_REGNO, _RA_REGNO);
2146     stxi(8, _SP_REGNO, _FP_REGNO);
2147     if (jit_regset_tstbit(&_jitc->function->regset, _S1))
2148         stxi(16, _SP_REGNO, 9);
2149     if (jit_regset_tstbit(&_jitc->function->regset, _S2))
2150         stxi(24, _SP_REGNO, 18);
2151     if (jit_regset_tstbit(&_jitc->function->regset, _S3))
2152         stxi(32, _SP_REGNO, 19);
2153     if (jit_regset_tstbit(&_jitc->function->regset, _S4))
2154         stxi(40, _SP_REGNO, 20);
2155     if (jit_regset_tstbit(&_jitc->function->regset, _S5))
2156         stxi(48, _SP_REGNO, 21);
2157     if (jit_regset_tstbit(&_jitc->function->regset, _S6))
2158         stxi(56, _SP_REGNO, 22);
2159     if (jit_regset_tstbit(&_jitc->function->regset, _S7))
2160         stxi(64, _SP_REGNO, 23);
2161     if (jit_regset_tstbit(&_jitc->function->regset, _S8))
2162         stxi(72, _SP_REGNO, 24);
2163     if (jit_regset_tstbit(&_jitc->function->regset, _S9))
2164         stxi(80, _SP_REGNO, 25);
2165     if (jit_regset_tstbit(&_jitc->function->regset, _S10))
2166         stxi(88, _SP_REGNO, 26);
2167     if (jit_regset_tstbit(&_jitc->function->regset, _S11))
2168         stxi(96, _SP_REGNO, 27);
2169     if (jit_regset_tstbit(&_jitc->function->regset, _FS0))
2170         stxi_d(104, _SP_REGNO, 8);
2171     if (jit_regset_tstbit(&_jitc->function->regset, _FS1))
2172         stxi_d(112, _SP_REGNO, 9);
2173     if (jit_regset_tstbit(&_jitc->function->regset, _FS2))
2174         stxi_d(120, _SP_REGNO, 18);
2175     if (jit_regset_tstbit(&_jitc->function->regset, _FS3))
2176         stxi_d(128, _SP_REGNO, 19);
2177     if (jit_regset_tstbit(&_jitc->function->regset, _FS4))
2178         stxi_d(136, _SP_REGNO, 20);
2179     if (jit_regset_tstbit(&_jitc->function->regset, _FS5))
2180         stxi_d(144, _SP_REGNO, 21);
2181     if (jit_regset_tstbit(&_jitc->function->regset, _FS6))
2182         stxi_d(152, _SP_REGNO, 22);
2183     if (jit_regset_tstbit(&_jitc->function->regset, _FS7))
2184         stxi_d(160, _SP_REGNO, 23);
2185     if (jit_regset_tstbit(&_jitc->function->regset, _FS8))
2186         stxi_d(168, _SP_REGNO, 24);
2187     if (jit_regset_tstbit(&_jitc->function->regset, _FS9))
2188         stxi_d(176, _SP_REGNO, 25);
2189     if (jit_regset_tstbit(&_jitc->function->regset, _FS10))
2190         stxi_d(184, _SP_REGNO, 26);
2191     if (jit_regset_tstbit(&_jitc->function->regset, _FS11))
2192         stxi_d(192, _SP_REGNO, 27);
2193     movr(_FP_REGNO, _SP_REGNO);
2194     if (_jitc->function->stack)
2195         subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
2196     if (_jitc->function->allocar) {
2197         reg = jit_get_reg(jit_class_gpr);
2198         movi(rn(reg), _jitc->function->self.aoff);
2199         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2200         jit_unget_reg(reg);
2201     }
2202     if (_jitc->function->self.call & jit_call_varargs) {
2203         for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2204             stxi(stack_framesize - ((8 - reg) * 8),
2205                  _FP_REGNO, rn(JIT_RA0 - reg));
2206     }
2207 }
2208
2209 static void
2210 _epilog(jit_state_t *_jit, jit_node_t *node)
2211 {
2212     if (_jitc->function->assume_frame)
2213         return;
2214     movr(_SP_REGNO, _FP_REGNO);
2215     ldxi(_RA_REGNO, _SP_REGNO, 0);
2216     ldxi(_FP_REGNO, _SP_REGNO, 8);
2217     if (jit_regset_tstbit(&_jitc->function->regset, _S1))
2218         ldxi(9, _SP_REGNO, 16);
2219     if (jit_regset_tstbit(&_jitc->function->regset, _S2))
2220         ldxi(18, _SP_REGNO, 24);
2221     if (jit_regset_tstbit(&_jitc->function->regset, _S3))
2222         ldxi(19, _SP_REGNO, 32);
2223     if (jit_regset_tstbit(&_jitc->function->regset, _S4))
2224         ldxi(20, _SP_REGNO, 40);
2225     if (jit_regset_tstbit(&_jitc->function->regset, _S5))
2226         ldxi(21, _SP_REGNO, 48);
2227     if (jit_regset_tstbit(&_jitc->function->regset, _S6))
2228         ldxi(22, _SP_REGNO, 56);
2229     if (jit_regset_tstbit(&_jitc->function->regset, _S7))
2230         ldxi(23, _SP_REGNO, 64);
2231     if (jit_regset_tstbit(&_jitc->function->regset, _S8))
2232         ldxi(24, _SP_REGNO, 72);
2233     if (jit_regset_tstbit(&_jitc->function->regset, _S9))
2234         ldxi(25, _SP_REGNO, 80);
2235     if (jit_regset_tstbit(&_jitc->function->regset, _S10))
2236         ldxi(26, _SP_REGNO, 88);
2237     if (jit_regset_tstbit(&_jitc->function->regset, _S11))
2238         ldxi(27, _SP_REGNO, 96);
2239     if (jit_regset_tstbit(&_jitc->function->regset, _FS0))
2240         ldxi_d(8, _SP_REGNO, 104);
2241     if (jit_regset_tstbit(&_jitc->function->regset, _FS1))
2242         ldxi_d(9, _SP_REGNO, 112);
2243     if (jit_regset_tstbit(&_jitc->function->regset, _FS2))
2244         ldxi_d(18, _SP_REGNO, 120);
2245     if (jit_regset_tstbit(&_jitc->function->regset, _FS3))
2246         ldxi_d(19, _SP_REGNO, 128);
2247     if (jit_regset_tstbit(&_jitc->function->regset, _FS4))
2248         ldxi_d(20, _SP_REGNO, 136);
2249     if (jit_regset_tstbit(&_jitc->function->regset, _FS5))
2250         ldxi_d(21, _SP_REGNO, 144);
2251     if (jit_regset_tstbit(&_jitc->function->regset, _FS6))
2252         ldxi_d(22, _SP_REGNO, 152);
2253     if (jit_regset_tstbit(&_jitc->function->regset, _FS7))
2254         ldxi_d(23, _SP_REGNO, 160);
2255     if (jit_regset_tstbit(&_jitc->function->regset, _FS8))
2256         ldxi_d(24, _SP_REGNO, 168);
2257     if (jit_regset_tstbit(&_jitc->function->regset, _FS9))
2258         ldxi_d(25, _SP_REGNO, 176);
2259     if (jit_regset_tstbit(&_jitc->function->regset, _FS10))
2260         ldxi_d(26, _SP_REGNO, 184);
2261     if (jit_regset_tstbit(&_jitc->function->regset, _FS11))
2262         ldxi_d(27, _SP_REGNO, 192);
2263     addi(_SP_REGNO, _SP_REGNO, stack_framesize);
2264     RET();
2265 }
2266
2267 static void
2268 _vastart(jit_state_t *_jit, jit_int32_t r0)
2269 {
2270     assert(_jitc->function->self.call & jit_call_varargs);
2271     /* Initialize va_list to the first stack argument. */
2272     if (jit_arg_reg_p(_jitc->function->vagp))
2273         addi(r0, _FP_REGNO, stack_framesize - ((8 - _jitc->function->vagp) * 8));
2274     else
2275         addi(r0, _FP_REGNO, _jitc->function->self.size);
2276 }
2277
2278 static void
2279 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2280 {
2281     assert(_jitc->function->self.call & jit_call_varargs);
2282     /* Load argument. */
2283     ldr(r0, r1);
2284     /* Update va_list. */
2285     addi(r1, r1, sizeof(jit_word_t));
2286 }
2287
2288 static void
2289 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2290 {
2291     instr_t              i;
2292     union {
2293         jit_int32_t     *i;
2294         jit_word_t       w;
2295     } u;
2296     u.w = instr;
2297     i.w = u.i[0];
2298     /* movi_p? */
2299     if (i.U.opcode == 55) {                                     /* LUI */
2300         jit_int32_t     ww = label << 32 >> 32;
2301         jit_int32_t     lo = ww << 20 >> 20;
2302         jit_int32_t     hi = ww - lo;
2303         i.U.imm12_31 = hi >> 12;
2304         u.i[0] = i.w;
2305         i.w = u.i[1];
2306         if (i.I.opcode == 27 && i.I.funct3 == 0) {              /* ADDIW */
2307             i.I.imm11_0 = lo & 0xfff;
2308             u.i[1] = i.w;
2309             i.w = u.i[2];
2310             if (i.U.opcode == 55) {                             /* LUI */
2311                 ww = label >> 32;
2312                 lo = ww << 20 >> 20;
2313                 hi = ww - lo;
2314                 i.U.imm12_31 = hi >> 12;
2315                 u.i[2] = i.w;
2316                 i.w = u.i[3];
2317                 if (i.I.opcode == 27 && i.I.funct3 == 0) {      /* ADDIW */
2318                     i.I.imm11_0 = lo & 0xfff;
2319                     u.i[3] = i.w;
2320                     i.w = u.i[4];
2321                     assert(i.IS.opcode == 19);                  /* SLLI */
2322                     assert(i.IS.shamt == 32);
2323                     i.w = u.i[5];
2324                     assert(i.R.opcode == 51);                   /* ADD */
2325                 }
2326                 else
2327                     abort();
2328             }
2329             else
2330                 abort();
2331         }
2332         else
2333             abort();
2334     }
2335     /* b{lt,le,eq,ge,gt,ne}{,_u}? */
2336     else if (i.B.opcode == 99) {                /* B{EQ,NE,LT,GE,LTU,GEU} */
2337         jit_word_t jmp = label - instr;
2338         assert(simm12_p(jmp));
2339         i.B.imm11       = (jmp >> 11) & 0x1;
2340         i.B.imm4_1      = (jmp >> 1) & 0xf;
2341         i.B.imm10_5     = (jmp >> 5) & 0x3f;
2342         i.B.imm12       = (jmp >> 12) & 0x1;
2343         u.i[0] = i.w;
2344     }
2345     else if (i.J.opcode == 111) {               /* JAL */
2346         jit_word_t jmp = label - instr;
2347         i.J.imm19_12    = (jmp >> 12) &  0xff;
2348         i.J.imm11       = (jmp >> 11) &   0x1;
2349         i.J.imm10_1     = (jmp >>  1) & 0x3ff;
2350         i.J.imm20       = (jmp >> 20) &   0x1;
2351         u.i[0] = i.w;
2352     }
2353     else
2354         abort();
2355 }
2356 #endif          /* CODE */