deps/lightning/lib/jit_riscv-cpu.c

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