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 ltr(r0, r1, r2)               SLT(r0, r1, r2)
 460 #  define lti(r0, r1, im)               _lti(_jit, r0, r1, im)
 461 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 462 #  define ltr_u(r0, r1, r2)             SLTU(r0, r1, r2)
 463 #  define lti_u(r0, r1, im)             _lti_u(_jit, r0, r1, im)
 464 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 465 #  define ler(r0, r1, r2)               _ler(_jit, r0, r1, r2)
 466 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 467 #  define lei(r0, r1, im)               _lei(_jit, r0, r1, im)
 468 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 469 #  define ler_u(r0, r1, r2)             _ler_u(_jit, r0, r1, r2)
 470 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 471 #  define lei_u(r0, r1, im)             _lei_u(_jit, r0, r1, im)
 472 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 473 #  define eqr(r0, r1, r2)               _eqr(_jit, r0, r1, r2)
 474 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 475 #  define eqi(r0, r1, im)               _eqi(_jit, r0, r1, im)
 476 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 477 #  define ger(r0, r1, r2)               _ger(_jit, r0, r1, r2)
 478 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 479 #  define gei(r0, r1, r2)               _gei(_jit, r0, r1, r2)
 480 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 481 #  define ger_u(r0, r1, r2)             _ger_u(_jit, r0, r1, r2)
 482 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 483 #  define gei_u(r0, r1, im)             _gei_u(_jit, r0, r1, im)
 484 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 485 #  define gtr(r0, r1, r2)               SLT(r0, r2, r1)
 486 #  define gti(r0, r1, im)               _gti(_jit, r0, r1, im)
 487 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 488 #  define gtr_u(r0, r1, r2)             SLTU(r0, r2, r1)
 489 #  define gti_u(r0, r1, im)             _gti_u(_jit, r0, r1, im)
 490 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 491 #  define ner(r0, r1, r2)               _ner(_jit, r0, r1, r2)
 492 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
 493 #  define nei(r0, r1, im)               _nei(_jit, r0, r1, im)
 494 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
 495 #  define bltr(br, r0, r1)              _bltr(_jit, br, r0, r1)
 496 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 497 #  define blti(br, r0, im)              _blti(_jit, br, r0, im)
 498 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 499 #  define bltr_u(br, r0, r1)            _bltr_u(_jit, br, r0, r1)
 500 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 501 #  define blti_u(br, r0, im)            _blti_u(_jit, br, r0, im)
 502 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 503 #  define bler(br, r0, r1)              _bler(_jit, br, r0, r1)
 504 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 505 #  define blei(br, r0, im)              _blei(_jit, br, r0, im)
 506 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 507 #  define bler_u(br, r0, r1)            _bler_u(_jit, br, r0, r1)
 508 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 509 #  define blei_u(br, r0, im)            _blei_u(_jit, br, r0, im)
 510 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 511 #  define beqr(br, r0, r1)              _beqr(_jit, br, r0, r1)
 512 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 513 #  define beqi(br, r0, im)              _beqi(_jit, br, r0, im)
 514 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 515 #  define bger(br, r0, r1)              _bger(_jit, br, r0, r1)
 516 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 517 #  define bgei(br, r0, im)              _bgei(_jit, br, r0, im)
 518 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 519 #  define bger_u(br, r0, r1)            _bger_u(_jit, br, r0, r1)
 520 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 521 #  define bgei_u(br, r0, im)            _bgei_u(_jit, br, r0, im)
 522 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 523 #  define bgtr(br, r0, r1)              _bgtr(_jit, br, r0, r1)
 524 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 525 #  define bgti(br, r0, im)              _bgti(_jit, br, r0, im)
 526 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 527 #  define bgtr_u(br, r0, r1)            _bgtr_u(_jit, br, r0, r1)
 528 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 529 #  define bgti_u(br, r0, im)            _bgti_u(_jit, br, r0, im)
 530 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 531 #  define bner(br, r0, r1)              _bner(_jit, br, r0, r1)
 532 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 533 #  define bnei(br, r0, im)              _bnei(_jit, br, r0, im)
 534 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 535 #  define boaddr(br, r0, r1)            _boaddr(_jit, br, r0, r1)
 536 #  define boaddi(br, r0, im)            _boaddi(_jit, br, r0, im)
 537 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 538 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 539 #  define boaddr_u(br, r0, r1)          _boaddr_u(_jit, br, r0, r1)
 540 #  define boaddi_u(br, r0, im)          _boaddi_u(_jit, br, r0, im)
 541 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 542 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 543 #  define bxaddr(br, r0, r1)            _bxaddr(_jit, br, r0, r1)
 544 #  define bxaddi(br, r0, im)            _bxaddi(_jit, br, r0, im)
 545 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 546 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 547 #  define bxaddr_u(br, r0, r1)          _bxaddr_u(_jit, br, r0, r1)
 548 #  define bxaddi_u(br, r0, im)          _bxaddi_u(_jit, br, r0, im)
 549 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 550 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 551 #  define bosubr(br, r0, r1)            _bosubr(_jit, br, r0, r1)
 552 #  define bosubi(br, r0, im)            _bosubi(_jit, br, r0, im)
 553 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 554 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 555 #  define bosubr_u(br, r0, r1)          _bosubr_u(_jit, br, r0, r1)
 556 #  define bosubi_u(br, r0, im)          _bosubi_u(_jit, br, r0, im)
 557 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 558 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 559 #  define bxsubr(br, r0, r1)            _bxsubr(_jit, br, r0, r1)
 560 #  define bxsubi(br, r0, im)            _bxsubi(_jit, br, r0, im)
 561 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 562 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 563 #  define bxsubr_u(br, r0, r1)          _bxsubr_u(_jit, br, r0, r1)
 564 #  define bxsubi_u(br, r0, im)          _bxsubi_u(_jit, br, r0, im)
 565 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 566 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 567 #  define bmsr(br, r0, r1)              _bmsr(_jit, br, r0, r1)
 568 #  define bmsi(br, r0, im)              _bmsi(_jit, br, r0, im)
 569 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 570 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 571 #  define bmcr(br, r0, r1)              _bmcr(_jit, br, r0, r1)
 572 #  define bmci(br, r0, im)              _bmci(_jit, br, r0, im)
 573 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
 574 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
 575 #  define jmpr(r0)                      JALR(_ZERO_REGNO, r0, 0)
 576 #  define jmpi(im)                      _jmpi(_jit, im)
 577 static void _jmpi(jit_state_t*,jit_word_t);
 578 #  define jmpi_p(im)                    _jmpi_p(_jit, im)
 579 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
 580 #  define callr(r0)                     JALR(_RA_REGNO, r0, 0)
 581 #  define calli(im)                     _calli(_jit, im)
 582 static void _calli(jit_state_t*,jit_word_t);
 583 #  define calli_p(im)           _calli_p(_jit, im)
 584 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
 585 #  define prolog(i0)                    _prolog(_jit,i0)
 586 static void _prolog(jit_state_t*,jit_node_t*);
 587 #  define epilog(i0)                    _epilog(_jit,i0)
 588 static void _epilog(jit_state_t*,jit_node_t*);
 589 #  define vastart(r0)                   _vastart(_jit, r0)
 590 static void _vastart(jit_state_t*, jit_int32_t);
 591 #  define vaarg(r0, r1)                 _vaarg(_jit, r0, r1)
 592 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
 593 #define patch_abs(instr,label)          _patch_at(_jit,instr,label)
 594 #define patch_at(instr,label)           _patch_at(_jit,instr,label)
 595 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
 596 #endif          /* PROTO */
 597
 598 #if CODE
 599 static void
 600 _Rtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
 601        jit_int32_t fct, jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2)
 602 {
 603     instr_t     i;
 604     assert(!(op   & ~0x7f));
 605     assert(!(rd   & ~0x1f));
 606     assert(!(fct  & ~0x07));
 607     assert(!(rs1  & ~0x1f));
 608     assert(!(rs2  & ~0x1f));
 609     assert(!(fct2 & ~0x7f));
 610     i.R.opcode  = op;
 611     i.R.rd      = rd;
 612     i.R.funct3  = fct;
 613     i.R.rs1     = rs1;
 614     i.R.rs2     = rs2;
 615     i.R.funct7  = fct2;
 616     ii(i.w);
 617 }
 618
 619 static void
 620 _R4type(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t fct,
 621         jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2, jit_int32_t rs3)
 622 {
 623     instr_t     i;
 624     assert(!(op   & ~0x7f));
 625     assert(!(rd   & ~0x1f));
 626     assert(!(fct  & ~0x07));
 627     assert(!(rs1  & ~0x1f));
 628     assert(!(rs2  & ~0x1f));
 629     assert(!(fct2 & ~0x03));
 630     assert(!(rs3  & ~0x1f));
 631     i.R4.opcode = op;
 632     i.R4.rd     = rd;
 633     i.R4.funct3 = fct;
 634     i.R4.rs1    = rs1;
 635     i.R4.rs2    = rs2;
 636     i.R4.funct2 = fct2;
 637     i.R4.rs3    = rs3;
 638     ii(i.w);
 639 }
 640
 641 static void
 642 _Itype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
 643        jit_int32_t fct, jit_int32_t rs1, jit_int32_t imm)
 644 {
 645     instr_t     i;
 646     assert(!(op  &  ~0x7f));
 647     assert(!(rd  &  ~0x1f));
 648     assert(!(fct &  ~0x07));
 649     assert(!(rs1 &  ~0x1f));
 650     assert(simm12_p(imm));
 651     i.I.opcode  = op;
 652     i.I.rd      = rd;
 653     i.I.funct3  = fct;
 654     i.I.rs1     = rs1;
 655     i.I.imm11_0 = imm;
 656     ii(i.w);
 657 }
 658
 659 #  if __WORDSIZE == 64
 660 static void
 661 _IStype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
 662        jit_int32_t fct, jit_int32_t rs1, jit_int32_t sh, jit_int32_t imm)
 663 {
 664     instr_t     i;
 665     assert(!(op  &  ~0x7f));
 666     assert(!(rd  &  ~0x1f));
 667     assert(!(fct &  ~0x07));
 668     assert(!(rs1 &  ~0x1f));
 669     assert(!(sh  &  ~0x3f));
 670     assert(simm6_p(imm));
 671     i.IS.opcode = op;
 672     i.IS.rd     = rd;
 673     i.IS.funct3 = fct;
 674     i.IS.rs1    = rs1;
 675     i.IS.shamt  = sh;
 676     i.IS.imm6_0 = imm;
 677     ii(i.w);
 678 }
 679 #  endif
 680
 681 static void
 682 _Stype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
 683        jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
 684 {
 685     instr_t     i;
 686     assert(!(op  &  ~0x7f));
 687     assert(!(fct &  ~0x07));
 688     assert(!(rs1 &  ~0x1f));
 689     assert(!(rs2 &  ~0x1f));
 690     assert(simm12_p(imm));
 691     i.S.opcode  = op;
 692     i.S.imm4_0  = imm & 0x1f;
 693     i.S.funct3  = fct;
 694     i.S.rs1     = rs1;
 695     i.S.rs2     = rs2;
 696     i.S.imm11_5 = (imm >> 5) & 0x7f;
 697     ii(i.w);
 698 }
 699
 700 static void
 701 _Btype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
 702        jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
 703 {
 704     instr_t     i;
 705     assert(!(op  & ~0x7f));
 706     assert(!(fct & ~0x07));
 707     assert(!(rs1 & ~0x1f));
 708     assert(!(rs2 & ~0x1f));
 709     assert(!(imm & 1) && simm12_p(imm));
 710     i.B.opcode  = op;
 711     i.B.imm11   = (imm >> 11) & 0x1;
 712     i.B.imm4_1  = (imm >>  1) & 0xf;
 713     i.B.funct3  = fct;
 714     i.B.rs1     = rs1;
 715     i.B.rs2     = rs2;
 716     i.B.imm10_5 = (imm >>  5) & 0x3f;
 717     i.B.imm12   = (imm >> 12) & 0x1;
 718     ii(i.w);
 719 }
 720
 721 static void
 722 _Utype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
 723 {
 724     instr_t     i;
 725     assert(!(op & ~0x7f));
 726     assert(!(rd & ~0x1f));
 727     assert(simm20_p(imm));
 728     i.U.opcode  = op;
 729     i.U.rd      = rd;
 730     i.U.imm12_31= imm;
 731     ii(i.w);
 732 }
 733
 734 static void
 735 _Jtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
 736 {
 737     instr_t     i;
 738     assert(!(op & ~0x7f));
 739     assert(!(rd & ~0x1f));
 740     assert(!(imm & 1) && imm <= 1048575 && imm >= -1048576);
 741     i.J.opcode  = op;
 742     i.J.rd      = rd;
 743     i.J.imm19_12= (imm >> 12) &  0xff;
 744     i.J.imm11   = (imm >> 11) &   0x1;
 745     i.J.imm10_1 = (imm >>  1) & 0x3ff;
 746     i.J.imm20   = (imm >> 20) &   0x1;
 747     ii(i.w);
 748 }
 749
 750 static void
 751 _nop(jit_state_t *_jit, jit_int32_t im)
 752 {
 753     for (; im > 0; im -= 4)
 754         NOP();
 755     assert(im == 0);
 756 }
 757
 758 static void
 759 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 760 {
 761     if (simm12_p(i0))
 762         ADDI(r0, r1, i0);
 763     else {
 764         jit_int32_t     t0;
 765         t0 = jit_get_reg(jit_class_gpr);
 766         movi(rn(t0), i0);
 767         addr(r0, r1, rn(t0));
 768         jit_unget_reg(t0);
 769     }
 770 }
 771
 772 static void
 773 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 774 {
 775     jit_int32_t         t0;
 776     if (jit_carry == _NOREG)
 777         jit_carry = jit_get_reg(jit_class_gpr);
 778     if (r0 == r1) {
 779         t0 = jit_get_reg(jit_class_gpr);
 780         addr(rn(t0), r1, r2);
 781         SLTU(rn(jit_carry), rn(t0), r1);
 782         movr(r0, rn(t0));
 783         jit_unget_reg(t0);
 784     }
 785     else {
 786         addr(r0, r1, r2);
 787         SLTU(rn(jit_carry), r0, r1);
 788     }
 789 }
 790
 791 static void
 792 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 793 {
 794     jit_int32_t         t0;
 795     if (jit_carry == _NOREG)
 796         jit_carry = jit_get_reg(jit_class_gpr);
 797     if (r0 == r1) {
 798         t0 = jit_get_reg(jit_class_gpr);
 799         addi(rn(t0), r1, i0);
 800         SLTU(rn(jit_carry), rn(t0), r1);
 801         movr(r0, rn(t0));
 802         jit_unget_reg(t0);
 803     }
 804     else {
 805         addi(r0, r1, i0);
 806         SLTU(rn(jit_carry), r0, r1);
 807     }
 808 }
 809
 810 static void
 811 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 812 {
 813     jit_int32_t         t0;
 814     assert(jit_carry != _NOREG);
 815     t0 = jit_get_reg(jit_class_gpr);
 816     movr(rn(t0), rn(jit_carry));
 817     addcr(r0, r1, r2);
 818     addcr(r0, r0, rn(t0));
 819     jit_unget_reg(t0);
 820 }
 821
 822 static void
 823 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 824 {
 825     jit_int32_t         t0;
 826     assert(jit_carry != _NOREG);
 827     t0 = jit_get_reg(jit_class_gpr);
 828     movr(rn(t0), rn(jit_carry));
 829     addci(r0, r1, i0);
 830     addcr(r0, r0, rn(t0));
 831     jit_unget_reg(t0);
 832 }
 833
 834 static void
 835 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 836 {
 837     if (simm12_p(-i0))
 838         ADDI(r0, r1, -i0);
 839     else {
 840         jit_int32_t     t0;
 841         t0 = jit_get_reg(jit_class_gpr);
 842         movi(rn(t0), i0);
 843         subr(r0, r1, rn(t0));
 844         jit_unget_reg(t0);
 845     }
 846 }
 847
 848 static void
 849 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 850 {
 851     jit_int32_t         t0;
 852     if (jit_carry == _NOREG)
 853         jit_carry = jit_get_reg(jit_class_gpr);
 854     if (r0 == r1) {
 855         t0 = jit_get_reg(jit_class_gpr);
 856         subr(rn(t0), r1, r2);
 857         SLTU(rn(jit_carry), r1, rn(t0));
 858         movr(r0, rn(t0));
 859         jit_unget_reg(t0);
 860     }
 861     else {
 862         subr(r0, r1, r2);
 863         SLTU(rn(jit_carry), r1, r0);
 864     }
 865 }
 866
 867 static void
 868 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 869 {
 870     jit_int32_t         t0;
 871     if (jit_carry == _NOREG)
 872         jit_carry = jit_get_reg(jit_class_gpr);
 873     if (r0 == r1) {
 874         t0 = jit_get_reg(jit_class_gpr);
 875         subi(rn(t0), r1, i0);
 876         SLTU(rn(jit_carry), r1, rn(t0));
 877         movr(r0, rn(t0));
 878         jit_unget_reg(t0);
 879     }
 880     else {
 881         subi(r0, r1, i0);
 882         SLTU(rn(jit_carry), r1, r0);
 883     }
 884 }
 885
 886 static void
 887 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
 888 {
 889     jit_int32_t         t0;
 890     assert(jit_carry != _NOREG);
 891     t0 = jit_get_reg(jit_class_gpr);
 892     movr(rn(t0), rn(jit_carry));
 893     subcr(r0, r1, r2);
 894     subcr(r0, r0, rn(t0));
 895     jit_unget_reg(t0);
 896 }
 897
 898 static void
 899 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 900 {
 901     jit_int32_t         t0;
 902     assert(jit_carry != _NOREG);
 903     t0 = jit_get_reg(jit_class_gpr);
 904     movr(rn(t0), rn(jit_carry));
 905     subci(r0, r1, i0);
 906     subcr(r0, r0, rn(t0));
 907     jit_unget_reg(t0);
 908 }
 909
 910 static void
 911 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 912 {
 913     subi(r0, r1, i0);
 914     negr(r0, r0);
 915 }
 916
 917 static void
 918 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 919 {
 920     jit_int32_t         t0;
 921     t0 = jit_get_reg(jit_class_gpr);
 922     movi(rn(t0), i0);
 923     mulr(r0, r1, rn(t0));
 924     jit_unget_reg(t0);
 925 }
 926
 927 static void
 928 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 929 {
 930     jit_int32_t         t0;
 931     t0 = jit_get_reg(jit_class_gpr);
 932     movi(rn(t0), i0);
 933     divr(r0, r1, rn(t0));
 934     jit_unget_reg(t0);
 935 }
 936
 937 static void
 938 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 939 {
 940     jit_int32_t         t0;
 941     t0 = jit_get_reg(jit_class_gpr);
 942     movi(rn(t0), i0);
 943     divr_u(r0, r1, rn(t0));
 944     jit_unget_reg(t0);
 945 }
 946
 947 static void
 948 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 949 {
 950     jit_int32_t         t0;
 951     t0 = jit_get_reg(jit_class_gpr);
 952     movi(rn(t0), i0);
 953     remr(r0, r1, rn(t0));
 954     jit_unget_reg(t0);
 955 }
 956
 957 static void
 958 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
 959 {
 960     jit_int32_t         t0;
 961     t0 = jit_get_reg(jit_class_gpr);
 962     movi(rn(t0), i0);
 963     remr_u(r0, r1, rn(t0));
 964     jit_unget_reg(t0);
 965 }
 966
 967 static void
 968 _qmulr(jit_state_t *_jit, jit_int32_t r0,
 969        jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 970 {
 971     jit_int32_t         t0;
 972     if (r0 == r2 || r0 == r3) {
 973         t0 = jit_get_reg(jit_class_gpr);
 974         mulr(rn(t0), r2, r3);
 975     }
 976     else
 977         mulr(r0, r2, r3);
 978     MULH(r1, r2, r3);
 979     if (r0 == r2 || r0 == r3) {
 980         movr(r0, rn(t0));
 981         jit_unget_reg(t0);
 982     }
 983 }
 984
 985 static void
 986 _qmuli(jit_state_t *_jit, jit_int32_t r0,
 987        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
 988 {
 989     jit_int32_t         t0;
 990     t0 = jit_get_reg(jit_class_gpr);
 991     movi(rn(t0), i0);
 992     qmulr(r0, r1, r2, rn(t0));
 993     jit_unget_reg(t0);
 994 }
 995
 996 static void
 997 _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
 998          jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
 999 {
1000     jit_int32_t         t0;
1001     if (r0 == r2 || r0 == r3) {
1002         t0 = jit_get_reg(jit_class_gpr);
1003         mulr(rn(t0), r2, r3);
1004     }
1005     else
1006         mulr(r0, r2, r3);
1007     MULHU(r1, r2, r3);
1008     if (r0 == r2 || r0 == r3) {
1009         movr(r0, rn(t0));
1010         jit_unget_reg(t0);
1011     }
1012 }
1013
1014 static void
1015 _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
1016          jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1017 {
1018     jit_int32_t         t0;
1019     t0 = jit_get_reg(jit_class_gpr);
1020     movi(rn(t0), i0);
1021     qmulr_u(r0, r1, r2, rn(t0));
1022     jit_unget_reg(t0);
1023 }
1024
1025 static void
1026 _iqdivr(jit_state_t *_jit, jit_bool_t sign,
1027         jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1028 {
1029     jit_int32_t         sv0, rg0;
1030     jit_int32_t         sv1, rg1;
1031     if (r0 == r2 || r0 == r3) {
1032         sv0 = jit_get_reg(jit_class_gpr);
1033         rg0 = rn(sv0);
1034     }
1035     else
1036         rg0 = r0;
1037     if (r1 == r2 || r1 == r3) {
1038         sv1 = jit_get_reg(jit_class_gpr);
1039         rg1 = rn(sv1);
1040     }
1041     else
1042         rg1 = r1;
1043     if (sign)
1044         divr(rg0, r2, r3);
1045     else
1046         divr_u(rg0, r2, r3);
1047     mulr(rg1, r3, rg0);
1048     subr(rg1, r2, rg1);
1049     if (rg0 != r0) {
1050         movr(r0, rg0);
1051         jit_unget_reg(sv0);
1052     }
1053     if (rg1 != r1) {
1054         movr(r1, rg1);
1055         jit_unget_reg(sv1);
1056     }
1057 }
1058
1059 static void
1060 _qdivi(jit_state_t *_jit, jit_int32_t r0,
1061        jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1062 {
1063     jit_int32_t         t0;
1064     t0 = jit_get_reg(jit_class_gpr);
1065     movi(rn(t0), i0);
1066     qdivr(r0, r1, r2, rn(t0));
1067     jit_unget_reg(t0);
1068 }
1069
1070 static void
1071 _qdivi_u(jit_state_t *_jit, jit_int32_t r0,
1072          jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1073 {
1074     jit_int32_t         t0;
1075     t0 = jit_get_reg(jit_class_gpr);
1076     movi(rn(t0), i0);
1077     qdivr_u(r0, r1, r2, rn(t0));
1078     jit_unget_reg(t0);
1079 }
1080
1081 static void
1082 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1083 {
1084     if (i0 == 0)
1085         movr(r0, r1);
1086     else {
1087         assert(i0 > 0 && i0 < 64);
1088         SLLI(r0, r1, i0);
1089     }
1090 }
1091
1092 static void
1093 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1094 {
1095     if (i0 == 0)
1096         movr(r0, r1);
1097     else {
1098         assert(i0 > 0 && i0 < 64);
1099         SRAI(r0, r1, i0);
1100     }
1101 }
1102
1103 static void
1104 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1105 {
1106     if (i0 == 0)
1107         movr(r0, r1);
1108     else {
1109         assert(i0 > 0 && i0 < 64);
1110         SRLI(r0, r1, i0);
1111     }
1112 }
1113
1114 static void
1115 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1116 {
1117     if (simm12_p(i0))
1118         ANDI(r0, r1, i0);
1119     else {
1120         jit_int32_t     t0;
1121         t0 = jit_get_reg(jit_class_gpr);
1122         movi(rn(t0), i0);
1123         andr(r0, r1, rn(t0));
1124         jit_unget_reg(t0);
1125     }
1126 }
1127
1128 static void
1129 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1130 {
1131     if (simm12_p(i0))
1132         ORI(r0, r1, i0);
1133     else {
1134         jit_int32_t     t0;
1135         t0 = jit_get_reg(jit_class_gpr);
1136         movi(rn(t0), i0);
1137         orr(r0, r1, rn(t0));
1138         jit_unget_reg(t0);
1139     }
1140 }
1141
1142 static void
1143 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1144 {
1145     if (simm12_p(i0))
1146         XORI(r0, r1, i0);
1147     else {
1148         jit_int32_t     t0;
1149         t0 = jit_get_reg(jit_class_gpr);
1150         movi(rn(t0), i0);
1151         xorr(r0, r1, rn(t0));
1152         jit_unget_reg(t0);
1153     }
1154 }
1155
1156 #  define DEFLD(T,O)                                                    \
1157 static void                                                             \
1158 _ldi_##T(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)              \
1159 {                                                                       \
1160     if (simm12_p(i0))                                                   \
1161         L##O(r0, _ZERO_REGNO, i0);                                      \
1162     else {                                                              \
1163         jit_int32_t     t0;                                             \
1164         t0 = jit_get_reg(jit_class_gpr);                                \
1165         movi(rn(t0), i0);                                               \
1166         ldr_##T(r0, rn(t0));                                            \
1167         jit_unget_reg(t0);                                              \
1168     }                                                                   \
1169 }                                                                       \
1170                                                                         \
1171 static void                                                             \
1172 _ldxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1173 {                                                                       \
1174     jit_int32_t t0;                                                     \
1175     t0 = jit_get_reg(jit_class_gpr);                                    \
1176     addr(rn(t0), r1, r2);                                               \
1177     ldr_##T(r0, rn(t0));                                                \
1178     jit_unget_reg(t0);                                                  \
1179 }                                                                       \
1180                                                                         \
1181 static void                                                             \
1182 _ldxi_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)\
1183 {                                                                       \
1184     if (simm12_p(i0))                                                   \
1185         L##O(r0, r1, i0);                                               \
1186     else {                                                              \
1187         jit_int32_t     t0;                                             \
1188         t0 = jit_get_reg(jit_class_gpr);                                \
1189         addi(rn(t0), r1, i0);                                           \
1190         ldr_##T(r0, rn(t0));                                            \
1191         jit_unget_reg(t0);                                              \
1192     }                                                                   \
1193 }
1194
1195 DEFLD(c,B)
1196 DEFLD(uc,BU)
1197 DEFLD(s,H)
1198 DEFLD(us,HU)
1199 DEFLD(i,W)
1200 DEFLD(ui,WU)
1201 DEFLD(l,D)
1202
1203 #  define DEFST(T, O)                                                   \
1204 static void                                                             \
1205 _sti_##T(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)              \
1206 {                                                                       \
1207     if (simm12_p(i0))                                                   \
1208         S##O(_ZERO_REGNO, r0, i0);                                      \
1209     else {                                                              \
1210         jit_int32_t     t0;                                             \
1211         t0 = jit_get_reg(jit_class_gpr);                                \
1212         movi(rn(t0), i0);                                               \
1213         str_##T(rn(t0), r0);                                            \
1214         jit_unget_reg(t0);                                              \
1215     }                                                                   \
1216 }                                                                       \
1217                                                                         \
1218 static void                                                             \
1219 _stxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1220 {                                                                       \
1221     jit_int32_t t0;                                                     \
1222     t0 = jit_get_reg(jit_class_gpr);                                    \
1223     addr(rn(t0), r0, r1);                                               \
1224     str_##T(rn(t0), r2);                                                \
1225     jit_unget_reg(t0);                                                  \
1226 }                                                                       \
1227                                                                         \
1228 static void                                                             \
1229 _stxi_##T(jit_state_t *_jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)\
1230 {                                                                       \
1231     if (simm12_p(i0))                                                   \
1232         S##O(r0, r1, i0);                                               \
1233     else {                                                              \
1234         jit_int32_t     t0;                                             \
1235         t0 = jit_get_reg(jit_class_gpr);                                \
1236         addi(rn(t0), r0, i0);                                           \
1237         str_##T(rn(t0), r1);                                            \
1238         jit_unget_reg(t0);                                              \
1239     }                                                                   \
1240 }
1241
1242 DEFST(c, B)
1243 DEFST(s, H)
1244 DEFST(i, W)
1245 DEFST(l, D)
1246
1247 static void
1248 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1249 {
1250     lshi(r0, r1, 56);
1251     rshi(r0, r0, 56);
1252 }
1253
1254 static void
1255 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1256 {
1257     lshi(r0, r1, 48);
1258     rshi(r0, r0, 48);
1259 }
1260
1261 static void
1262 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1263 {
1264     lshi(r0, r1, 48);
1265     rshi_u(r0, r0, 48);
1266 }
1267
1268 static void
1269 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1270 {
1271     lshi(r0, r1, 32);
1272     rshi_u(r0, r0, 32);
1273 }
1274
1275 static void
1276 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1277 {
1278     if (simm32_p(i0)) {
1279         jit_int32_t     lo = (jit_int32_t)i0 << 20 >> 20;
1280         jit_int32_t     hi = i0 - lo;
1281         if (hi) {
1282             LUI(r0, hi >> 12);
1283             if (lo)
1284                 ADDIW(r0, r0, lo);
1285         }
1286         else
1287             ADDIW(r0, _ZERO_REGNO, lo);
1288     }
1289     else {
1290         jit_int32_t     lo = i0 << 32 >> 32;
1291         jit_word_t      hi = i0 - lo;
1292         jit_int32_t     t0 = jit_get_reg(jit_class_gpr);
1293         movi(rn(t0), (jit_int32_t)(hi >> 32));
1294         movi(r0, lo);
1295         lshi(rn(t0), rn(t0), 32);
1296         addr(r0, r0, rn(t0));
1297         jit_unget_reg(t0);
1298     }
1299 }
1300
1301 static jit_word_t
1302 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1303 {
1304     jit_word_t          w;
1305     jit_int32_t         t0;
1306     jit_int32_t         ww = i0 << 32 >> 32;
1307     jit_int32_t         lo = ww << 20 >> 20;
1308     jit_int32_t         hi = ww - lo;
1309     w = _jit->pc.w;
1310     t0 = jit_get_reg(jit_class_gpr);
1311     LUI(r0, hi >> 12);
1312     ADDIW(r0, r0, lo);
1313     ww = i0 >> 32;
1314     lo = ww << 20 >> 20;
1315     hi = ww - lo;
1316     LUI(rn(t0), hi >> 12);
1317     ADDIW(rn(t0), rn(t0), lo);
1318     SLLI(rn(t0), rn(t0), 32);
1319     ADD(r0, r0, rn(t0));
1320     jit_unget_reg(t0);
1321     return (w);
1322 }
1323
1324 static void
1325 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1326 {
1327     jit_word_t  w;
1328     w = beqi(_jit->pc.w, r2, 0);
1329     movr(r1, r0);
1330     patch_at(w, _jit->pc.w);
1331 }
1332
1333 static void
1334 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1335 {
1336     jit_word_t  w;
1337     w = bnei(_jit->pc.w, r2, 0);
1338     movr(r1, r0);
1339     patch_at(w, _jit->pc.w);
1340 }
1341
1342 static void
1343 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1344 {
1345     if (simm12_p(i0))
1346         SLTI(r0, r1, i0);
1347     else {
1348         jit_int32_t     t0;
1349         t0 = jit_get_reg(jit_class_gpr);
1350         movi(r0, i0);
1351         ltr(r0, r1, rn(t0));
1352         jit_unget_reg(t0);
1353     }
1354 }
1355
1356 static void
1357 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1358 {
1359     if (simm12_p(i0))
1360         SLTIU(r0, r1, i0);
1361     else {
1362         jit_int32_t     t0;
1363         t0 = jit_get_reg(jit_class_gpr);
1364         movi(r0, i0);
1365         ltr_u(r0, r1, rn(t0));
1366         jit_unget_reg(t0);
1367     }
1368 }
1369
1370 static void
1371 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1372 {
1373     SLT(r0, r2, r1);
1374     XORI(r0, r0, 1);
1375 }
1376
1377 static void
1378 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1379 {
1380     jit_int32_t         t0;
1381     if (i0 == 0) {
1382         SLT(r0, _ZERO_REGNO, r1);
1383         XORI(r0, r0, 1);
1384     }
1385     else {
1386         t0 = jit_get_reg(jit_class_gpr);
1387         movi(rn(t0), i0);
1388         ler(r0, r1, rn(t0));
1389         jit_unget_reg(t0);
1390     }
1391 }
1392
1393 static void
1394 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1395 {
1396     SLTU(r0, r2, r1);
1397     XORI(r0, r0, 1);
1398 }
1399
1400 static void
1401 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1402 {
1403     jit_int32_t         t0;
1404     if (i0 == 0) {
1405         SLTU(r0, _ZERO_REGNO, r1);
1406         XORI(r0, r0, 1);
1407     }
1408     else {
1409         t0 = jit_get_reg(jit_class_gpr);
1410         movi(rn(t0), i0);
1411         ler_u(r0, r1, rn(t0));
1412         jit_unget_reg(t0);
1413     }
1414 }
1415
1416 static void
1417 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1418 {
1419     subr(r0, r1, r2);
1420     SLTU(r0, _ZERO_REGNO, r0);
1421     XORI(r0, r0, 1);
1422 }
1423
1424 static void
1425 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1426 {
1427     if (i0) {
1428         subi(r0, r1, i0);
1429         SLTU(r0, _ZERO_REGNO, r0);
1430     }
1431     else
1432         SLTU(r0, _ZERO_REGNO, r1);
1433     XORI(r0, r0, 1);
1434 }
1435
1436 static void
1437 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1438 {
1439     SLT(r0, r1, r2);
1440     XORI(r0, r0, 1);
1441 }
1442
1443 static void
1444 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1445 {
1446     jit_int32_t         t0;
1447     t0 = jit_get_reg(jit_class_gpr);
1448     movi(rn(t0), i0);
1449     ger(r0, r1, rn(t0));
1450     jit_unget_reg(t0);
1451 }
1452
1453 static void
1454 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1455 {
1456     SLTU(r0, r1, r2);
1457     XORI(r0, r0, 1);
1458 }
1459
1460 static void
1461 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1462 {
1463     jit_int32_t         t0;
1464     t0 = jit_get_reg(jit_class_gpr);
1465     movi(rn(t0), i0);
1466     ger_u(r0, r1, rn(t0));
1467     jit_unget_reg(t0);
1468 }
1469
1470 static void
1471 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1472 {
1473     jit_int32_t t0;
1474     t0 = jit_get_reg(jit_class_gpr);
1475     movi(r0, i0);
1476     ltr(r0, rn(t0), r1);
1477     jit_unget_reg(t0);
1478 }
1479
1480 static void
1481 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1482 {
1483     jit_int32_t t0;
1484     t0 = jit_get_reg(jit_class_gpr);
1485     movi(r0, i0);
1486     ltr_u(r0, rn(t0), r1);
1487     jit_unget_reg(t0);
1488 }
1489
1490 static void
1491 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1492 {
1493     subr(r0, r1, r2);
1494     SLTU(r0, _ZERO_REGNO, r0);
1495 }
1496
1497 static void
1498 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1499 {
1500     if (i0) {
1501         subi(r0, r1, i0);
1502         SLTU(r0, _ZERO_REGNO, r0);
1503     }
1504     else
1505         SLTU(r0, _ZERO_REGNO, r1);
1506 }
1507
1508 static jit_word_t
1509 _bltr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1510 {
1511     jit_word_t          w;
1512     w = _jit->pc.w;
1513     BLT(r0, r1, br - w);
1514     return (w);
1515 }
1516
1517 static jit_word_t
1518 _blti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1519 {
1520     jit_word_t          w;
1521     jit_reg_t           t0;
1522     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1523     movi(rn(t0), i0);
1524     w = bltr(br, r0, rn(t0));
1525     jit_unget_reg(t0);
1526     return (w);
1527 }
1528
1529 static jit_word_t
1530 _bltr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1531 {
1532     jit_word_t          w;
1533     w = _jit->pc.w;
1534     BLTU(r0, r1, br - w);
1535     return (w);
1536 }
1537
1538 static jit_word_t
1539 _blti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1540 {
1541     jit_word_t          w;
1542     jit_reg_t           t0;
1543     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1544     movi(rn(t0), i0);
1545     w = bltr_u(br, r0, rn(t0));
1546     jit_unget_reg(t0);
1547     return (w);
1548 }
1549
1550 static jit_word_t
1551 _bler(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1552 {
1553     jit_word_t          w;
1554     w = _jit->pc.w;
1555     BGE(r1, r0, br - w);
1556     return (w);
1557 }
1558
1559 static jit_word_t
1560 _blei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1561 {
1562     jit_word_t          w;
1563     jit_reg_t           t0;
1564     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1565     movi(rn(t0), i0);
1566     w = bler(br, r0, rn(t0));
1567     jit_unget_reg(t0);
1568     return (w);
1569 }
1570
1571 static jit_word_t
1572 _bler_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1573 {
1574     jit_word_t          w;
1575     w = _jit->pc.w;
1576     BGEU(r1, r0, br - w);
1577     return (w);
1578 }
1579
1580 static jit_word_t
1581 _blei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1582 {
1583     jit_word_t          w;
1584     jit_reg_t           t0;
1585     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1586     movi(rn(t0), i0);
1587     w = bler_u(br, r0, rn(t0));
1588     jit_unget_reg(t0);
1589     return (w);
1590 }
1591
1592 static jit_word_t
1593 _beqr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1594 {
1595     jit_word_t          w;
1596     w = _jit->pc.w;
1597     BEQ(r1, r0, br - w);
1598     return (w);
1599 }
1600
1601 static jit_word_t
1602 _beqi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1603 {
1604     jit_word_t          w;
1605     jit_reg_t           t0;
1606     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1607     movi(rn(t0), i0);
1608     w = beqr(br, r0, rn(t0));
1609     jit_unget_reg(t0);
1610     return (w);
1611 }
1612
1613 static jit_word_t
1614 _bger(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1615 {
1616     jit_word_t          w;
1617     w = _jit->pc.w;
1618     BGE(r0, r1, br - w);
1619     return (w);
1620 }
1621
1622 static jit_word_t
1623 _bgei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1624 {
1625     jit_word_t          w;
1626     jit_reg_t           t0;
1627     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1628     movi(rn(t0), i0);
1629     w = bger(br, r0, rn(t0));
1630     jit_unget_reg(t0);
1631     return (w);
1632 }
1633
1634 static jit_word_t
1635 _bger_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1636 {
1637     jit_word_t          w;
1638     w = _jit->pc.w;
1639     BGEU(r0, r1, br - w);
1640     return (w);
1641 }
1642
1643 static jit_word_t
1644 _bgei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1645 {
1646     jit_word_t          w;
1647     jit_reg_t           t0;
1648     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1649     movi(rn(t0), i0);
1650     w = bger_u(br, r0, rn(t0));
1651     jit_unget_reg(t0);
1652     return (w);
1653 }
1654
1655 static jit_word_t
1656 _bgtr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1657 {
1658     jit_word_t          w;
1659     w = _jit->pc.w;
1660     BLT(r1, r0, br - w);
1661     return (w);
1662 }
1663
1664 static jit_word_t
1665 _bgti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1666 {
1667     jit_word_t          w;
1668     jit_reg_t           t0;
1669     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1670     movi(rn(t0), i0);
1671     w = bgtr(br, r0, rn(t0));
1672     jit_unget_reg(t0);
1673     return (w);
1674 }
1675
1676 static jit_word_t
1677 _bgtr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1678 {
1679     jit_word_t          w;
1680     w = _jit->pc.w;
1681     BLTU(r1, r0, br - w);
1682     return (w);
1683 }
1684
1685 static jit_word_t
1686 _bgti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1687 {
1688     jit_word_t          w;
1689     jit_reg_t           t0;
1690     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1691     movi(rn(t0), i0);
1692     w = bgtr_u(br, r0, rn(t0));
1693     jit_unget_reg(t0);
1694     return (w);
1695 }
1696
1697 static jit_word_t
1698 _bner(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1699 {
1700     jit_word_t          w;
1701     w = _jit->pc.w;
1702     BNE(r1, r0, br - w);
1703     return (w);
1704 }
1705
1706 static jit_word_t
1707 _bnei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1708 {
1709     jit_word_t          w;
1710     jit_reg_t           t0;
1711     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1712     movi(rn(t0), i0);
1713     w = bner(br, r0, rn(t0));
1714     jit_unget_reg(t0);
1715     return (w);
1716 }
1717
1718 static jit_word_t
1719 _boaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1720 {
1721     jit_word_t          w, jal;
1722     jit_int32_t         t0, t1;
1723     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1724     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1725     /* t0 = r1 < 0; */
1726     SLT(rn(t0), r1, _ZERO_REGNO);
1727     /* t1 = r0 */
1728     movr(rn(t1), r0);
1729     /* r0 = r0 + r1 */
1730     addr(r0, r0, r1);
1731     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1732     w = _jit->pc.w;
1733     BNE(rn(t0), _ZERO_REGNO, 0);
1734     /* r1 >= 0 */
1735     SLT(rn(t1), r0, rn(t1));
1736     jal = _jit->pc.w;
1737     JAL(_ZERO_REGNO, 0);
1738     /* r1 < 0 */
1739     patch_at(w, _jit->pc.w);
1740     SLT(rn(t1), rn(t1), r0);
1741     /**/
1742     patch_at(jal, _jit->pc.w);
1743     w = _jit->pc.w;
1744     BNE(rn(t1), _ZERO_REGNO, br - w);
1745     jit_unget_reg(t1);
1746     jit_unget_reg(t0);
1747     return (w);
1748 }
1749
1750 static jit_word_t
1751 _boaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1752 {
1753     jit_word_t          w;
1754     jit_int32_t         t0;
1755     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1756     movi(rn(t0), i0);
1757     w = boaddr(br, r0, rn(t0));
1758     jit_unget_reg(t0);
1759     return (w);
1760 }
1761
1762 static jit_word_t
1763 _boaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1764 {
1765     jit_word_t          w;
1766     jit_int32_t         t0, t1;
1767     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1768     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1769     addr(rn(t0), r0, r1);
1770     SLTU(rn(t1), rn(t0), r0);
1771     movr(r0, rn(t0));
1772     w = _jit->pc.w;
1773     BNE(_ZERO_REGNO, rn(t1), br - w);
1774     jit_unget_reg(t1);
1775     jit_unget_reg(t0);
1776     return (w);
1777 }
1778
1779 static jit_word_t
1780 _boaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1781 {
1782     jit_word_t          w;
1783     jit_int32_t         t0;
1784     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1785     movi(rn(t0), i0);
1786     w = boaddr_u(br, r0, rn(t0));
1787     jit_unget_reg(t0);
1788     return (w);
1789 }
1790
1791 static jit_word_t
1792 _bxaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1793 {
1794     jit_word_t          w, jal;
1795     jit_int32_t         t0, t1;
1796     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1797     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1798     /* t0 = r1 < 0; */
1799     SLT(rn(t0), r1, _ZERO_REGNO);
1800     /* t1 = r0 */
1801     movr(rn(t1), r0);
1802     /* r0 = r0 + r1 */
1803     addr(r0, r0, r1);
1804     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1805     w = _jit->pc.w;
1806     BNE(rn(t0), _ZERO_REGNO, 0);
1807     /* r1 >= 0 */
1808     SLT(rn(t1), r0, rn(t1));
1809     jal = _jit->pc.w;
1810     JAL(_ZERO_REGNO, 0);
1811     /* r1 < 0 */
1812     patch_at(w, _jit->pc.w);
1813     SLT(rn(t1), rn(t1), r0);
1814     /**/
1815     patch_at(jal, _jit->pc.w);
1816     w = _jit->pc.w;
1817     BEQ(rn(t1), _ZERO_REGNO, br - w);
1818     jit_unget_reg(t1);
1819     jit_unget_reg(t0);
1820     return (w);
1821 }
1822
1823 static jit_word_t
1824 _bxaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1825 {
1826     jit_word_t          w;
1827     jit_int32_t         t0;
1828     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1829     movi(rn(t0), i0);
1830     w = bxaddr(br, r0, rn(t0));
1831     jit_unget_reg(t0);
1832     return (w);
1833 }
1834
1835 static jit_word_t
1836 _bxaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1837 {
1838     jit_word_t          w;
1839     jit_int32_t         t0, t1;
1840     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1841     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1842     addr(rn(t0), r0, r1);
1843     SLTU(rn(t1), rn(t0), r0);
1844     movr(r0, rn(t0));
1845     w = _jit->pc.w;
1846     BEQ(_ZERO_REGNO, rn(t1), br - w);
1847     jit_unget_reg(t1);
1848     jit_unget_reg(t0);
1849     return (w);
1850 }
1851
1852 static jit_word_t
1853 _bxaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1854 {
1855     jit_word_t          w;
1856     jit_int32_t         t0;
1857     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1858     movi(rn(t0), i0);
1859     w = bxaddr_u(br, r0, rn(t0));
1860     jit_unget_reg(t0);
1861     return (w);
1862 }
1863
1864 static jit_word_t
1865 _bosubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1866 {
1867     jit_word_t          w, jal;
1868     jit_int32_t         t0, t1;
1869     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1870     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1871     /* t0 = 0 < r1; */
1872     SLT(rn(t0), _ZERO_REGNO, r1);
1873     /* t1 = r0 */
1874     movr(rn(t1), r0);
1875     /* r0 = r0 - r1 */
1876     subr(r0, r0, r1);
1877     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1878     w = _jit->pc.w;
1879     BNE(rn(t0), _ZERO_REGNO, 0);
1880     /* r1 >= 0 */
1881     SLT(rn(t1), r0, rn(t1));
1882     jal = _jit->pc.w;
1883     JAL(_ZERO_REGNO, 0);
1884     /* r1 < 0 */
1885     patch_at(w, _jit->pc.w);
1886     SLT(rn(t1), rn(t1), r0);
1887     /**/
1888     patch_at(jal, _jit->pc.w);
1889     w = _jit->pc.w;
1890     BNE(rn(t1), _ZERO_REGNO, br - w);
1891     jit_unget_reg(t1);
1892     jit_unget_reg(t0);
1893     return (w);
1894 }
1895
1896 static jit_word_t
1897 _bosubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1898 {
1899     jit_word_t          w;
1900     jit_int32_t         t0;
1901     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1902     movi(rn(t0), i0);
1903     w = bosubr(br, r0, rn(t0));
1904     jit_unget_reg(t0);
1905     return (w);
1906 }
1907
1908 static jit_word_t
1909 _bosubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1910 {
1911     jit_word_t          w;
1912     jit_int32_t         t0, t1;
1913     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1914     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1915     subr(rn(t0), r0, r1);
1916     SLTU(rn(t1), r0, rn(t0));
1917     movr(r0, rn(t0));
1918     w = _jit->pc.w;
1919     BNE(_ZERO_REGNO, rn(t1), br - w);
1920     jit_unget_reg(t1);
1921     jit_unget_reg(t0);
1922     return (w);
1923 }
1924
1925 static jit_word_t
1926 _bosubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1927 {
1928     jit_word_t          w;
1929     jit_int32_t         t0;
1930     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1931     movi(rn(t0), i0);
1932     w = bosubr_u(br, r0, rn(t0));
1933     jit_unget_reg(t0);
1934     return (w);
1935 }
1936
1937 static jit_word_t
1938 _bxsubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1939 {
1940     jit_word_t          w, jal;
1941     jit_int32_t         t0, t1;
1942     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1943     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1944     /* t0 = r1 < 0; */
1945     SLT(rn(t0), _ZERO_REGNO, r1);
1946     /* t1 = r0 */
1947     movr(rn(t1), r0);
1948     /* r0 = r0 - r1 */
1949     subr(r0, r0, r1);
1950     /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1951     w = _jit->pc.w;
1952     BNE(rn(t0), _ZERO_REGNO, 0);
1953     /* r1 >= 0 */
1954     SLT(rn(t1), r0, rn(t1));
1955     jal = _jit->pc.w;
1956     JAL(_ZERO_REGNO, 0);
1957     /* r1 < 0 */
1958     patch_at(w, _jit->pc.w);
1959     SLT(rn(t1), rn(t1), r0);
1960     /**/
1961     patch_at(jal, _jit->pc.w);
1962     w = _jit->pc.w;
1963     BEQ(rn(t1), _ZERO_REGNO, br - w);
1964     jit_unget_reg(t1);
1965     jit_unget_reg(t0);
1966     return (w);
1967 }
1968
1969 static jit_word_t
1970 _bxsubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1971 {
1972     jit_word_t          w;
1973     jit_int32_t         t0;
1974     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1975     movi(rn(t0), i0);
1976     w = bxsubr(br, r0, rn(t0));
1977     jit_unget_reg(t0);
1978     return (w);
1979 }
1980
1981 static jit_word_t
1982 _bxsubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1983 {
1984     jit_word_t          w;
1985     jit_int32_t         t0, t1;
1986     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1987     t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1988     subr(rn(t0), r0, r1);
1989     SLTU(rn(t1), r0, rn(t0));
1990     movr(r0, rn(t0));
1991     w = _jit->pc.w;
1992     BEQ(_ZERO_REGNO, rn(t1), br - w);
1993     jit_unget_reg(t1);
1994     jit_unget_reg(t0);
1995     return (w);
1996 }
1997
1998 static jit_word_t
1999 _bxsubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2000 {
2001     jit_word_t          w;
2002     jit_int32_t         t0;
2003     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2004     movi(rn(t0), i0);
2005     w = bxsubr_u(br, r0, rn(t0));
2006     jit_unget_reg(t0);
2007     return (w);
2008 }
2009
2010 static jit_word_t
2011 _bmsr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2012 {
2013     jit_word_t          w;
2014     jit_int32_t         t0;
2015     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2016     AND(rn(t0), r0, r1);
2017     w = _jit->pc.w;
2018     BNE(_ZERO_REGNO, rn(t0), br - w);
2019     jit_unget_reg(t0);
2020     return (w);
2021 }
2022
2023 static jit_word_t
2024 _bmsi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2025 {
2026     jit_word_t          w;
2027     jit_int32_t         t0;
2028     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2029     movi(rn(t0), i0);
2030     w = bmsr(br, r0, rn(t0));
2031     jit_unget_reg(t0);
2032     return (w);
2033 }
2034
2035 static jit_word_t
2036 _bmcr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2037 {
2038     jit_word_t          w;
2039     jit_int32_t         t0;
2040     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2041     AND(rn(t0), r0, r1);
2042     w = _jit->pc.w;
2043     BEQ(_ZERO_REGNO, rn(t0), br - w);
2044     jit_unget_reg(t0);
2045     return (w);
2046 }
2047
2048 static jit_word_t
2049 _bmci(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2050 {
2051     jit_word_t          w;
2052     jit_int32_t         t0;
2053     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2054     movi(rn(t0), i0);
2055     w = bmcr(br, r0, rn(t0));
2056     jit_unget_reg(t0);
2057     return (w);
2058 }
2059
2060 static void
2061 _jmpi(jit_state_t *_jit, jit_word_t i0)
2062 {
2063     jit_int32_t         t0;
2064     jit_word_t          dsp;
2065     dsp = i0 - _jit->pc.w;
2066     if (simm20_p(dsp))
2067         JAL(_ZERO_REGNO, dsp);
2068     else {
2069         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2070         movi(rn(t0), i0);
2071         jmpr(rn(t0));
2072         jit_unget_reg(t0);
2073     }
2074 }
2075
2076 static jit_word_t
2077 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2078 {
2079     jit_word_t          w;
2080     jit_int32_t         t0;
2081     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2082     w = movi_p(rn(t0), i0);
2083     jmpr(rn(t0));
2084     jit_unget_reg(t0);
2085     return (w);
2086 }
2087
2088 static void
2089 _calli(jit_state_t *_jit, jit_word_t i0)
2090 {
2091     jit_int32_t         t0;
2092     jit_word_t          dsp;
2093     dsp = i0 - _jit->pc.w;
2094     if (simm20_p(dsp))
2095         JAL(_RA_REGNO, dsp);
2096     else {
2097         t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2098         movi(rn(t0), i0);
2099         callr(rn(t0));
2100         jit_unget_reg(t0);
2101     }
2102 }
2103
2104 static jit_word_t
2105 _calli_p(jit_state_t *_jit, jit_word_t i0)
2106 {
2107     jit_word_t          w;
2108     jit_int32_t         t0;
2109     t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2110     w = movi_p(rn(t0), i0);
2111     callr(rn(t0));
2112     jit_unget_reg(t0);
2113     return (w);
2114 }
2115
2116 static void
2117 _prolog(jit_state_t *_jit, jit_node_t *node)
2118 {
2119     jit_int32_t         reg;
2120     if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2121         jit_int32_t     frame = -_jitc->function->frame;
2122         assert(_jitc->function->self.aoff >= frame);
2123         if (_jitc->function->assume_frame)
2124             return;
2125         _jitc->function->self.aoff = frame;
2126     }
2127     if (_jitc->function->allocar)
2128         _jitc->function->self.aoff &= -16;
2129     _jitc->function->stack = ((_jitc->function->self.alen -
2130                               /* align stack at 16 bytes */
2131                               _jitc->function->self.aoff) + 15) & -16;
2132     subi(_SP_REGNO, _SP_REGNO, stack_framesize);
2133     stxi(0, _SP_REGNO, _RA_REGNO);
2134     stxi(8, _SP_REGNO, _FP_REGNO);
2135     if (jit_regset_tstbit(&_jitc->function->regset, _S1))
2136         stxi(16, _SP_REGNO, 9);
2137     if (jit_regset_tstbit(&_jitc->function->regset, _S2))
2138         stxi(24, _SP_REGNO, 18);
2139     if (jit_regset_tstbit(&_jitc->function->regset, _S3))
2140         stxi(32, _SP_REGNO, 19);
2141     if (jit_regset_tstbit(&_jitc->function->regset, _S4))
2142         stxi(40, _SP_REGNO, 20);
2143     if (jit_regset_tstbit(&_jitc->function->regset, _S5))
2144         stxi(48, _SP_REGNO, 21);
2145     if (jit_regset_tstbit(&_jitc->function->regset, _S6))
2146         stxi(56, _SP_REGNO, 22);
2147     if (jit_regset_tstbit(&_jitc->function->regset, _S7))
2148         stxi(64, _SP_REGNO, 23);
2149     if (jit_regset_tstbit(&_jitc->function->regset, _S8))
2150         stxi(72, _SP_REGNO, 24);
2151     if (jit_regset_tstbit(&_jitc->function->regset, _S9))
2152         stxi(80, _SP_REGNO, 25);
2153     if (jit_regset_tstbit(&_jitc->function->regset, _S10))
2154         stxi(88, _SP_REGNO, 26);
2155     if (jit_regset_tstbit(&_jitc->function->regset, _S11))
2156         stxi(96, _SP_REGNO, 27);
2157     if (jit_regset_tstbit(&_jitc->function->regset, _FS0))
2158         stxi_d(104, _SP_REGNO, 8);
2159     if (jit_regset_tstbit(&_jitc->function->regset, _FS1))
2160         stxi_d(112, _SP_REGNO, 9);
2161     if (jit_regset_tstbit(&_jitc->function->regset, _FS2))
2162         stxi_d(120, _SP_REGNO, 18);
2163     if (jit_regset_tstbit(&_jitc->function->regset, _FS3))
2164         stxi_d(128, _SP_REGNO, 19);
2165     if (jit_regset_tstbit(&_jitc->function->regset, _FS4))
2166         stxi_d(136, _SP_REGNO, 20);
2167     if (jit_regset_tstbit(&_jitc->function->regset, _FS5))
2168         stxi_d(144, _SP_REGNO, 21);
2169     if (jit_regset_tstbit(&_jitc->function->regset, _FS6))
2170         stxi_d(152, _SP_REGNO, 22);
2171     if (jit_regset_tstbit(&_jitc->function->regset, _FS7))
2172         stxi_d(160, _SP_REGNO, 23);
2173     if (jit_regset_tstbit(&_jitc->function->regset, _FS8))
2174         stxi_d(168, _SP_REGNO, 24);
2175     if (jit_regset_tstbit(&_jitc->function->regset, _FS9))
2176         stxi_d(176, _SP_REGNO, 25);
2177     if (jit_regset_tstbit(&_jitc->function->regset, _FS10))
2178         stxi_d(184, _SP_REGNO, 26);
2179     if (jit_regset_tstbit(&_jitc->function->regset, _FS11))
2180         stxi_d(192, _SP_REGNO, 27);
2181     movr(_FP_REGNO, _SP_REGNO);
2182     if (_jitc->function->stack)
2183         subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
2184     if (_jitc->function->allocar) {
2185         reg = jit_get_reg(jit_class_gpr);
2186         movi(rn(reg), _jitc->function->self.aoff);
2187         stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2188         jit_unget_reg(reg);
2189     }
2190     if (_jitc->function->self.call & jit_call_varargs) {
2191         for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2192             stxi(stack_framesize - ((8 - reg) * 8),
2193                  _FP_REGNO, rn(JIT_RA0 - reg));
2194     }
2195 }
2196
2197 static void
2198 _epilog(jit_state_t *_jit, jit_node_t *node)
2199 {
2200     if (_jitc->function->assume_frame)
2201         return;
2202     movr(_SP_REGNO, _FP_REGNO);
2203     ldxi(_RA_REGNO, _SP_REGNO, 0);
2204     ldxi(_FP_REGNO, _SP_REGNO, 8);
2205     if (jit_regset_tstbit(&_jitc->function->regset, _S1))
2206         ldxi(9, _SP_REGNO, 16);
2207     if (jit_regset_tstbit(&_jitc->function->regset, _S2))
2208         ldxi(18, _SP_REGNO, 24);
2209     if (jit_regset_tstbit(&_jitc->function->regset, _S3))
2210         ldxi(19, _SP_REGNO, 32);
2211     if (jit_regset_tstbit(&_jitc->function->regset, _S4))
2212         ldxi(20, _SP_REGNO, 40);
2213     if (jit_regset_tstbit(&_jitc->function->regset, _S5))
2214         ldxi(21, _SP_REGNO, 48);
2215     if (jit_regset_tstbit(&_jitc->function->regset, _S6))
2216         ldxi(22, _SP_REGNO, 56);
2217     if (jit_regset_tstbit(&_jitc->function->regset, _S7))
2218         ldxi(23, _SP_REGNO, 64);
2219     if (jit_regset_tstbit(&_jitc->function->regset, _S8))
2220         ldxi(24, _SP_REGNO, 72);
2221     if (jit_regset_tstbit(&_jitc->function->regset, _S9))
2222         ldxi(25, _SP_REGNO, 80);
2223     if (jit_regset_tstbit(&_jitc->function->regset, _S10))
2224         ldxi(26, _SP_REGNO, 88);
2225     if (jit_regset_tstbit(&_jitc->function->regset, _S11))
2226         ldxi(27, _SP_REGNO, 96);
2227     if (jit_regset_tstbit(&_jitc->function->regset, _FS0))
2228         ldxi_d(8, _SP_REGNO, 104);
2229     if (jit_regset_tstbit(&_jitc->function->regset, _FS1))
2230         ldxi_d(9, _SP_REGNO, 112);
2231     if (jit_regset_tstbit(&_jitc->function->regset, _FS2))
2232         ldxi_d(18, _SP_REGNO, 120);
2233     if (jit_regset_tstbit(&_jitc->function->regset, _FS3))
2234         ldxi_d(19, _SP_REGNO, 128);
2235     if (jit_regset_tstbit(&_jitc->function->regset, _FS4))
2236         ldxi_d(20, _SP_REGNO, 136);
2237     if (jit_regset_tstbit(&_jitc->function->regset, _FS5))
2238         ldxi_d(21, _SP_REGNO, 144);
2239     if (jit_regset_tstbit(&_jitc->function->regset, _FS6))
2240         ldxi_d(22, _SP_REGNO, 152);
2241     if (jit_regset_tstbit(&_jitc->function->regset, _FS7))
2242         ldxi_d(23, _SP_REGNO, 160);
2243     if (jit_regset_tstbit(&_jitc->function->regset, _FS8))
2244         ldxi_d(24, _SP_REGNO, 168);
2245     if (jit_regset_tstbit(&_jitc->function->regset, _FS9))
2246         ldxi_d(25, _SP_REGNO, 176);
2247     if (jit_regset_tstbit(&_jitc->function->regset, _FS10))
2248         ldxi_d(26, _SP_REGNO, 184);
2249     if (jit_regset_tstbit(&_jitc->function->regset, _FS11))
2250         ldxi_d(27, _SP_REGNO, 192);
2251     addi(_SP_REGNO, _SP_REGNO, stack_framesize);
2252     RET();
2253 }
2254
2255 static void
2256 _vastart(jit_state_t *_jit, jit_int32_t r0)
2257 {
2258     assert(_jitc->function->self.call & jit_call_varargs);
2259     /* Initialize va_list to the first stack argument. */
2260     if (jit_arg_reg_p(_jitc->function->vagp))
2261         addi(r0, _FP_REGNO, stack_framesize - ((8 - _jitc->function->vagp) * 8));
2262     else
2263         addi(r0, _FP_REGNO, _jitc->function->self.size);
2264 }
2265
2266 static void
2267 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2268 {
2269     assert(_jitc->function->self.call & jit_call_varargs);
2270     /* Load argument. */
2271     ldr(r0, r1);
2272     /* Update va_list. */
2273     addi(r1, r1, sizeof(jit_word_t));
2274 }
2275
2276 static void
2277 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2278 {
2279     instr_t              i;
2280     union {
2281         jit_int32_t     *i;
2282         jit_word_t       w;
2283     } u;
2284     u.w = instr;
2285     i.w = u.i[0];
2286     /* movi_p? */
2287     if (i.U.opcode == 55) {                                     /* LUI */
2288         jit_int32_t     ww = label << 32 >> 32;
2289         jit_int32_t     lo = ww << 20 >> 20;
2290         jit_int32_t     hi = ww - lo;
2291         i.U.imm12_31 = hi >> 12;
2292         u.i[0] = i.w;
2293         i.w = u.i[1];
2294         if (i.I.opcode == 27 && i.I.funct3 == 0) {              /* ADDIW */
2295             i.I.imm11_0 = lo & 0xfff;
2296             u.i[1] = i.w;
2297             i.w = u.i[2];
2298             if (i.U.opcode == 55) {                             /* LUI */
2299                 ww = label >> 32;
2300                 lo = ww << 20 >> 20;
2301                 hi = ww - lo;
2302                 i.U.imm12_31 = hi >> 12;
2303                 u.i[2] = i.w;
2304                 i.w = u.i[3];
2305                 if (i.I.opcode == 27 && i.I.funct3 == 0) {      /* ADDIW */
2306                     i.I.imm11_0 = lo & 0xfff;
2307                     u.i[3] = i.w;
2308                     i.w = u.i[4];
2309                     assert(i.IS.opcode == 19);                  /* SLLI */
2310                     assert(i.IS.shamt == 32);
2311                     i.w = u.i[5];
2312                     assert(i.R.opcode == 51);                   /* ADD */
2313                 }
2314                 else
2315                     abort();
2316             }
2317             else
2318                 abort();
2319         }
2320         else
2321             abort();
2322     }
2323     /* b{lt,le,eq,ge,gt,ne}{,_u}? */
2324     else if (i.B.opcode == 99) {                /* B{EQ,NE,LT,GE,LTU,GEU} */
2325         jit_word_t jmp = label - instr;
2326         assert(simm12_p(jmp));
2327         i.B.imm11       = (jmp >> 11) & 0x1;
2328         i.B.imm4_1      = (jmp >> 1) & 0xf;
2329         i.B.imm10_5     = (jmp >> 5) & 0x3f;
2330         i.B.imm12       = (jmp >> 12) & 0x1;
2331         u.i[0] = i.w;
2332     }
2333     else if (i.J.opcode == 111) {               /* JAL */
2334         jit_word_t jmp = label - instr;
2335         i.J.imm19_12    = (jmp >> 12) &  0xff;
2336         i.J.imm11       = (jmp >> 11) &   0x1;
2337         i.J.imm10_1     = (jmp >>  1) & 0x3ff;
2338         i.J.imm20       = (jmp >> 20) &   0x1;
2339         u.i[0] = i.w;
2340     }
2341     else
2342         abort();
2343 }
2344 #endif          /* CODE */