2 * Copyright (C) 2019-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
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)
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.
17 * Paulo Cesar Pereira de Andrade
21 #define jit_unaligned_p() (jit_cpu.unaligned)
27 # define ui jit_uint32_t
96 # define ii(i) *_jit->pc.ui++ = i
97 # define ldr(r0, r1) ldr_l(r0, r1)
98 # define ldi(r0, im) ldi_l(r0, im)
99 # define ldxr(r0, r1, r2) ldxr_l(r0, r1, r2)
100 # define ldxi(r0, r1, im) ldxi_l(r0, r1, im)
101 # define str(r0, r1) str_l(r0, r1)
102 # define sti(im, r0) sti_l(im, r0)
103 # define stxr(r0, r1, r2) stxr_l(r0, r1, r2)
104 # define stxi(im, r0, r1) stxi_l(im, r0, r1)
105 # define simm6_p(im) ((im) <= 31 && (im) >= -32)
106 # define simm12_p(im) ((im) <= 2047 && (im) >= -2048)
107 # define simm20_p(im) ((im) <= 524287 && (im) >= -524288)
108 # define simm32_p(im) ((im) <= 2147483647LL && (im) >= -2147483648LL)
111 * RV32I Base Instruction Set
113 # define LUI(rd, imm) Utype(55, rd, imm)
114 # define AUIPC(rd, imm) Utype(23, rd, imm)
115 # define JAL(rd, imm) Jtype(111, rd, imm)
116 # define JALR(rd, rs1, imm) Itype(103, rd, 0, rs1, imm)
117 # define BEQ(rs1, rs2, imm) Btype(99, 0, rs1, rs2, imm)
118 # define BNE(rs1, rs2, imm) Btype(99, 1, rs1, rs2, imm)
119 # define BLT(rs1, rs2, imm) Btype(99, 4, rs1, rs2, imm)
120 # define BGE(rs1, rs2, imm) Btype(99, 5, rs1, rs2, imm)
121 # define BLTU(rs1, rs2, imm) Btype(99, 6, rs1, rs2, imm)
122 # define BGEU(rs1, rs2, imm) Btype(99, 7, rs1, rs2, imm)
123 # define LB(rd, rs1, imm) Itype(3, rd, 0, rs1, imm)
124 # define LH(rd, rs1, imm) Itype(3, rd, 1, rs1, imm)
125 # define LW(rd, rs1, imm) Itype(3, rd, 2, rs1, imm)
126 # define LBU(rd, rs1, imm) Itype(3, rd, 4, rs1, imm)
127 # define LHU(rd, rs1, imm) Itype(3, rd, 5, rs1, imm)
128 # define SB(rs1, rs2, imm) Stype(35, 0, rs1, rs2, imm)
129 # define SH(rs1, rs2, imm) Stype(35, 1, rs1, rs2, imm)
130 # define SW(rs1, rs2, imm) Stype(35, 2, rs1, rs2, imm)
131 # define ADDI(rd, rs1, imm) Itype(19, rd, 0, rs1, imm)
132 # define SLTI(rd, rs1, imm) Itype(19, rd, 2, rs1, imm)
133 # define SLTIU(rd, rs1, imm) Itype(19, rd, 3, rs1, imm)
134 # define XORI(rd, rs1, imm) Itype(19, rd, 4, rs1, imm)
135 # define ORI(rd, rs1, imm) Itype(19, rd, 6, rs1, imm)
136 # define ANDI(rd, rs1, imm) Itype(19, rd, 7, rs1, imm)
137 # if __WORDSIZE == 32
138 # define SLLI(rd, rs1, imm) Rtype(19, rd, 1, rs1, imm, 0)
139 # define SRLI(rd, rs1, imm) Rtype(19, rd, 5, rs1, imm, 0)
140 # define SRAI(rd, rs1, imm) Rtype(19, rd, 5, rs1, imm, 32)
142 # define ADD(rd, rs1, rs2) Rtype(51, rd, 0, rs1, rs2, 0)
143 # define SUB(rd, rs1, rs2) Rtype(51, rd, 0, rs1, rs2, 32)
144 # define SLL(rd, rs1, rs2) Rtype(51, rd, 1, rs1, rs2, 0)
145 # define SLT(rd, rs1, rs2) Rtype(51, rd, 2, rs1, rs2, 0)
146 # define SLTU(rd, rs1, rs2) Rtype(51, rd, 3, rs1, rs2, 0)
147 # define XOR(rd, rs1, rs2) Rtype(51, rd, 4, rs1, rs2, 0)
148 # define SRL(rd, rs1, rs2) Rtype(51, rd, 5, rs1, rs2, 0)
149 # define SRA(rd, rs1, rs2) Rtype(51, rd, 5, rs1, rs2, 32)
150 # define OR(rd, rs1, rs2) Rtype(51, rd, 6, rs1, rs2, 0)
151 # define AND(rd, rs1, rs2) Rtype(51, rd, 7, rs1, rs2, 0)
152 # define FENCE(imm) Itype(15, 0, 0, 0, im)
153 # define FENCE_I(imm) Itype(15, 0, 1, 0, im)
154 # define ECALL() Itype(115, 0, 0, 0, 0)
155 # define EBREAK() Itype(115, 0, 0, 0, 1)
156 # define CSRRW(rd, rs1, csr) Itype(115, rd, 1, rs1, csr)
157 # define CSRRS(rd, rs1, csr) Itype(115, rd, 2, rs1, csr)
158 # define CSRRC(rd, rs1, csr) Itype(115, rd, 3, rs1, csr)
159 # define CSRRWI(rd, zimm, csr) Itype(115, rd, 5, zimm, csr)
160 # define CSRRSI(rd, zimm, csr) Itype(115, rd, 6, zimm, csr)
161 # define CSRRCI(rd, zimm, csr) Itype(115, rd, 7, zimm, csr)
163 * RV64I Base Instruction Set (in addition to RV32I)
165 # define LWU(rd, rs1, imm) Itype(3, rd, 6, rs1, imm)
166 # define LD(rd, rs1, imm) Itype(3, rd, 3, rs1, imm)
167 # define SD(rs1, rs2, imm) Stype(35, 3, rs1, rs2, imm)
168 # if __WORDSIZE == 64
169 # define SLLI(rd, rs1, sh) IStype(19, rd, 1, rs1, sh, 0)
170 # define SRLI(rd, rs1, sh) IStype(19, rd, 5, rs1, sh, 0)
171 # define SRAI(rd, rs1, sh) IStype(19, rd, 5, rs1, sh, 16)
173 # define ADDIW(rd, rs1, imm) Itype(27, rd, 0, rs1, imm)
174 # define SLLIW(rd, rs1, imm) Rtype(27, rd, 1, rs1, imm, 0)
175 # define SRLIW(rd, rs1, imm) Rtype(27, rd, 3, rs1, imm, 0)
176 # define SRAIW(rd, rs1, imm) Rtype(27, rd, 3, rs1, imm, 32)
177 # define ADDW(rd, rs1, imm) Rtype(59, rd, 0, rs1, imm, 0)
178 # define SUBW(rd, rs1, imm) Rtype(59, rd, 0, rs1, imm, 32)
179 # define SLLW(rd, rs1, imm) Rtype(59, rd, 1, rs1, imm, 0)
180 # define SRLW(rd, rs1, imm) Rtype(59, rd, 5, rs1, imm, 0)
181 # define SRAW(rd, rs1, imm) Rtype(59, rd, 5, rs1, imm, 32)
183 * RV32M Standard Extension
185 # define MUL(rd, rs1, rs2) Rtype(51, rd, 0, rs1, rs2, 1)
186 # define MULH(rd, rs1, rs2) Rtype(51, rd, 1, rs1, rs2, 1)
187 # define MULHSU(rd, rs1, rs2) Rtype(51, rd, 2, rs1, rs2, 1)
188 # define MULHU(rd, rs1, rs2) Rtype(51, rd, 3, rs1, rs2, 1)
189 # define DIV(rd, rs1, rs2) Rtype(51, rd, 4, rs1, rs2, 1)
190 # define DIVU(rd, rs1, rs2) Rtype(51, rd, 5, rs1, rs2, 1)
191 # define REM(rd, rs1, rs2) Rtype(51, rd, 6, rs1, rs2, 1)
192 # define REMU(rd, rs1, rs2) Rtype(51, rd, 7, rs1, rs2, 1)
194 * RV64M Standard Extension (in addition to RV32M)
196 # define MULW(rd, rs1, rs2) Rtype(59, rd, 0, rs1, rs2, 1)
197 # define DIVW(rd, rs1, rs2) Rtype(59, rd, 4, rs1, rs2, 1)
198 # define DIVUW(rd, rs1, rs2) Rtype(59, rd, 5, rs1, rs2, 1)
199 # define REMW(rd, rs1, rs2) Rtype(59, rd, 6, rs1, rs2, 1)
200 # define REMUW(rd, rs1, rs2) Rtype(59, rd, 7, rs1, rs2, 1)
202 * RV32A Standard Extension
204 # define LR_W(rd, rs1) R4type(47, rd, 2, rs1, 0, 0, 2)
205 # define SC_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 3)
206 # define AMOSWAP_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 1)
207 # define AMOADD_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 0)
208 # define AMOXOR_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 4)
209 # define AMOAND_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 12)
210 # define AMOOR_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 8)
211 # define AMOMIN_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 16)
212 # define AMOMAX_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 20)
213 # define AMOMINU_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 24)
214 # define AMOMAXU_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 28)
216 * RV64A Standard Extension (in addition to RV32A)
218 # define LR_D(rd, rs1) R4type(47, rd, 3, rs1, 0, 0, 2)
219 # define SC_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 3)
220 # define AMOSWAP_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 1)
221 # define AMOADD_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 0)
222 # define AMOXOR_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 4)
223 # define AMOAND_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 12)
224 # define AMOOR_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 8)
225 # define AMOMIN_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 16)
226 # define AMOMAX_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 20)
227 # define AMOMINU_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 24)
228 # define AMOMAXU_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 28)
230 * Pseudo Instructions
232 # define NOP() ADDI(_ZERO_REGNO, _ZERO_REGNO, 0)
233 # define MV(r0, r1) ADDI(r0, r1, 0)
234 # define NOT(r0, r1) XORI(r0, r1, -1)
235 # define NEG(r0, r1) SUB(r0, _ZERO_REGNO, r1)
236 # define NEGW(r0, r1) SUBW(r0, _ZERO_REGNO, r1)
237 # define SEXT_W(r0, r1) ADDIW(r0, r1, 0)
238 # define RET() JALR(0, 1, 0)
241 * Enconding functions
243 # define Rtype(op, rd, fct, rs1, rs2, fct2) \
244 _Rtype(_jit, op, rd, fct, rs1, rs2, fct2)
245 static void _Rtype(jit_state_t*, jit_int32_t, jit_int32_t,
246 jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
247 # define R4type(op, rd, fct, rs1,rs2,fct2,rs3) \
248 _R4type(_jit, op, rd, fct, rs1, rs2, fct2, rs3)
249 static void _R4type(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t,
250 jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
251 # define Itype(op, rd, fct, rs1, imm) \
252 _Itype(_jit, op, rd, fct, rs1, imm)
253 static void _Itype(jit_state_t*, jit_int32_t, jit_int32_t,
254 jit_int32_t, jit_int32_t, jit_int32_t);
255 # if __WORDSIZE == 64
256 # define IStype(op, rd, fct, rs1, sh, imm) \
257 _IStype(_jit, op, rd, fct, rs1, sh, imm)
258 static void _IStype(jit_state_t*, jit_int32_t, jit_int32_t,
259 jit_int32_t, jit_int32_t, jit_int32_t,jit_int32_t);
261 # define Stype(op, fct, rs1, rs2, imm) \
262 _Stype(_jit, op, fct, rs1, rs2, imm)
263 static void _Stype(jit_state_t*, jit_int32_t, jit_int32_t,
264 jit_int32_t, jit_int32_t, jit_int32_t);
265 # define Btype(op, fct, rs1, rs2, imm) \
266 _Btype(_jit, op, fct, rs1, rs2, imm)
267 static void _Btype(jit_state_t*, jit_int32_t, jit_int32_t,
268 jit_int32_t, jit_int32_t, jit_int32_t);
269 # define Utype(op, rd, imm) _Utype(_jit, op, rd, imm)
270 static void _Utype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
271 # define Jtype(op, rd, imm) _Jtype(_jit, op, rd, imm)
272 static void _Jtype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
274 * Lightning instructions
276 # define nop(im) _nop(_jit, im)
277 static void _nop(jit_state_t*, jit_int32_t);
278 # define addr(r0, r1, r2) ADD(r0, r1, r2)
279 # define addi(r0, r1, im) _addi(_jit, r0, r1, im)
280 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
281 # define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2)
282 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
283 # define addci(r0, r1, im) _addci(_jit, r0, r1, im)
284 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
285 # define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2)
286 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
287 # define addxi(r0, r1, im) _addxi(_jit, r0, r1, im)
288 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
289 # define subr(r0, r1, r2) SUB(r0, r1, r2)
290 # define subi(r0, r1, im) _subi(_jit, r0, r1, im)
291 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
292 # define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2)
293 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
294 # define subci(r0, r1, im) _subci(_jit, r0, r1, im)
295 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
296 # define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2)
297 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
298 # define subxi(r0, r1, im) _subxi(_jit, r0, r1, im)
299 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
300 # define rsbi(r0, r1, im) _rsbi(_jit, r0, r1, im)
301 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
302 # define mulr(r0, r1, r2) MUL(r0, r1, r2)
303 # define muli(r0, r1, im) _muli(_jit, r0, r1, im)
304 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
305 # define hmulr(r0, r1, r2) MULH(r0, r1, r2)
306 # define hmuli(r0, r1, im) _hmuli(_jit, r0, r1, im)
307 static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
308 # define hmulr_u(r0, r1, r2) MULHU(r0, r1, r2)
309 # define hmuli_u(r0, r1, im) _hmuli_u(_jit, r0, r1, im)
310 static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
311 # define divr(r0, r1, r2) DIV(r0, r1, r2)
312 # define divi(r0, r1, im) _divi(_jit, r0, r1, im)
313 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
314 # define divr_u(r0, r1, r2) DIVU(r0, r1, r2)
315 # define divi_u(r0, r1, im) _divi_u(_jit, r0, r1, im)
316 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
317 # define remr(r0, r1, r2) REM(r0, r1, r2)
318 # define remi(r0, r1, im) _remi(_jit, r0, r1, im)
319 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
320 # define remr_u(r0, r1, r2) REMU(r0, r1, r2)
321 # define remi_u(r0, r1, im) _remi_u(_jit, r0, r1, im)
322 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
323 # define qmulr(r0, r1, r2, r3) _qmulr(_jit,r0,r1,r2,r3)
324 static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
325 # define qmuli(r0, r1, r2, i0) _qmuli(_jit,r0,r1,r2,i0)
326 static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
327 # define qmulr_u(r0, r1, r2, r3) _qmulr_u(_jit,r0,r1,r2,r3)
328 static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
329 # define qmuli_u(r0, r1, r2, i0) _qmuli_u(_jit,r0,r1,r2,i0)
330 static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
331 static void _iqdivr(jit_state_t*,jit_bool_t,
332 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
333 # define qdivr(r0,r1,r2,r3) _iqdivr(_jit,1,r0,r1,r2,r3)
334 # define qdivr_u(r0,r1,r2,r3) _iqdivr(_jit,0,r0,r1,r2,r3)
335 static void _iqdivr(jit_state_t*,jit_bool_t,
336 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
337 # define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
338 static void _qdivi(jit_state_t*,jit_int32_t,
339 jit_int32_t,jit_int32_t,jit_word_t);
340 # define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
341 static void _qdivi_u(jit_state_t*,jit_int32_t,
342 jit_int32_t,jit_int32_t,jit_word_t);
343 # define lshr(r0, r1, r2) SLL(r0, r1, r2)
344 # define lshi(r0, r1, im) _lshi(_jit, r0, r1, im)
345 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
346 # define rshr(r0, r1, r2) SRA(r0, r1, r2)
347 # define rshi(r0, r1, im) _rshi(_jit, r0, r1, im)
348 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
349 # define rshr_u(r0, r1, r2) SRL(r0, r1, r2)
350 # define rshi_u(r0, r1, im) _rshi_u(_jit, r0, r1, im)
351 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
352 # define negr(r0, r1) NEG(r0, r1)
353 # define comr(r0, r1) NOT(r0, r1)
354 # define andr(r0, r1, r2) AND(r0, r1, r2)
355 # define andi(r0, r1, im) _andi(_jit, r0, r1, im)
356 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
357 # define orr(r0, r1, r2) OR(r0, r1, r2)
358 # define ori(r0, r1, im) _ori(_jit, r0, r1, im)
359 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
360 # define xorr(r0, r1, r2) XOR(r0, r1, r2)
361 # define xori(r0, r1, im) _xori(_jit, r0, r1, im)
362 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
363 # define ldr_c(r0, r1) LB(r0, r1, 0)
364 # define ldi_c(r0, im) _ldi_c(_jit, r0, im)
365 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
366 # define ldr_uc(r0, r1) LBU(r0, r1, 0)
367 # define ldi_uc(r0, im) _ldi_uc(_jit, r0, im)
368 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
369 # define ldr_s(r0, r1) LH(r0, r1, 0)
370 # define ldi_s(r0, im) _ldi_s(_jit, r0, im)
371 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
372 # define ldr_us(r0, r1) LHU(r0, r1, 0)
373 # define ldi_us(r0, im) _ldi_us(_jit, r0, im)
374 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
375 # define ldr_i(r0, r1) LW(r0, r1, 0)
376 # define ldi_i(r0, im) _ldi_i(_jit, r0, im)
377 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
378 # define ldr_ui(r0, r1) LWU(r0, r1, 0)
379 # define ldi_ui(r0, im) _ldi_ui(_jit, r0, im)
380 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
381 # define ldr_l(r0, r1) LD(r0, r1, 0)
382 # define ldi_l(r0, im) _ldi_l(_jit, r0, im)
383 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
384 # define ldxr_c(r0, r1, r2) _ldxr_c(_jit, r0, r1, r2)
385 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
386 # define ldxi_c(r0, r1, im) _ldxi_c(_jit, r0, r1, im)
387 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
388 # define ldxr_uc(r0, r1, r2) _ldxr_uc(_jit, r0, r1, r2)
389 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
390 # define ldxi_uc(r0, r1, im) _ldxi_uc(_jit, r0, r1, im)
391 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
392 # define ldxr_s(r0, r1, r2) _ldxr_s(_jit, r0, r1, r2)
393 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
394 # define ldxi_s(r0, r1, im) _ldxi_s(_jit, r0, r1, im)
395 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
396 # define ldxr_us(r0, r1, r2) _ldxr_us(_jit, r0, r1, r2)
397 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
398 # define ldxi_us(r0, r1, im) _ldxi_us(_jit, r0, r1, im)
399 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
400 # define ldxr_i(r0, r1, r2) _ldxr_i(_jit, r0, r1, r2)
401 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
402 # define ldxi_i(r0, r1, im) _ldxi_i(_jit, r0, r1, im)
403 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
404 # define ldxr_ui(r0, r1, r2) _ldxr_ui(_jit, r0, r1, r2)
405 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
406 # define ldxi_ui(r0, r1, im) _ldxi_ui(_jit, r0, r1, im)
407 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
408 # define ldxr_l(r0, r1, r2) _ldxr_l(_jit, r0, r1, r2)
409 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
410 # define ldxi_l(r0, r1, im) _ldxi_l(_jit, r0, r1, im)
411 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
412 # define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0)
413 static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
414 # define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1)
415 static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
416 # define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0)
417 static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
418 # define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1)
419 static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
420 # define str_c(r0, r1) SB(r0, r1, 0)
421 # define sti_c(im, r0) _sti_c(_jit, im, r0)
422 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
423 # define str_s(r0, r1) SH(r0, r1, 0)
424 # define sti_s(im, r0) _sti_s(_jit, im, r0)
425 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
426 # define str_i(r0, r1) SW(r0, r1, 0)
427 # define sti_i(im, r0) _sti_i(_jit, im, r0)
428 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
429 # define str_l(r0, r1) SD(r0, r1, 0)
430 # define sti_l(im, r0) _sti_l(_jit, im, r0)
431 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
432 # define stxr_c(r0, r1, r2) _stxr_c(_jit, r0, r1, r2)
433 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
434 # define stxi_c(i0, r0, r1) _stxi_c(_jit, i0, r0, r1)
435 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
436 # define stxr_s(r0, r1, r2) _stxr_s(_jit, r0, r1, r2)
437 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
438 # define stxi_s(i0, r0, r1) _stxi_s(_jit, i0, r0, r1)
439 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
440 # define stxr_i(r0, r1, r2) _stxr_i(_jit, r0, r1, r2)
441 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
442 # define stxi_i(i0, r0, r1) _stxi_i(_jit, i0, r0, r1)
443 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
444 # define stxr_l(r0, r1, r2) _stxr_l(_jit, r0, r1, r2)
445 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
446 # define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1)
447 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
448 #define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0)
449 static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
450 #define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1)
451 static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
452 # define bswapr_us(r0, r1) generic_bswapr_us(_jit, r0, r1)
453 # define bswapr_ui(r0, r1) generic_bswapr_ui(_jit, r0, r1)
454 # define bswapr_ul(r0, r1) generic_bswapr_ul(_jit, r0, r1)
455 # define extr_c(r0, r1) _extr_c(_jit, r0, r1)
456 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
457 # define extr_uc(r0, r1) andi(r0, r1, 0xff)
458 # define extr_s(r0, r1) _extr_s(_jit, r0, r1)
459 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
460 # define extr_us(r0, r1) _extr_us(_jit, r0, r1)
461 static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
462 # define extr_i(r0, r1) SEXT_W(r0, r1)
463 # define extr_ui(r0, r1) _extr_ui(_jit, r0, r1)
464 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
465 # define movr(r0, r1) MV(r0, r1)
466 # define movi(r0, im) _movi(_jit, r0, im)
467 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
468 # define movi_p(r0, im) _movi_p(_jit, r0, im)
469 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
470 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
471 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
472 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
473 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
474 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
475 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
476 jit_int32_t,jit_int32_t,jit_word_t);
477 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
478 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
479 # define ltr(r0, r1, r2) SLT(r0, r1, r2)
480 # define lti(r0, r1, im) _lti(_jit, r0, r1, im)
481 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
482 # define ltr_u(r0, r1, r2) SLTU(r0, r1, r2)
483 # define lti_u(r0, r1, im) _lti_u(_jit, r0, r1, im)
484 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
485 # define ler(r0, r1, r2) _ler(_jit, r0, r1, r2)
486 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
487 # define lei(r0, r1, im) _lei(_jit, r0, r1, im)
488 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
489 # define ler_u(r0, r1, r2) _ler_u(_jit, r0, r1, r2)
490 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
491 # define lei_u(r0, r1, im) _lei_u(_jit, r0, r1, im)
492 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
493 # define eqr(r0, r1, r2) _eqr(_jit, r0, r1, r2)
494 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
495 # define eqi(r0, r1, im) _eqi(_jit, r0, r1, im)
496 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
497 # define ger(r0, r1, r2) _ger(_jit, r0, r1, r2)
498 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
499 # define gei(r0, r1, r2) _gei(_jit, r0, r1, r2)
500 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
501 # define ger_u(r0, r1, r2) _ger_u(_jit, r0, r1, r2)
502 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
503 # define gei_u(r0, r1, im) _gei_u(_jit, r0, r1, im)
504 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
505 # define gtr(r0, r1, r2) SLT(r0, r2, r1)
506 # define gti(r0, r1, im) _gti(_jit, r0, r1, im)
507 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
508 # define gtr_u(r0, r1, r2) SLTU(r0, r2, r1)
509 # define gti_u(r0, r1, im) _gti_u(_jit, r0, r1, im)
510 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
511 # define ner(r0, r1, r2) _ner(_jit, r0, r1, r2)
512 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
513 # define nei(r0, r1, im) _nei(_jit, r0, r1, im)
514 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
515 # define bltr(br, r0, r1) _bltr(_jit, br, r0, r1)
516 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
517 # define blti(br, r0, im) _blti(_jit, br, r0, im)
518 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
519 # define bltr_u(br, r0, r1) _bltr_u(_jit, br, r0, r1)
520 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
521 # define blti_u(br, r0, im) _blti_u(_jit, br, r0, im)
522 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
523 # define bler(br, r0, r1) _bler(_jit, br, r0, r1)
524 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
525 # define blei(br, r0, im) _blei(_jit, br, r0, im)
526 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
527 # define bler_u(br, r0, r1) _bler_u(_jit, br, r0, r1)
528 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
529 # define blei_u(br, r0, im) _blei_u(_jit, br, r0, im)
530 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
531 # define beqr(br, r0, r1) _beqr(_jit, br, r0, r1)
532 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
533 # define beqi(br, r0, im) _beqi(_jit, br, r0, im)
534 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
535 # define bger(br, r0, r1) _bger(_jit, br, r0, r1)
536 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
537 # define bgei(br, r0, im) _bgei(_jit, br, r0, im)
538 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
539 # define bger_u(br, r0, r1) _bger_u(_jit, br, r0, r1)
540 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
541 # define bgei_u(br, r0, im) _bgei_u(_jit, br, r0, im)
542 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
543 # define bgtr(br, r0, r1) _bgtr(_jit, br, r0, r1)
544 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
545 # define bgti(br, r0, im) _bgti(_jit, br, r0, im)
546 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
547 # define bgtr_u(br, r0, r1) _bgtr_u(_jit, br, r0, r1)
548 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
549 # define bgti_u(br, r0, im) _bgti_u(_jit, br, r0, im)
550 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
551 # define bner(br, r0, r1) _bner(_jit, br, r0, r1)
552 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
553 # define bnei(br, r0, im) _bnei(_jit, br, r0, im)
554 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
555 # define boaddr(br, r0, r1) _boaddr(_jit, br, r0, r1)
556 # define boaddi(br, r0, im) _boaddi(_jit, br, r0, im)
557 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
558 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
559 # define boaddr_u(br, r0, r1) _boaddr_u(_jit, br, r0, r1)
560 # define boaddi_u(br, r0, im) _boaddi_u(_jit, br, r0, im)
561 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
562 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
563 # define bxaddr(br, r0, r1) _bxaddr(_jit, br, r0, r1)
564 # define bxaddi(br, r0, im) _bxaddi(_jit, br, r0, im)
565 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
566 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
567 # define bxaddr_u(br, r0, r1) _bxaddr_u(_jit, br, r0, r1)
568 # define bxaddi_u(br, r0, im) _bxaddi_u(_jit, br, r0, im)
569 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
570 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
571 # define bosubr(br, r0, r1) _bosubr(_jit, br, r0, r1)
572 # define bosubi(br, r0, im) _bosubi(_jit, br, r0, im)
573 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
574 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
575 # define bosubr_u(br, r0, r1) _bosubr_u(_jit, br, r0, r1)
576 # define bosubi_u(br, r0, im) _bosubi_u(_jit, br, r0, im)
577 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
578 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
579 # define bxsubr(br, r0, r1) _bxsubr(_jit, br, r0, r1)
580 # define bxsubi(br, r0, im) _bxsubi(_jit, br, r0, im)
581 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
582 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
583 # define bxsubr_u(br, r0, r1) _bxsubr_u(_jit, br, r0, r1)
584 # define bxsubi_u(br, r0, im) _bxsubi_u(_jit, br, r0, im)
585 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
586 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
587 # define bmsr(br, r0, r1) _bmsr(_jit, br, r0, r1)
588 # define bmsi(br, r0, im) _bmsi(_jit, br, r0, im)
589 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
590 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
591 # define bmcr(br, r0, r1) _bmcr(_jit, br, r0, r1)
592 # define bmci(br, r0, im) _bmci(_jit, br, r0, im)
593 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
594 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
595 # define jmpr(r0) JALR(_ZERO_REGNO, r0, 0)
596 # define jmpi(im) _jmpi(_jit, im)
597 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
598 # define jmpi_p(im) _jmpi_p(_jit, im)
599 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
600 # define callr(r0) JALR(_RA_REGNO, r0, 0)
601 # define calli(im) _calli(_jit, im)
602 static jit_word_t _calli(jit_state_t*,jit_word_t);
603 # define calli_p(im) _calli_p(_jit, im)
604 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
605 # define prolog(i0) _prolog(_jit,i0)
606 static void _prolog(jit_state_t*,jit_node_t*);
607 # define epilog(i0) _epilog(_jit,i0)
608 static void _epilog(jit_state_t*,jit_node_t*);
609 # define vastart(r0) _vastart(_jit, r0)
610 static void _vastart(jit_state_t*, jit_int32_t);
611 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
612 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
613 #define patch_abs(instr,label) _patch_at(_jit,instr,label)
614 #define patch_at(instr,label) _patch_at(_jit,instr,label)
615 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
620 _Rtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
621 jit_int32_t fct, jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2)
624 assert(!(op & ~0x7f));
625 assert(!(rd & ~0x1f));
626 assert(!(fct & ~0x07));
627 assert(!(rs1 & ~0x1f));
628 assert(!(rs2 & ~0x1f));
629 assert(!(fct2 & ~0x7f));
640 _R4type(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t fct,
641 jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2, jit_int32_t rs3)
644 assert(!(op & ~0x7f));
645 assert(!(rd & ~0x1f));
646 assert(!(fct & ~0x07));
647 assert(!(rs1 & ~0x1f));
648 assert(!(rs2 & ~0x1f));
649 assert(!(fct2 & ~0x03));
650 assert(!(rs3 & ~0x1f));
662 _Itype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
663 jit_int32_t fct, jit_int32_t rs1, jit_int32_t imm)
666 assert(!(op & ~0x7f));
667 assert(!(rd & ~0x1f));
668 assert(!(fct & ~0x07));
669 assert(!(rs1 & ~0x1f));
670 assert(simm12_p(imm));
679 # if __WORDSIZE == 64
681 _IStype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
682 jit_int32_t fct, jit_int32_t rs1, jit_int32_t sh, jit_int32_t imm)
685 assert(!(op & ~0x7f));
686 assert(!(rd & ~0x1f));
687 assert(!(fct & ~0x07));
688 assert(!(rs1 & ~0x1f));
689 assert(!(sh & ~0x3f));
690 assert(simm6_p(imm));
702 _Stype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
703 jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
706 assert(!(op & ~0x7f));
707 assert(!(fct & ~0x07));
708 assert(!(rs1 & ~0x1f));
709 assert(!(rs2 & ~0x1f));
710 assert(simm12_p(imm));
712 i.S.imm4_0 = imm & 0x1f;
716 i.S.imm11_5 = (imm >> 5) & 0x7f;
721 _Btype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
722 jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
725 assert(!(op & ~0x7f));
726 assert(!(fct & ~0x07));
727 assert(!(rs1 & ~0x1f));
728 assert(!(rs2 & ~0x1f));
729 assert(!(imm & 1) && simm12_p(imm));
731 i.B.imm11 = (imm >> 11) & 0x1;
732 i.B.imm4_1 = (imm >> 1) & 0xf;
736 i.B.imm10_5 = (imm >> 5) & 0x3f;
737 i.B.imm12 = (imm >> 12) & 0x1;
742 _Utype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
745 assert(!(op & ~0x7f));
746 assert(!(rd & ~0x1f));
747 assert(simm20_p(imm));
755 _Jtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
758 assert(!(op & ~0x7f));
759 assert(!(rd & ~0x1f));
760 assert(!(imm & 1) && imm <= 1048575 && imm >= -1048576);
763 i.J.imm19_12= (imm >> 12) & 0xff;
764 i.J.imm11 = (imm >> 11) & 0x1;
765 i.J.imm10_1 = (imm >> 1) & 0x3ff;
766 i.J.imm20 = (imm >> 20) & 0x1;
771 _nop(jit_state_t *_jit, jit_int32_t im)
773 for (; im > 0; im -= 4)
779 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
785 t0 = jit_get_reg(jit_class_gpr);
787 addr(r0, r1, rn(t0));
793 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
796 if (jit_carry == _NOREG)
797 jit_carry = jit_get_reg(jit_class_gpr);
799 t0 = jit_get_reg(jit_class_gpr);
800 addr(rn(t0), r1, r2);
801 SLTU(rn(jit_carry), rn(t0), r1);
807 SLTU(rn(jit_carry), r0, r1);
812 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
815 if (jit_carry == _NOREG)
816 jit_carry = jit_get_reg(jit_class_gpr);
818 t0 = jit_get_reg(jit_class_gpr);
819 addi(rn(t0), r1, i0);
820 SLTU(rn(jit_carry), rn(t0), r1);
826 SLTU(rn(jit_carry), r0, r1);
831 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
834 assert(jit_carry != _NOREG);
835 t0 = jit_get_reg(jit_class_gpr);
836 movr(rn(t0), rn(jit_carry));
838 addcr(r0, r0, rn(t0));
843 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
846 assert(jit_carry != _NOREG);
847 t0 = jit_get_reg(jit_class_gpr);
848 movr(rn(t0), rn(jit_carry));
850 addcr(r0, r0, rn(t0));
855 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
861 t0 = jit_get_reg(jit_class_gpr);
863 subr(r0, r1, rn(t0));
869 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
872 if (jit_carry == _NOREG)
873 jit_carry = jit_get_reg(jit_class_gpr);
875 t0 = jit_get_reg(jit_class_gpr);
876 subr(rn(t0), r1, r2);
877 SLTU(rn(jit_carry), r1, rn(t0));
883 SLTU(rn(jit_carry), r1, r0);
888 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
891 if (jit_carry == _NOREG)
892 jit_carry = jit_get_reg(jit_class_gpr);
894 t0 = jit_get_reg(jit_class_gpr);
895 subi(rn(t0), r1, i0);
896 SLTU(rn(jit_carry), r1, rn(t0));
902 SLTU(rn(jit_carry), r1, r0);
907 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
910 assert(jit_carry != _NOREG);
911 t0 = jit_get_reg(jit_class_gpr);
912 movr(rn(t0), rn(jit_carry));
914 subcr(r0, r0, rn(t0));
919 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
922 assert(jit_carry != _NOREG);
923 t0 = jit_get_reg(jit_class_gpr);
924 movr(rn(t0), rn(jit_carry));
926 subcr(r0, r0, rn(t0));
931 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
938 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
941 t0 = jit_get_reg(jit_class_gpr);
943 mulr(r0, r1, rn(t0));
948 _hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
951 t0 = jit_get_reg(jit_class_gpr);
953 hmulr(r0, r1, rn(t0));
958 _hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
961 t0 = jit_get_reg(jit_class_gpr);
963 hmulr_u(r0, r1, rn(t0));
968 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
971 t0 = jit_get_reg(jit_class_gpr);
973 divr(r0, r1, rn(t0));
978 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
981 t0 = jit_get_reg(jit_class_gpr);
983 divr_u(r0, r1, rn(t0));
988 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
991 t0 = jit_get_reg(jit_class_gpr);
993 remr(r0, r1, rn(t0));
998 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1001 t0 = jit_get_reg(jit_class_gpr);
1003 remr_u(r0, r1, rn(t0));
1008 _qmulr(jit_state_t *_jit, jit_int32_t r0,
1009 jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1012 if (r0 == r2 || r0 == r3) {
1013 t0 = jit_get_reg(jit_class_gpr);
1014 mulr(rn(t0), r2, r3);
1019 if (r0 == r2 || r0 == r3) {
1026 _qmuli(jit_state_t *_jit, jit_int32_t r0,
1027 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1030 t0 = jit_get_reg(jit_class_gpr);
1032 qmulr(r0, r1, r2, rn(t0));
1037 _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
1038 jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1041 if (r0 == r2 || r0 == r3) {
1042 t0 = jit_get_reg(jit_class_gpr);
1043 mulr(rn(t0), r2, r3);
1048 if (r0 == r2 || r0 == r3) {
1055 _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
1056 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1059 t0 = jit_get_reg(jit_class_gpr);
1061 qmulr_u(r0, r1, r2, rn(t0));
1066 _iqdivr(jit_state_t *_jit, jit_bool_t sign,
1067 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1069 jit_int32_t sv0, rg0;
1070 jit_int32_t sv1, rg1;
1071 if (r0 == r2 || r0 == r3) {
1072 sv0 = jit_get_reg(jit_class_gpr);
1077 if (r1 == r2 || r1 == r3) {
1078 sv1 = jit_get_reg(jit_class_gpr);
1086 divr_u(rg0, r2, r3);
1100 _qdivi(jit_state_t *_jit, jit_int32_t r0,
1101 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1104 t0 = jit_get_reg(jit_class_gpr);
1106 qdivr(r0, r1, r2, rn(t0));
1111 _qdivi_u(jit_state_t *_jit, jit_int32_t r0,
1112 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1115 t0 = jit_get_reg(jit_class_gpr);
1117 qdivr_u(r0, r1, r2, rn(t0));
1122 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1127 assert(i0 > 0 && i0 < 64);
1133 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1138 assert(i0 > 0 && i0 < 64);
1144 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1149 assert(i0 > 0 && i0 < 64);
1155 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1161 t0 = jit_get_reg(jit_class_gpr);
1163 andr(r0, r1, rn(t0));
1169 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1175 t0 = jit_get_reg(jit_class_gpr);
1177 orr(r0, r1, rn(t0));
1183 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1189 t0 = jit_get_reg(jit_class_gpr);
1191 xorr(r0, r1, rn(t0));
1196 # define DEFLD(T,O) \
1198 _ldi_##T(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) \
1201 L##O(r0, _ZERO_REGNO, i0); \
1204 t0 = jit_get_reg(jit_class_gpr); \
1206 ldr_##T(r0, rn(t0)); \
1207 jit_unget_reg(t0); \
1212 _ldxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1215 t0 = jit_get_reg(jit_class_gpr); \
1216 addr(rn(t0), r1, r2); \
1217 ldr_##T(r0, rn(t0)); \
1218 jit_unget_reg(t0); \
1222 _ldxi_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)\
1228 t0 = jit_get_reg(jit_class_gpr); \
1229 addi(rn(t0), r1, i0); \
1230 ldr_##T(r0, rn(t0)); \
1231 jit_unget_reg(t0); \
1244 _unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1246 if (jit_unaligned_p())
1247 fallback_unldr(r0, r1, i0);
1249 generic_unldr(r0, r1, i0);
1253 _unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
1256 if (jit_unaligned_p())
1257 fallback_unldi(r0, i0, i1);
1259 generic_unldi(r0, i0, i1);
1263 _unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1265 if (jit_unaligned_p())
1266 fallback_unldr_u(r0, r1, i0);
1268 generic_unldr_u(r0, r1, i0);
1272 _unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
1275 if (jit_unaligned_p())
1276 fallback_unldi_u(r0, i0, i1);
1278 generic_unldi_u(r0, i0, i1);
1281 # define DEFST(T, O) \
1283 _sti_##T(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) \
1286 S##O(_ZERO_REGNO, r0, i0); \
1289 t0 = jit_get_reg(jit_class_gpr); \
1291 str_##T(rn(t0), r0); \
1292 jit_unget_reg(t0); \
1297 _stxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1300 t0 = jit_get_reg(jit_class_gpr); \
1301 addr(rn(t0), r0, r1); \
1302 str_##T(rn(t0), r2); \
1303 jit_unget_reg(t0); \
1307 _stxi_##T(jit_state_t *_jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)\
1313 t0 = jit_get_reg(jit_class_gpr); \
1314 addi(rn(t0), r0, i0); \
1315 str_##T(rn(t0), r1); \
1316 jit_unget_reg(t0); \
1326 _unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1328 if (jit_unaligned_p())
1329 fallback_unstr(r0, r1, i0);
1331 generic_unstr(r0, r1, i0);
1335 _unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1337 if (jit_unaligned_p())
1338 fallback_unsti(i0, r0, i1);
1340 generic_unsti(i0, r0, i1);
1344 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1351 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1358 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1365 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1372 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1374 # if __WORDSIZE == 64
1377 jit_int32_t lo = (jit_int32_t)i0 << 20 >> 20;
1378 jit_int32_t hi = i0 - lo;
1385 ADDIW(r0, _ZERO_REGNO, lo);
1386 # if __WORDSIZE == 64
1394 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1398 # if __WORDSIZE == 64
1410 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1413 w = beqi(_jit->pc.w, r2, 0);
1415 patch_at(w, _jit->pc.w);
1419 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1422 w = bnei(_jit->pc.w, r2, 0);
1424 patch_at(w, _jit->pc.w);
1428 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1429 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1431 jit_int32_t t0, r1_reg, iscasi;
1432 jit_word_t retry, done, jump0, jump1;
1433 if ((iscasi = (r1 == _NOREG))) {
1434 r1_reg = jit_get_reg(jit_class_gpr);
1438 t0 = jit_get_reg(jit_class_gpr);
1440 # if __WORDSIZE == 32
1447 # if __WORDSIZE == 32
1448 SC_W(rn(t0), r1, r3);
1450 SC_D(rn(t0), r1, r3);
1453 BNE(rn(t0), _ZERO_REGNO, 0);
1456 patch_at(jump0, done);
1457 patch_at(jump1, retry);
1460 jit_unget_reg(r1_reg);
1464 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1470 t0 = jit_get_reg(jit_class_gpr);
1472 ltr(r0, r1, rn(t0));
1478 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1484 t0 = jit_get_reg(jit_class_gpr);
1486 ltr_u(r0, r1, rn(t0));
1492 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1499 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1503 SLT(r0, _ZERO_REGNO, r1);
1507 t0 = jit_get_reg(jit_class_gpr);
1509 ler(r0, r1, rn(t0));
1515 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1522 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1526 SLTU(r0, _ZERO_REGNO, r1);
1530 t0 = jit_get_reg(jit_class_gpr);
1532 ler_u(r0, r1, rn(t0));
1538 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1541 SLTU(r0, _ZERO_REGNO, r0);
1546 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1550 SLTU(r0, _ZERO_REGNO, r0);
1553 SLTU(r0, _ZERO_REGNO, r1);
1558 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1565 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1568 t0 = jit_get_reg(jit_class_gpr);
1570 ger(r0, r1, rn(t0));
1575 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1582 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1585 t0 = jit_get_reg(jit_class_gpr);
1587 ger_u(r0, r1, rn(t0));
1592 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1595 t0 = jit_get_reg(jit_class_gpr);
1597 ltr(r0, rn(t0), r1);
1602 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1605 t0 = jit_get_reg(jit_class_gpr);
1607 ltr_u(r0, rn(t0), r1);
1612 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1615 SLTU(r0, _ZERO_REGNO, r0);
1619 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1623 SLTU(r0, _ZERO_REGNO, r0);
1626 SLTU(r0, _ZERO_REGNO, r1);
1630 _bltr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1634 BLT(r0, r1, br - w);
1639 _blti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1643 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1645 w = bltr(br, r0, rn(t0));
1651 _bltr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1655 BLTU(r0, r1, br - w);
1660 _blti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1664 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1666 w = bltr_u(br, r0, rn(t0));
1672 _bler(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1676 BGE(r1, r0, br - w);
1681 _blei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1685 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1687 w = bler(br, r0, rn(t0));
1693 _bler_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1697 BGEU(r1, r0, br - w);
1702 _blei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1706 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1708 w = bler_u(br, r0, rn(t0));
1714 _beqr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1718 BEQ(r1, r0, br - w);
1723 _beqi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1727 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1729 w = beqr(br, r0, rn(t0));
1735 _bger(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1739 BGE(r0, r1, br - w);
1744 _bgei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1748 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1750 w = bger(br, r0, rn(t0));
1756 _bger_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1760 BGEU(r0, r1, br - w);
1765 _bgei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1769 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1771 w = bger_u(br, r0, rn(t0));
1777 _bgtr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1781 BLT(r1, r0, br - w);
1786 _bgti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1790 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1792 w = bgtr(br, r0, rn(t0));
1798 _bgtr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1802 BLTU(r1, r0, br - w);
1807 _bgti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1811 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1813 w = bgtr_u(br, r0, rn(t0));
1819 _bner(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1823 BNE(r1, r0, br - w);
1828 _bnei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1832 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1834 w = bner(br, r0, rn(t0));
1840 _boaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1844 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1845 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1847 SLT(rn(t0), r1, _ZERO_REGNO);
1852 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1854 BNE(rn(t0), _ZERO_REGNO, 0);
1856 SLT(rn(t1), r0, rn(t1));
1858 JAL(_ZERO_REGNO, 0);
1860 patch_at(w, _jit->pc.w);
1861 SLT(rn(t1), rn(t1), r0);
1863 patch_at(jal, _jit->pc.w);
1865 BNE(rn(t1), _ZERO_REGNO, br - w);
1872 _boaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1876 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1878 w = boaddr(br, r0, rn(t0));
1884 _boaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1888 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1889 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1890 addr(rn(t0), r0, r1);
1891 SLTU(rn(t1), rn(t0), r0);
1894 BNE(_ZERO_REGNO, rn(t1), br - w);
1901 _boaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1905 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1907 w = boaddr_u(br, r0, rn(t0));
1913 _bxaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1917 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1918 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1920 SLT(rn(t0), r1, _ZERO_REGNO);
1925 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1927 BNE(rn(t0), _ZERO_REGNO, 0);
1929 SLT(rn(t1), r0, rn(t1));
1931 JAL(_ZERO_REGNO, 0);
1933 patch_at(w, _jit->pc.w);
1934 SLT(rn(t1), rn(t1), r0);
1936 patch_at(jal, _jit->pc.w);
1938 BEQ(rn(t1), _ZERO_REGNO, br - w);
1945 _bxaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1949 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1951 w = bxaddr(br, r0, rn(t0));
1957 _bxaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1961 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1962 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1963 addr(rn(t0), r0, r1);
1964 SLTU(rn(t1), rn(t0), r0);
1967 BEQ(_ZERO_REGNO, rn(t1), br - w);
1974 _bxaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1978 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1980 w = bxaddr_u(br, r0, rn(t0));
1986 _bosubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1990 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1991 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1993 SLT(rn(t0), _ZERO_REGNO, r1);
1998 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
2000 BNE(rn(t0), _ZERO_REGNO, 0);
2002 SLT(rn(t1), r0, rn(t1));
2004 JAL(_ZERO_REGNO, 0);
2006 patch_at(w, _jit->pc.w);
2007 SLT(rn(t1), rn(t1), r0);
2009 patch_at(jal, _jit->pc.w);
2011 BNE(rn(t1), _ZERO_REGNO, br - w);
2018 _bosubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2022 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2024 w = bosubr(br, r0, rn(t0));
2030 _bosubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2034 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2035 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2036 subr(rn(t0), r0, r1);
2037 SLTU(rn(t1), r0, rn(t0));
2040 BNE(_ZERO_REGNO, rn(t1), br - w);
2047 _bosubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2051 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2053 w = bosubr_u(br, r0, rn(t0));
2059 _bxsubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2063 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2064 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2066 SLT(rn(t0), _ZERO_REGNO, r1);
2071 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
2073 BNE(rn(t0), _ZERO_REGNO, 0);
2075 SLT(rn(t1), r0, rn(t1));
2077 JAL(_ZERO_REGNO, 0);
2079 patch_at(w, _jit->pc.w);
2080 SLT(rn(t1), rn(t1), r0);
2082 patch_at(jal, _jit->pc.w);
2084 BEQ(rn(t1), _ZERO_REGNO, br - w);
2091 _bxsubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2095 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2097 w = bxsubr(br, r0, rn(t0));
2103 _bxsubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2107 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2108 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2109 subr(rn(t0), r0, r1);
2110 SLTU(rn(t1), r0, rn(t0));
2113 BEQ(_ZERO_REGNO, rn(t1), br - w);
2120 _bxsubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2124 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2126 w = bxsubr_u(br, r0, rn(t0));
2132 _bmsr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2136 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2137 AND(rn(t0), r0, r1);
2139 BNE(_ZERO_REGNO, rn(t0), br - w);
2145 _bmsi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2149 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2151 w = bmsr(br, r0, rn(t0));
2157 _bmcr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2161 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2162 AND(rn(t0), r0, r1);
2164 BEQ(_ZERO_REGNO, rn(t0), br - w);
2170 _bmci(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2174 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2176 w = bmcr(br, r0, rn(t0));
2182 _jmpi(jit_state_t *_jit, jit_word_t i0)
2189 JAL(_ZERO_REGNO, dsp);
2191 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2200 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2204 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2205 w = movi_p(rn(t0), i0);
2212 _calli(jit_state_t *_jit, jit_word_t i0)
2219 JAL(_RA_REGNO, dsp);
2221 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2230 _calli_p(jit_state_t *_jit, jit_word_t i0)
2234 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2235 w = movi_p(rn(t0), i0);
2242 _prolog(jit_state_t *_jit, jit_node_t *node)
2244 jit_int32_t reg, offs;
2245 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2246 jit_int32_t frame = -_jitc->function->frame;
2248 assert(_jitc->function->self.aoff >= frame);
2249 if (_jitc->function->assume_frame)
2251 _jitc->function->self.aoff = frame;
2253 if (_jitc->function->allocar)
2254 _jitc->function->self.aoff &= -16;
2255 _jitc->function->stack = ((_jitc->function->self.alen -
2256 /* align stack at 16 bytes */
2257 _jitc->function->self.aoff) + 15) & -16;
2259 if (_jitc->function->stack)
2260 _jitc->function->need_stack = 1;
2261 if (!_jitc->function->need_frame && !_jitc->function->need_stack) {
2262 /* check if any callee save register needs to be saved */
2263 for (reg = 0; reg < _jitc->reglen; ++reg)
2264 if (jit_regset_tstbit(&_jitc->function->regset, reg) &&
2265 (_rvs[reg].spec & jit_class_sav)) {
2266 _jitc->function->need_stack = 1;
2271 if (_jitc->function->need_frame || _jitc->function->need_stack)
2272 subi(_SP_REGNO, _SP_REGNO, jit_framesize());
2273 if (_jitc->function->need_frame) {
2274 stxi(0, _SP_REGNO, _RA_REGNO);
2275 stxi(8, _SP_REGNO, _FP_REGNO);
2277 /* callee save registers */
2278 for (reg = 0, offs = 16; reg < jit_size(iregs); reg++) {
2279 if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
2280 stxi(offs, _SP_REGNO, rn(iregs[reg]));
2281 offs += sizeof(jit_word_t);
2284 for (reg = 0; reg < jit_size(fregs); reg++) {
2285 if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
2286 stxi_d(offs, _SP_REGNO, rn(fregs[reg]));
2287 offs += sizeof(jit_float64_t);
2291 if (_jitc->function->need_frame)
2292 movr(_FP_REGNO, _SP_REGNO);
2293 if (_jitc->function->stack)
2294 subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
2295 if (_jitc->function->allocar) {
2296 reg = jit_get_reg(jit_class_gpr);
2297 movi(rn(reg), _jitc->function->self.aoff);
2298 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2301 if (_jitc->function->self.call & jit_call_varargs) {
2302 for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2303 stxi(jit_framesize() - ((8 - reg) * 8),
2304 _FP_REGNO, rn(JIT_RA0 - reg));
2309 _epilog(jit_state_t *_jit, jit_node_t *node)
2311 jit_int32_t reg, offs;
2312 if (_jitc->function->assume_frame)
2314 if (_jitc->function->need_frame) {
2315 movr(_SP_REGNO, _FP_REGNO);
2316 ldxi(_RA_REGNO, _SP_REGNO, 0);
2317 ldxi(_FP_REGNO, _SP_REGNO, 8);
2320 /* callee save registers */
2321 for (reg = 0, offs = 16; reg < jit_size(iregs); reg++) {
2322 if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
2323 ldxi(rn(iregs[reg]), _SP_REGNO, offs);
2324 offs += sizeof(jit_word_t);
2327 for (reg = 0; reg < jit_size(fregs); reg++) {
2328 if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
2329 ldxi_d(rn(fregs[reg]), _SP_REGNO, offs);
2330 offs += sizeof(jit_float64_t);
2334 if (_jitc->function->need_frame || _jitc->function->need_stack)
2335 addi(_SP_REGNO, _SP_REGNO, jit_framesize());
2340 _vastart(jit_state_t *_jit, jit_int32_t r0)
2342 assert(_jitc->function->self.call & jit_call_varargs);
2343 /* Initialize va_list to the first stack argument. */
2344 if (jit_arg_reg_p(_jitc->function->vagp))
2345 addi(r0, _FP_REGNO, jit_framesize() - ((8 - _jitc->function->vagp) * 8));
2347 addi(r0, _FP_REGNO, jit_selfsize());
2351 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2353 assert(_jitc->function->self.call & jit_call_varargs);
2354 /* Load argument. */
2356 /* Update va_list. */
2357 addi(r1, r1, sizeof(jit_word_t));
2361 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2371 # if __WORDSIZE == 64
2372 if (i.U.opcode == 23) { /* AUIPC */
2374 jit_word_t address, relative;
2375 address = get_const(label);
2376 relative = address - instr;
2377 assert(simm32_p(relative));
2378 lo = (jit_int32_t)relative << 20 >> 20;
2380 i.U.imm12_31 = hi >> 12;
2383 if (i.I.opcode == 19 && i.I.funct3 == 0) { /* ADDI */
2390 assert(i.I.opcode == 3 && i.I.funct3 == 3); /* LD */
2393 if (i.U.opcode == 55) { /* LUI */
2394 jit_int32_t lo = (jit_int32_t)label << 20 >> 20;
2395 jit_int32_t hi = label - lo;
2396 i.U.imm12_31 = hi >> 12;
2399 if (i.I.opcode == 27 && i.I.funct3 == 0) { /* ADDIW */
2408 /* b{lt,le,eq,ge,gt,ne}{,_u}? */
2409 else if (i.B.opcode == 99) { /* B{EQ,NE,LT,GE,LTU,GEU} */
2410 jit_word_t jmp = label - instr;
2411 assert(simm12_p(jmp));
2412 i.B.imm11 = (jmp >> 11) & 0x1;
2413 i.B.imm4_1 = (jmp >> 1) & 0xf;
2414 i.B.imm10_5 = (jmp >> 5) & 0x3f;
2415 i.B.imm12 = (jmp >> 12) & 0x1;
2418 else if (i.J.opcode == 111) { /* JAL */
2419 jit_word_t jmp = label - instr;
2420 i.J.imm19_12 = (jmp >> 12) & 0xff;
2421 i.J.imm11 = (jmp >> 11) & 0x1;
2422 i.J.imm10_1 = (jmp >> 1) & 0x3ff;
2423 i.J.imm20 = (jmp >> 20) & 0x1;