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