notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
spu: irq adjustments according to MiSTer
[pcsx_rearmed.git] / deps / lightning / lib / jit_riscv-cpu.c
CommitLineData
4a71579b 1/*
c0c16242 2 * Copyright (C) 2019-2022 Free Software Foundation, Inc.
4a71579b
PC		 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
25typedef 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)
248static 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)
252static 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)
256static 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)
261static 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)
266static 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)
270static 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)
273static 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)
275static 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)
280static 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)
283static 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)
285static 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)
287static 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)
289static 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)
291static 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)
294static 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)
296static 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)
298static 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)
300static 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)
302static 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)
304static 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)
307static 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)
310static 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)
313static 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)
316static 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)
319static 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)
321static 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)
323static 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)
325static 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)
327static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
328static 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)
332static 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)
335static 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)
338static 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)
342static 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)
345static 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)
348static 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)
353static 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)
356static 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)
359static 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)
362static 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)
365static 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)
368static 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)
371static 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)
374static 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)
377static 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)
380static 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)
382static 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)
384static 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)
386static 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)
388static 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)
390static 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)
392static 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)
394static 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)
396static 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)
398static 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)
400static 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)
402static 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)
404static 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)
406static 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)
408static 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)
411static 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)
414static 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)
417static 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)
420static 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)
422static 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)
424static 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)
426static 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)
428static 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)
430static 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)
432static 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)
434static 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)
436static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
40a44dcb
PC		 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)
4a71579b
PC		 440# define extr_c(r0, r1) _extr_c(_jit, r0, r1)
441static 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)
444static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
445# define extr_us(r0, r1) _extr_us(_jit, r0, r1)
446static 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)
449static 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)
452static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
453# define movi_p(r0, im) _movi_p(_jit, r0, im)
454static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
40a44dcb
PC		 455# define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
456static 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)
458static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
c0c16242 459# define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
ba3814c1
PC		 460static 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)
4a71579b
PC		 464# define ltr(r0, r1, r2) SLT(r0, r1, r2)
465# define lti(r0, r1, im) _lti(_jit, r0, r1, im)
466static 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)
469static 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)
471static 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)
473static 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)
475static 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)
477static 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)
479static 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)
481static 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)
483static 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)
485static 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)
487static 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)
489static 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)
492static 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)
495static 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)
497static 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)
499static 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)
501static 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)
503static 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)
505static 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)
507static 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)
509static 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)
511static 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)
513static 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)
515static 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)
517static 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)
519static 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)
521static 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)
523static 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)
525static 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)
527static 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)
529static 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)
531static 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)
533static 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)
535static 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)
537static 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)
539static 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)
542static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
543static 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)
546static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
547static 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)
550static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
551static 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)
554static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
555static 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)
558static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
559static 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)
562static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
563static 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)
566static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
567static 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)
570static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
571static 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)
574static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
575static 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)
578static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
579static 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)
582static void _jmpi(jit_state_t*,jit_word_t);
583# define jmpi_p(im) _jmpi_p(_jit, im)
584static 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)
587static void _calli(jit_state_t*,jit_word_t);
588# define calli_p(im) _calli_p(_jit, im)
589static jit_word_t _calli_p(jit_state_t*,jit_word_t);
590# define prolog(i0) _prolog(_jit,i0)
591static void _prolog(jit_state_t*,jit_node_t*);
592# define epilog(i0) _epilog(_jit,i0)
593static void _epilog(jit_state_t*,jit_node_t*);
594# define vastart(r0) _vastart(_jit, r0)
595static void _vastart(jit_state_t*, jit_int32_t);
596# define vaarg(r0, r1) _vaarg(_jit, r0, r1)
597static 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)
600static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
601#endif /* PROTO */
602
603#if CODE
604static 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
624static 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
646static 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
665static 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
686static 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
705static 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
726static 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
739static 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
755static 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
763static 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
777static 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
796static 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
815static 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
827static 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
839static 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
853static 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
872static 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
891static 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
903static 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
915static 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
922static 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
932static 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
942static 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
952static 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
962static 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
972static 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
990static 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
1001static 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
1019static 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
1030static 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
1064static 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
1075static 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
1086static 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
1097static 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
1108static 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
1119static 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
1133static 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
1147static 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) \
1162static 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 \
1176static 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 \
1186static 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
1200DEFLD(c,B)
1201DEFLD(uc,BU)
1202DEFLD(s,H)
1203DEFLD(us,HU)
1204DEFLD(i,W)
1205DEFLD(ui,WU)
1206DEFLD(l,D)
1207
1208# define DEFST(T, O) \
1209static 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 \
1223static 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 \
1233static 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
1247DEFST(c, B)
1248DEFST(s, H)
1249DEFST(i, W)
1250DEFST(l, D)
1251
4a71579b
PC		 1252static 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
1259static 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
1266static 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
1273static 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
1280static void
1281_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1282{
c0c16242 1283# if __WORDSIZE == 64
4a71579b 1284 if (simm32_p(i0)) {
c0c16242 1285# endif
4a71579b
PC		 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);
c0c16242 1295# if __WORDSIZE == 64
4a71579b 1296 }
c0c16242
PC		 1297 else
1298 load_const(r0, i0);
1299# endif
4a71579b
PC		 1300}
1301
1302static jit_word_t
1303_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1304{
1305 jit_word_t w;
4a71579b 1306 w = _jit->pc.w;
c0c16242
PC		 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
4a71579b
PC		 1315 return (w);
1316}
1317
40a44dcb
PC		 1318static 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);
c0c16242 1323 movr(r0, r1);
40a44dcb
PC		 1324 patch_at(w, _jit->pc.w);
1325}
1326
1327static 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);
c0c16242 1332 movr(r0, r1);
40a44dcb
PC		 1333 patch_at(w, _jit->pc.w);
1334}
1335
ba3814c1
PC		 1336static 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{
c0c16242
PC		 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);
ba3814c1
PC		 1370}
1371
4a71579b
PC		 1372static 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
1386static 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
1400static 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
1407static 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
1423static 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
1430static 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
1446static 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
1454static 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
1466static 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
1473static 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
1483static 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
1490static 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
1500static 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
1510static 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
1520static 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
1527static 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
1538static 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
1547static 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
1559static 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
1568static 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
1580static 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
1589static 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
1601static 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
1610static 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
1622static 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
1631static 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
1643static 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
1652static 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
1664static 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
1673static 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
1685static 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
1694static 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
1706static 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
1715static 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
1727static 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
1736static 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
1748static 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
1780static 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
1792static 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
1809static 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
1821static 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
1853static 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
1865static 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
1882static 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
1894static 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
1926static 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
1938static 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
1955static 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
1967static 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
1999static 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
2011static 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
2028static 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
2040static 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
2053static 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
2065static 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
2078static 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
2090static 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
2106static 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
2118static 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
2134static 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
2146static 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
2227static 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
2285static 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
2296static 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
2306static 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? */
c0c16242
PC		 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
4a71579b 2340 if (i.U.opcode == 55) { /* LUI */
c0c16242
PC		 2341 jit_int32_t lo = (jit_int32_t)label << 20 >> 20;
2342 jit_int32_t hi = label - lo;
4a71579b
PC		 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 */
c0c16242 2347 i.I.imm11_0 = lo;
4a71579b
PC		 2348 u.i[1] = i.w;
2349 i.w = u.i[2];
4a71579b
PC		 2350 }
2351 else
2352 abort();
2353 }
c0c16242 2354# endif
4a71579b
PC		 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 */
ARM optimized PCSX fork