2 * Copyright (C) 2019-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
17 * Paulo Cesar Pereira de Andrade
26 # define ui jit_uint32_t
95 # define ii(i) *_jit->pc.ui++ = i
96 # define ldr(r0, r1) ldr_l(r0, r1)
97 # define ldi(r0, im) ldi_l(r0, im)
98 # define ldxr(r0, r1, r2) ldxr_l(r0, r1, r2)
99 # define ldxi(r0, r1, im) ldxi_l(r0, r1, im)
100 # define str(r0, r1) str_l(r0, r1)
101 # define sti(im, r0) sti_l(im, r0)
102 # define stxr(r0, r1, r2) stxr_l(r0, r1, r2)
103 # define stxi(im, r0, r1) stxi_l(im, r0, r1)
104 # define simm6_p(im) ((im) <= 31 && (im) >= -32)
105 # define simm12_p(im) ((im) <= 2047 && (im) >= -2048)
106 # define simm20_p(im) ((im) <= 524287 && (im) >= -524288)
107 # define simm32_p(im) ((im) <= 2147483647LL && (im) >= -2147483648LL)
110 * RV32I Base Instruction Set
112 # define LUI(rd, imm) Utype(55, rd, imm)
113 # define AUIPC(rd, imm) Utype(23, rd, imm)
114 # define JAL(rd, imm) Jtype(111, rd, imm)
115 # define JALR(rd, rs1, imm) Itype(103, rd, 0, rs1, imm)
116 # define BEQ(rs1, rs2, imm) Btype(99, 0, rs1, rs2, imm)
117 # define BNE(rs1, rs2, imm) Btype(99, 1, rs1, rs2, imm)
118 # define BLT(rs1, rs2, imm) Btype(99, 4, rs1, rs2, imm)
119 # define BGE(rs1, rs2, imm) Btype(99, 5, rs1, rs2, imm)
120 # define BLTU(rs1, rs2, imm) Btype(99, 6, rs1, rs2, imm)
121 # define BGEU(rs1, rs2, imm) Btype(99, 7, rs1, rs2, imm)
122 # define LB(rd, rs1, imm) Itype(3, rd, 0, rs1, imm)
123 # define LH(rd, rs1, imm) Itype(3, rd, 1, rs1, imm)
124 # define LW(rd, rs1, imm) Itype(3, rd, 2, rs1, imm)
125 # define LBU(rd, rs1, imm) Itype(3, rd, 4, rs1, imm)
126 # define LHU(rd, rs1, imm) Itype(3, rd, 5, rs1, imm)
127 # define SB(rs1, rs2, imm) Stype(35, 0, rs1, rs2, imm)
128 # define SH(rs1, rs2, imm) Stype(35, 1, rs1, rs2, imm)
129 # define SW(rs1, rs2, imm) Stype(35, 2, rs1, rs2, imm)
130 # define ADDI(rd, rs1, imm) Itype(19, rd, 0, rs1, imm)
131 # define SLTI(rd, rs1, imm) Itype(19, rd, 2, rs1, imm)
132 # define SLTIU(rd, rs1, imm) Itype(19, rd, 3, rs1, imm)
133 # define XORI(rd, rs1, imm) Itype(19, rd, 4, rs1, imm)
134 # define ORI(rd, rs1, imm) Itype(19, rd, 6, rs1, imm)
135 # define ANDI(rd, rs1, imm) Itype(19, rd, 7, rs1, imm)
136 # if __WORDSIZE == 32
137 # define SLLI(rd, rs1, imm) Rtype(19, rd, 1, rs1, imm, 0)
138 # define SRLI(rd, rs1, imm) Rtype(19, rd, 5, rs1, imm, 0)
139 # define SRAI(rd, rs1, imm) Rtype(19, rd, 5, rs1, imm, 32)
141 # define ADD(rd, rs1, rs2) Rtype(51, rd, 0, rs1, rs2, 0)
142 # define SUB(rd, rs1, rs2) Rtype(51, rd, 0, rs1, rs2, 32)
143 # define SLL(rd, rs1, rs2) Rtype(51, rd, 1, rs1, rs2, 0)
144 # define SLT(rd, rs1, rs2) Rtype(51, rd, 2, rs1, rs2, 0)
145 # define SLTU(rd, rs1, rs2) Rtype(51, rd, 3, rs1, rs2, 0)
146 # define XOR(rd, rs1, rs2) Rtype(51, rd, 4, rs1, rs2, 0)
147 # define SRL(rd, rs1, rs2) Rtype(51, rd, 5, rs1, rs2, 0)
148 # define SRA(rd, rs1, rs2) Rtype(51, rd, 5, rs1, rs2, 32)
149 # define OR(rd, rs1, rs2) Rtype(51, rd, 6, rs1, rs2, 0)
150 # define AND(rd, rs1, rs2) Rtype(51, rd, 7, rs1, rs2, 0)
151 # define FENCE(imm) Itype(15, 0, 0, 0, im)
152 # define FENCE_I(imm) Itype(15, 0, 1, 0, im)
153 # define ECALL() Itype(115, 0, 0, 0, 0)
154 # define EBREAK() Itype(115, 0, 0, 0, 1)
155 # define CSRRW(rd, rs1, csr) Itype(115, rd, 1, rs1, csr)
156 # define CSRRS(rd, rs1, csr) Itype(115, rd, 2, rs1, csr)
157 # define CSRRC(rd, rs1, csr) Itype(115, rd, 3, rs1, csr)
158 # define CSRRWI(rd, zimm, csr) Itype(115, rd, 5, zimm, csr)
159 # define CSRRSI(rd, zimm, csr) Itype(115, rd, 6, zimm, csr)
160 # define CSRRCI(rd, zimm, csr) Itype(115, rd, 7, zimm, csr)
162 * RV64I Base Instruction Set (in addition to RV32I)
164 # define LWU(rd, rs1, imm) Itype(3, rd, 6, rs1, imm)
165 # define LD(rd, rs1, imm) Itype(3, rd, 3, rs1, imm)
166 # define SD(rs1, rs2, imm) Stype(35, 3, rs1, rs2, imm)
167 # if __WORDSIZE == 64
168 # define SLLI(rd, rs1, sh) IStype(19, rd, 1, rs1, sh, 0)
169 # define SRLI(rd, rs1, sh) IStype(19, rd, 5, rs1, sh, 0)
170 # define SRAI(rd, rs1, sh) IStype(19, rd, 5, rs1, sh, 16)
172 # define ADDIW(rd, rs1, imm) Itype(27, rd, 0, rs1, imm)
173 # define SLLIW(rd, rs1, imm) Rtype(27, rd, 1, rs1, imm, 0)
174 # define SRLIW(rd, rs1, imm) Rtype(27, rd, 3, rs1, imm, 0)
175 # define SRAIW(rd, rs1, imm) Rtype(27, rd, 3, rs1, imm, 32)
176 # define ADDW(rd, rs1, imm) Rtype(59, rd, 0, rs1, imm, 0)
177 # define SUBW(rd, rs1, imm) Rtype(59, rd, 0, rs1, imm, 32)
178 # define SLLW(rd, rs1, imm) Rtype(59, rd, 1, rs1, imm, 0)
179 # define SRLW(rd, rs1, imm) Rtype(59, rd, 5, rs1, imm, 0)
180 # define SRAW(rd, rs1, imm) Rtype(59, rd, 5, rs1, imm, 32)
182 * RV32M Standard Extension
184 # define MUL(rd, rs1, rs2) Rtype(51, rd, 0, rs1, rs2, 1)
185 # define MULH(rd, rs1, rs2) Rtype(51, rd, 1, rs1, rs2, 1)
186 # define MULHSU(rd, rs1, rs2) Rtype(51, rd, 2, rs1, rs2, 1)
187 # define MULHU(rd, rs1, rs2) Rtype(51, rd, 3, rs1, rs2, 1)
188 # define DIV(rd, rs1, rs2) Rtype(51, rd, 4, rs1, rs2, 1)
189 # define DIVU(rd, rs1, rs2) Rtype(51, rd, 5, rs1, rs2, 1)
190 # define REM(rd, rs1, rs2) Rtype(51, rd, 6, rs1, rs2, 1)
191 # define REMU(rd, rs1, rs2) Rtype(51, rd, 7, rs1, rs2, 1)
193 * RV64M Standard Extension (in addition to RV32M)
195 # define MULW(rd, rs1, rs2) Rtype(59, rd, 0, rs1, rs2, 1)
196 # define DIVW(rd, rs1, rs2) Rtype(59, rd, 4, rs1, rs2, 1)
197 # define DIVUW(rd, rs1, rs2) Rtype(59, rd, 5, rs1, rs2, 1)
198 # define REMW(rd, rs1, rs2) Rtype(59, rd, 6, rs1, rs2, 1)
199 # define REMUW(rd, rs1, rs2) Rtype(59, rd, 7, rs1, rs2, 1)
201 * RV32A Standard Extension
203 # define LR_W(rd, rs1) R4type(47, rd, 2, rs1, 0, 0, 2)
204 # define SC_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 3)
205 # define AMOSWAP_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 1)
206 # define AMOADD_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 0)
207 # define AMOXOR_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 4)
208 # define AMOAND_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 12)
209 # define AMOOR_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 8)
210 # define AMOMIN_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 16)
211 # define AMOMAX_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 20)
212 # define AMOMINU_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 24)
213 # define AMOMAXU_W(rd, rs1, rs2) R4type(47, rd, 2, rs1, rs2, 0, 28)
215 * RV64A Standard Extension (in addition to RV32A)
217 # define LR_D(rd, rs1) R4type(47, rd, 3, rs1, 0, 0, 2)
218 # define SC_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 3)
219 # define AMOSWAP_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 1)
220 # define AMOADD_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 0)
221 # define AMOXOR_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 4)
222 # define AMOAND_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 12)
223 # define AMOOR_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 8)
224 # define AMOMIN_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 16)
225 # define AMOMAX_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 20)
226 # define AMOMINU_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 24)
227 # define AMOMAXU_D(rd, rs1, rs2) R4type(47, rd, 3, rs1, rs2, 0, 28)
229 * Pseudo Instructions
231 # define NOP() ADDI(_ZERO_REGNO, _ZERO_REGNO, 0)
232 # define MV(r0, r1) ADDI(r0, r1, 0)
233 # define NOT(r0, r1) XORI(r0, r1, -1)
234 # define NEG(r0, r1) SUB(r0, _ZERO_REGNO, r1)
235 # define NEGW(r0, r1) SUBW(r0, _ZERO_REGNO, r1)
236 # define SEXT_W(r0, r1) ADDIW(r0, r1, 0)
237 # define RET() JALR(0, 1, 0)
240 * Enconding functions
242 # define Rtype(op, rd, fct, rs1, rs2, fct2) \
243 _Rtype(_jit, op, rd, fct, rs1, rs2, fct2)
244 static void _Rtype(jit_state_t*, jit_int32_t, jit_int32_t,
245 jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
246 # define R4type(op, rd, fct, rs1,rs2,fct2,rs3) \
247 _R4type(_jit, op, rd, fct, rs1, rs2, fct2, rs3)
248 static void _R4type(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t,
249 jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
250 # define Itype(op, rd, fct, rs1, imm) \
251 _Itype(_jit, op, rd, fct, rs1, imm)
252 static void _Itype(jit_state_t*, jit_int32_t, jit_int32_t,
253 jit_int32_t, jit_int32_t, jit_int32_t);
254 # if __WORDSIZE == 64
255 # define IStype(op, rd, fct, rs1, sh, imm) \
256 _IStype(_jit, op, rd, fct, rs1, sh, imm)
257 static void _IStype(jit_state_t*, jit_int32_t, jit_int32_t,
258 jit_int32_t, jit_int32_t, jit_int32_t,jit_int32_t);
260 # define Stype(op, fct, rs1, rs2, imm) \
261 _Stype(_jit, op, fct, rs1, rs2, imm)
262 static void _Stype(jit_state_t*, jit_int32_t, jit_int32_t,
263 jit_int32_t, jit_int32_t, jit_int32_t);
264 # define Btype(op, fct, rs1, rs2, imm) \
265 _Btype(_jit, op, fct, rs1, rs2, imm)
266 static void _Btype(jit_state_t*, jit_int32_t, jit_int32_t,
267 jit_int32_t, jit_int32_t, jit_int32_t);
268 # define Utype(op, rd, imm) _Utype(_jit, op, rd, imm)
269 static void _Utype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
270 # define Jtype(op, rd, imm) _Jtype(_jit, op, rd, imm)
271 static void _Jtype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
273 * Lightning instructions
275 # define nop(im) _nop(_jit, im)
276 static void _nop(jit_state_t*, jit_int32_t);
277 # define addr(r0, r1, r2) ADD(r0, r1, r2)
278 # define addi(r0, r1, im) _addi(_jit, r0, r1, im)
279 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
280 # define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2)
281 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
282 # define addci(r0, r1, im) _addci(_jit, r0, r1, im)
283 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
284 # define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2)
285 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
286 # define addxi(r0, r1, im) _addxi(_jit, r0, r1, im)
287 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
288 # define subr(r0, r1, r2) SUB(r0, r1, r2)
289 # define subi(r0, r1, im) _subi(_jit, r0, r1, im)
290 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
291 # define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2)
292 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
293 # define subci(r0, r1, im) _subci(_jit, r0, r1, im)
294 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
295 # define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2)
296 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
297 # define subxi(r0, r1, im) _subxi(_jit, r0, r1, im)
298 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
299 # define rsbi(r0, r1, im) _rsbi(_jit, r0, r1, im)
300 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
301 # define mulr(r0, r1, r2) MUL(r0, r1, r2)
302 # define muli(r0, r1, im) _muli(_jit, r0, r1, im)
303 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
304 # define divr(r0, r1, r2) DIV(r0, r1, r2)
305 # define divi(r0, r1, im) _divi(_jit, r0, r1, im)
306 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
307 # define divr_u(r0, r1, r2) DIVU(r0, r1, r2)
308 # define divi_u(r0, r1, im) _divi_u(_jit, r0, r1, im)
309 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
310 # define remr(r0, r1, r2) REM(r0, r1, r2)
311 # define remi(r0, r1, im) _remi(_jit, r0, r1, im)
312 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
313 # define remr_u(r0, r1, r2) REMU(r0, r1, r2)
314 # define remi_u(r0, r1, im) _remi_u(_jit, r0, r1, im)
315 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
316 # define qmulr(r0, r1, r2, r3) _qmulr(_jit,r0,r1,r2,r3)
317 static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
318 # define qmuli(r0, r1, r2, i0) _qmuli(_jit,r0,r1,r2,i0)
319 static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
320 # define qmulr_u(r0, r1, r2, r3) _qmulr_u(_jit,r0,r1,r2,r3)
321 static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
322 # define qmuli_u(r0, r1, r2, i0) _qmuli_u(_jit,r0,r1,r2,i0)
323 static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
324 static void _iqdivr(jit_state_t*,jit_bool_t,
325 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
326 # define qdivr(r0,r1,r2,r3) _iqdivr(_jit,1,r0,r1,r2,r3)
327 # define qdivr_u(r0,r1,r2,r3) _iqdivr(_jit,0,r0,r1,r2,r3)
328 static void _iqdivr(jit_state_t*,jit_bool_t,
329 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
330 # define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
331 static void _qdivi(jit_state_t*,jit_int32_t,
332 jit_int32_t,jit_int32_t,jit_word_t);
333 # define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
334 static void _qdivi_u(jit_state_t*,jit_int32_t,
335 jit_int32_t,jit_int32_t,jit_word_t);
336 # define lshr(r0, r1, r2) SLL(r0, r1, r2)
337 # define lshi(r0, r1, im) _lshi(_jit, r0, r1, im)
338 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
339 # define rshr(r0, r1, r2) SRA(r0, r1, r2)
340 # define rshi(r0, r1, im) _rshi(_jit, r0, r1, im)
341 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
342 # define rshr_u(r0, r1, r2) SRL(r0, r1, r2)
343 # define rshi_u(r0, r1, im) _rshi_u(_jit, r0, r1, im)
344 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
345 # define negr(r0, r1) NEG(r0, r1)
346 # define comr(r0, r1) NOT(r0, r1)
347 # define andr(r0, r1, r2) AND(r0, r1, r2)
348 # define andi(r0, r1, im) _andi(_jit, r0, r1, im)
349 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
350 # define orr(r0, r1, r2) OR(r0, r1, r2)
351 # define ori(r0, r1, im) _ori(_jit, r0, r1, im)
352 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
353 # define xorr(r0, r1, r2) XOR(r0, r1, r2)
354 # define xori(r0, r1, im) _xori(_jit, r0, r1, im)
355 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
356 # define ldr_c(r0, r1) LB(r0, r1, 0)
357 # define ldi_c(r0, im) _ldi_c(_jit, r0, im)
358 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
359 # define ldr_uc(r0, r1) LBU(r0, r1, 0)
360 # define ldi_uc(r0, im) _ldi_uc(_jit, r0, im)
361 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
362 # define ldr_s(r0, r1) LH(r0, r1, 0)
363 # define ldi_s(r0, im) _ldi_s(_jit, r0, im)
364 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
365 # define ldr_us(r0, r1) LHU(r0, r1, 0)
366 # define ldi_us(r0, im) _ldi_us(_jit, r0, im)
367 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
368 # define ldr_i(r0, r1) LW(r0, r1, 0)
369 # define ldi_i(r0, im) _ldi_i(_jit, r0, im)
370 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
371 # define ldr_ui(r0, r1) LWU(r0, r1, 0)
372 # define ldi_ui(r0, im) _ldi_ui(_jit, r0, im)
373 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
374 # define ldr_l(r0, r1) LD(r0, r1, 0)
375 # define ldi_l(r0, im) _ldi_l(_jit, r0, im)
376 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
377 # define ldxr_c(r0, r1, r2) _ldxr_c(_jit, r0, r1, r2)
378 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
379 # define ldxi_c(r0, r1, im) _ldxi_c(_jit, r0, r1, im)
380 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
381 # define ldxr_uc(r0, r1, r2) _ldxr_uc(_jit, r0, r1, r2)
382 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
383 # define ldxi_uc(r0, r1, im) _ldxi_uc(_jit, r0, r1, im)
384 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
385 # define ldxr_s(r0, r1, r2) _ldxr_s(_jit, r0, r1, r2)
386 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
387 # define ldxi_s(r0, r1, im) _ldxi_s(_jit, r0, r1, im)
388 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
389 # define ldxr_us(r0, r1, r2) _ldxr_us(_jit, r0, r1, r2)
390 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
391 # define ldxi_us(r0, r1, im) _ldxi_us(_jit, r0, r1, im)
392 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
393 # define ldxr_i(r0, r1, r2) _ldxr_i(_jit, r0, r1, r2)
394 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
395 # define ldxi_i(r0, r1, im) _ldxi_i(_jit, r0, r1, im)
396 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
397 # define ldxr_ui(r0, r1, r2) _ldxr_ui(_jit, r0, r1, r2)
398 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
399 # define ldxi_ui(r0, r1, im) _ldxi_ui(_jit, r0, r1, im)
400 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
401 # define ldxr_l(r0, r1, r2) _ldxr_l(_jit, r0, r1, r2)
402 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
403 # define ldxi_l(r0, r1, im) _ldxi_l(_jit, r0, r1, im)
404 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
405 # define str_c(r0, r1) SB(r0, r1, 0)
406 # define sti_c(im, r0) _sti_c(_jit, im, r0)
407 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
408 # define str_s(r0, r1) SH(r0, r1, 0)
409 # define sti_s(im, r0) _sti_s(_jit, im, r0)
410 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
411 # define str_i(r0, r1) SW(r0, r1, 0)
412 # define sti_i(im, r0) _sti_i(_jit, im, r0)
413 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
414 # define str_l(r0, r1) SD(r0, r1, 0)
415 # define sti_l(im, r0) _sti_l(_jit, im, r0)
416 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
417 # define stxr_c(r0, r1, r2) _stxr_c(_jit, r0, r1, r2)
418 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
419 # define stxi_c(i0, r0, r1) _stxi_c(_jit, i0, r0, r1)
420 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
421 # define stxr_s(r0, r1, r2) _stxr_s(_jit, r0, r1, r2)
422 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
423 # define stxi_s(i0, r0, r1) _stxi_s(_jit, i0, r0, r1)
424 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
425 # define stxr_i(r0, r1, r2) _stxr_i(_jit, r0, r1, r2)
426 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
427 # define stxi_i(i0, r0, r1) _stxi_i(_jit, i0, r0, r1)
428 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
429 # define stxr_l(r0, r1, r2) _stxr_l(_jit, r0, r1, r2)
430 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
431 # define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1)
432 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
433 # define bswapr_us(r0, r1) generic_bswapr_us(_jit, r0, r1)
434 # define bswapr_ui(r0, r1) generic_bswapr_ui(_jit, r0, r1)
435 # define bswapr_ul(r0, r1) generic_bswapr_ul(_jit, r0, r1)
436 # define extr_c(r0, r1) _extr_c(_jit, r0, r1)
437 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
438 # define extr_uc(r0, r1) andi(r0, r1, 0xff)
439 # define extr_s(r0, r1) _extr_s(_jit, r0, r1)
440 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
441 # define extr_us(r0, r1) _extr_us(_jit, r0, r1)
442 static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
443 # define extr_i(r0, r1) SEXT_W(r0, r1)
444 # define extr_ui(r0, r1) _extr_ui(_jit, r0, r1)
445 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
446 # define movr(r0, r1) MV(r0, r1)
447 # define movi(r0, im) _movi(_jit, r0, im)
448 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
449 # define movi_p(r0, im) _movi_p(_jit, r0, im)
450 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
451 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
452 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
453 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
454 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
455 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
456 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
457 jit_int32_t,jit_int32_t,jit_word_t);
458 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
459 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
460 # define ltr(r0, r1, r2) SLT(r0, r1, r2)
461 # define lti(r0, r1, im) _lti(_jit, r0, r1, im)
462 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
463 # define ltr_u(r0, r1, r2) SLTU(r0, r1, r2)
464 # define lti_u(r0, r1, im) _lti_u(_jit, r0, r1, im)
465 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
466 # define ler(r0, r1, r2) _ler(_jit, r0, r1, r2)
467 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
468 # define lei(r0, r1, im) _lei(_jit, r0, r1, im)
469 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
470 # define ler_u(r0, r1, r2) _ler_u(_jit, r0, r1, r2)
471 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
472 # define lei_u(r0, r1, im) _lei_u(_jit, r0, r1, im)
473 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
474 # define eqr(r0, r1, r2) _eqr(_jit, r0, r1, r2)
475 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
476 # define eqi(r0, r1, im) _eqi(_jit, r0, r1, im)
477 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
478 # define ger(r0, r1, r2) _ger(_jit, r0, r1, r2)
479 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
480 # define gei(r0, r1, r2) _gei(_jit, r0, r1, r2)
481 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
482 # define ger_u(r0, r1, r2) _ger_u(_jit, r0, r1, r2)
483 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
484 # define gei_u(r0, r1, im) _gei_u(_jit, r0, r1, im)
485 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
486 # define gtr(r0, r1, r2) SLT(r0, r2, r1)
487 # define gti(r0, r1, im) _gti(_jit, r0, r1, im)
488 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
489 # define gtr_u(r0, r1, r2) SLTU(r0, r2, r1)
490 # define gti_u(r0, r1, im) _gti_u(_jit, r0, r1, im)
491 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
492 # define ner(r0, r1, r2) _ner(_jit, r0, r1, r2)
493 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
494 # define nei(r0, r1, im) _nei(_jit, r0, r1, im)
495 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
496 # define bltr(br, r0, r1) _bltr(_jit, br, r0, r1)
497 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
498 # define blti(br, r0, im) _blti(_jit, br, r0, im)
499 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
500 # define bltr_u(br, r0, r1) _bltr_u(_jit, br, r0, r1)
501 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
502 # define blti_u(br, r0, im) _blti_u(_jit, br, r0, im)
503 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
504 # define bler(br, r0, r1) _bler(_jit, br, r0, r1)
505 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
506 # define blei(br, r0, im) _blei(_jit, br, r0, im)
507 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
508 # define bler_u(br, r0, r1) _bler_u(_jit, br, r0, r1)
509 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
510 # define blei_u(br, r0, im) _blei_u(_jit, br, r0, im)
511 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
512 # define beqr(br, r0, r1) _beqr(_jit, br, r0, r1)
513 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
514 # define beqi(br, r0, im) _beqi(_jit, br, r0, im)
515 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
516 # define bger(br, r0, r1) _bger(_jit, br, r0, r1)
517 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
518 # define bgei(br, r0, im) _bgei(_jit, br, r0, im)
519 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
520 # define bger_u(br, r0, r1) _bger_u(_jit, br, r0, r1)
521 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
522 # define bgei_u(br, r0, im) _bgei_u(_jit, br, r0, im)
523 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
524 # define bgtr(br, r0, r1) _bgtr(_jit, br, r0, r1)
525 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
526 # define bgti(br, r0, im) _bgti(_jit, br, r0, im)
527 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
528 # define bgtr_u(br, r0, r1) _bgtr_u(_jit, br, r0, r1)
529 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
530 # define bgti_u(br, r0, im) _bgti_u(_jit, br, r0, im)
531 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
532 # define bner(br, r0, r1) _bner(_jit, br, r0, r1)
533 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
534 # define bnei(br, r0, im) _bnei(_jit, br, r0, im)
535 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
536 # define boaddr(br, r0, r1) _boaddr(_jit, br, r0, r1)
537 # define boaddi(br, r0, im) _boaddi(_jit, br, r0, im)
538 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
539 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
540 # define boaddr_u(br, r0, r1) _boaddr_u(_jit, br, r0, r1)
541 # define boaddi_u(br, r0, im) _boaddi_u(_jit, br, r0, im)
542 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
543 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
544 # define bxaddr(br, r0, r1) _bxaddr(_jit, br, r0, r1)
545 # define bxaddi(br, r0, im) _bxaddi(_jit, br, r0, im)
546 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
547 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
548 # define bxaddr_u(br, r0, r1) _bxaddr_u(_jit, br, r0, r1)
549 # define bxaddi_u(br, r0, im) _bxaddi_u(_jit, br, r0, im)
550 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
551 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
552 # define bosubr(br, r0, r1) _bosubr(_jit, br, r0, r1)
553 # define bosubi(br, r0, im) _bosubi(_jit, br, r0, im)
554 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
555 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
556 # define bosubr_u(br, r0, r1) _bosubr_u(_jit, br, r0, r1)
557 # define bosubi_u(br, r0, im) _bosubi_u(_jit, br, r0, im)
558 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
559 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
560 # define bxsubr(br, r0, r1) _bxsubr(_jit, br, r0, r1)
561 # define bxsubi(br, r0, im) _bxsubi(_jit, br, r0, im)
562 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
563 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
564 # define bxsubr_u(br, r0, r1) _bxsubr_u(_jit, br, r0, r1)
565 # define bxsubi_u(br, r0, im) _bxsubi_u(_jit, br, r0, im)
566 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
567 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
568 # define bmsr(br, r0, r1) _bmsr(_jit, br, r0, r1)
569 # define bmsi(br, r0, im) _bmsi(_jit, br, r0, im)
570 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
571 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
572 # define bmcr(br, r0, r1) _bmcr(_jit, br, r0, r1)
573 # define bmci(br, r0, im) _bmci(_jit, br, r0, im)
574 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
575 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
576 # define jmpr(r0) JALR(_ZERO_REGNO, r0, 0)
577 # define jmpi(im) _jmpi(_jit, im)
578 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
579 # define jmpi_p(im) _jmpi_p(_jit, im)
580 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
581 # define callr(r0) JALR(_RA_REGNO, r0, 0)
582 # define calli(im) _calli(_jit, im)
583 static jit_word_t _calli(jit_state_t*,jit_word_t);
584 # define calli_p(im) _calli_p(_jit, im)
585 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
586 # define prolog(i0) _prolog(_jit,i0)
587 static void _prolog(jit_state_t*,jit_node_t*);
588 # define epilog(i0) _epilog(_jit,i0)
589 static void _epilog(jit_state_t*,jit_node_t*);
590 # define vastart(r0) _vastart(_jit, r0)
591 static void _vastart(jit_state_t*, jit_int32_t);
592 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
593 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
594 #define patch_abs(instr,label) _patch_at(_jit,instr,label)
595 #define patch_at(instr,label) _patch_at(_jit,instr,label)
596 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
601 _Rtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
602 jit_int32_t fct, jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2)
605 assert(!(op & ~0x7f));
606 assert(!(rd & ~0x1f));
607 assert(!(fct & ~0x07));
608 assert(!(rs1 & ~0x1f));
609 assert(!(rs2 & ~0x1f));
610 assert(!(fct2 & ~0x7f));
621 _R4type(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t fct,
622 jit_int32_t rs1, jit_int32_t rs2, jit_int32_t fct2, jit_int32_t rs3)
625 assert(!(op & ~0x7f));
626 assert(!(rd & ~0x1f));
627 assert(!(fct & ~0x07));
628 assert(!(rs1 & ~0x1f));
629 assert(!(rs2 & ~0x1f));
630 assert(!(fct2 & ~0x03));
631 assert(!(rs3 & ~0x1f));
643 _Itype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
644 jit_int32_t fct, jit_int32_t rs1, jit_int32_t imm)
647 assert(!(op & ~0x7f));
648 assert(!(rd & ~0x1f));
649 assert(!(fct & ~0x07));
650 assert(!(rs1 & ~0x1f));
651 assert(simm12_p(imm));
660 # if __WORDSIZE == 64
662 _IStype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
663 jit_int32_t fct, jit_int32_t rs1, jit_int32_t sh, jit_int32_t imm)
666 assert(!(op & ~0x7f));
667 assert(!(rd & ~0x1f));
668 assert(!(fct & ~0x07));
669 assert(!(rs1 & ~0x1f));
670 assert(!(sh & ~0x3f));
671 assert(simm6_p(imm));
683 _Stype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
684 jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
687 assert(!(op & ~0x7f));
688 assert(!(fct & ~0x07));
689 assert(!(rs1 & ~0x1f));
690 assert(!(rs2 & ~0x1f));
691 assert(simm12_p(imm));
693 i.S.imm4_0 = imm & 0x1f;
697 i.S.imm11_5 = (imm >> 5) & 0x7f;
702 _Btype(jit_state_t *_jit, jit_int32_t op, jit_int32_t fct,
703 jit_int32_t rs1, jit_int32_t rs2, jit_int32_t imm)
706 assert(!(op & ~0x7f));
707 assert(!(fct & ~0x07));
708 assert(!(rs1 & ~0x1f));
709 assert(!(rs2 & ~0x1f));
710 assert(!(imm & 1) && simm12_p(imm));
712 i.B.imm11 = (imm >> 11) & 0x1;
713 i.B.imm4_1 = (imm >> 1) & 0xf;
717 i.B.imm10_5 = (imm >> 5) & 0x3f;
718 i.B.imm12 = (imm >> 12) & 0x1;
723 _Utype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
726 assert(!(op & ~0x7f));
727 assert(!(rd & ~0x1f));
728 assert(simm20_p(imm));
736 _Jtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
739 assert(!(op & ~0x7f));
740 assert(!(rd & ~0x1f));
741 assert(!(imm & 1) && imm <= 1048575 && imm >= -1048576);
744 i.J.imm19_12= (imm >> 12) & 0xff;
745 i.J.imm11 = (imm >> 11) & 0x1;
746 i.J.imm10_1 = (imm >> 1) & 0x3ff;
747 i.J.imm20 = (imm >> 20) & 0x1;
752 _nop(jit_state_t *_jit, jit_int32_t im)
754 for (; im > 0; im -= 4)
760 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
766 t0 = jit_get_reg(jit_class_gpr);
768 addr(r0, r1, rn(t0));
774 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
777 if (jit_carry == _NOREG)
778 jit_carry = jit_get_reg(jit_class_gpr);
780 t0 = jit_get_reg(jit_class_gpr);
781 addr(rn(t0), r1, r2);
782 SLTU(rn(jit_carry), rn(t0), r1);
788 SLTU(rn(jit_carry), r0, r1);
793 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
796 if (jit_carry == _NOREG)
797 jit_carry = jit_get_reg(jit_class_gpr);
799 t0 = jit_get_reg(jit_class_gpr);
800 addi(rn(t0), r1, i0);
801 SLTU(rn(jit_carry), rn(t0), r1);
807 SLTU(rn(jit_carry), r0, r1);
812 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
815 assert(jit_carry != _NOREG);
816 t0 = jit_get_reg(jit_class_gpr);
817 movr(rn(t0), rn(jit_carry));
819 addcr(r0, r0, rn(t0));
824 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
827 assert(jit_carry != _NOREG);
828 t0 = jit_get_reg(jit_class_gpr);
829 movr(rn(t0), rn(jit_carry));
831 addcr(r0, r0, rn(t0));
836 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
842 t0 = jit_get_reg(jit_class_gpr);
844 subr(r0, r1, rn(t0));
850 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
853 if (jit_carry == _NOREG)
854 jit_carry = jit_get_reg(jit_class_gpr);
856 t0 = jit_get_reg(jit_class_gpr);
857 subr(rn(t0), r1, r2);
858 SLTU(rn(jit_carry), r1, rn(t0));
864 SLTU(rn(jit_carry), r1, r0);
869 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
872 if (jit_carry == _NOREG)
873 jit_carry = jit_get_reg(jit_class_gpr);
875 t0 = jit_get_reg(jit_class_gpr);
876 subi(rn(t0), r1, i0);
877 SLTU(rn(jit_carry), r1, rn(t0));
883 SLTU(rn(jit_carry), r1, r0);
888 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
891 assert(jit_carry != _NOREG);
892 t0 = jit_get_reg(jit_class_gpr);
893 movr(rn(t0), rn(jit_carry));
895 subcr(r0, r0, rn(t0));
900 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
903 assert(jit_carry != _NOREG);
904 t0 = jit_get_reg(jit_class_gpr);
905 movr(rn(t0), rn(jit_carry));
907 subcr(r0, r0, rn(t0));
912 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
919 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
922 t0 = jit_get_reg(jit_class_gpr);
924 mulr(r0, r1, rn(t0));
929 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
932 t0 = jit_get_reg(jit_class_gpr);
934 divr(r0, r1, rn(t0));
939 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
942 t0 = jit_get_reg(jit_class_gpr);
944 divr_u(r0, r1, rn(t0));
949 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
952 t0 = jit_get_reg(jit_class_gpr);
954 remr(r0, r1, rn(t0));
959 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
962 t0 = jit_get_reg(jit_class_gpr);
964 remr_u(r0, r1, rn(t0));
969 _qmulr(jit_state_t *_jit, jit_int32_t r0,
970 jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
973 if (r0 == r2 || r0 == r3) {
974 t0 = jit_get_reg(jit_class_gpr);
975 mulr(rn(t0), r2, r3);
980 if (r0 == r2 || r0 == r3) {
987 _qmuli(jit_state_t *_jit, jit_int32_t r0,
988 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
991 t0 = jit_get_reg(jit_class_gpr);
993 qmulr(r0, r1, r2, rn(t0));
998 _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
999 jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1002 if (r0 == r2 || r0 == r3) {
1003 t0 = jit_get_reg(jit_class_gpr);
1004 mulr(rn(t0), r2, r3);
1009 if (r0 == r2 || r0 == r3) {
1016 _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
1017 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1020 t0 = jit_get_reg(jit_class_gpr);
1022 qmulr_u(r0, r1, r2, rn(t0));
1027 _iqdivr(jit_state_t *_jit, jit_bool_t sign,
1028 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1030 jit_int32_t sv0, rg0;
1031 jit_int32_t sv1, rg1;
1032 if (r0 == r2 || r0 == r3) {
1033 sv0 = jit_get_reg(jit_class_gpr);
1038 if (r1 == r2 || r1 == r3) {
1039 sv1 = jit_get_reg(jit_class_gpr);
1047 divr_u(rg0, r2, r3);
1061 _qdivi(jit_state_t *_jit, jit_int32_t r0,
1062 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1065 t0 = jit_get_reg(jit_class_gpr);
1067 qdivr(r0, r1, r2, rn(t0));
1072 _qdivi_u(jit_state_t *_jit, jit_int32_t r0,
1073 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1076 t0 = jit_get_reg(jit_class_gpr);
1078 qdivr_u(r0, r1, r2, rn(t0));
1083 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1088 assert(i0 > 0 && i0 < 64);
1094 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1099 assert(i0 > 0 && i0 < 64);
1105 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1110 assert(i0 > 0 && i0 < 64);
1116 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1122 t0 = jit_get_reg(jit_class_gpr);
1124 andr(r0, r1, rn(t0));
1130 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1136 t0 = jit_get_reg(jit_class_gpr);
1138 orr(r0, r1, rn(t0));
1144 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1150 t0 = jit_get_reg(jit_class_gpr);
1152 xorr(r0, r1, rn(t0));
1157 # define DEFLD(T,O) \
1159 _ldi_##T(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) \
1162 L##O(r0, _ZERO_REGNO, i0); \
1165 t0 = jit_get_reg(jit_class_gpr); \
1167 ldr_##T(r0, rn(t0)); \
1168 jit_unget_reg(t0); \
1173 _ldxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1176 t0 = jit_get_reg(jit_class_gpr); \
1177 addr(rn(t0), r1, r2); \
1178 ldr_##T(r0, rn(t0)); \
1179 jit_unget_reg(t0); \
1183 _ldxi_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)\
1189 t0 = jit_get_reg(jit_class_gpr); \
1190 addi(rn(t0), r1, i0); \
1191 ldr_##T(r0, rn(t0)); \
1192 jit_unget_reg(t0); \
1204 # define DEFST(T, O) \
1206 _sti_##T(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) \
1209 S##O(_ZERO_REGNO, r0, i0); \
1212 t0 = jit_get_reg(jit_class_gpr); \
1214 str_##T(rn(t0), r0); \
1215 jit_unget_reg(t0); \
1220 _stxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
1223 t0 = jit_get_reg(jit_class_gpr); \
1224 addr(rn(t0), r0, r1); \
1225 str_##T(rn(t0), r2); \
1226 jit_unget_reg(t0); \
1230 _stxi_##T(jit_state_t *_jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)\
1236 t0 = jit_get_reg(jit_class_gpr); \
1237 addi(rn(t0), r0, i0); \
1238 str_##T(rn(t0), r1); \
1239 jit_unget_reg(t0); \
1249 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1256 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1263 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1270 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1277 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1279 # if __WORDSIZE == 64
1282 jit_int32_t lo = (jit_int32_t)i0 << 20 >> 20;
1283 jit_int32_t hi = i0 - lo;
1290 ADDIW(r0, _ZERO_REGNO, lo);
1291 # if __WORDSIZE == 64
1299 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1303 # if __WORDSIZE == 64
1315 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1318 w = beqi(_jit->pc.w, r2, 0);
1320 patch_at(w, _jit->pc.w);
1324 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1327 w = bnei(_jit->pc.w, r2, 0);
1329 patch_at(w, _jit->pc.w);
1333 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1334 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1336 jit_int32_t t0, r1_reg, iscasi;
1337 jit_word_t retry, done, jump0, jump1;
1338 if ((iscasi = (r1 == _NOREG))) {
1339 r1_reg = jit_get_reg(jit_class_gpr);
1343 t0 = jit_get_reg(jit_class_gpr);
1345 # if __WORDSIZE == 32
1352 # if __WORDSIZE == 32
1353 SC_W(rn(t0), r1, r3);
1355 SC_D(rn(t0), r1, r3);
1358 BNE(rn(t0), _ZERO_REGNO, 0);
1361 patch_at(jump0, done);
1362 patch_at(jump1, retry);
1365 jit_unget_reg(r1_reg);
1369 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1375 t0 = jit_get_reg(jit_class_gpr);
1377 ltr(r0, r1, rn(t0));
1383 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1389 t0 = jit_get_reg(jit_class_gpr);
1391 ltr_u(r0, r1, rn(t0));
1397 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1404 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1408 SLT(r0, _ZERO_REGNO, r1);
1412 t0 = jit_get_reg(jit_class_gpr);
1414 ler(r0, r1, rn(t0));
1420 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1427 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1431 SLTU(r0, _ZERO_REGNO, r1);
1435 t0 = jit_get_reg(jit_class_gpr);
1437 ler_u(r0, r1, rn(t0));
1443 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1446 SLTU(r0, _ZERO_REGNO, r0);
1451 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1455 SLTU(r0, _ZERO_REGNO, r0);
1458 SLTU(r0, _ZERO_REGNO, r1);
1463 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1470 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1473 t0 = jit_get_reg(jit_class_gpr);
1475 ger(r0, r1, rn(t0));
1480 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1487 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1490 t0 = jit_get_reg(jit_class_gpr);
1492 ger_u(r0, r1, rn(t0));
1497 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1500 t0 = jit_get_reg(jit_class_gpr);
1502 ltr(r0, rn(t0), r1);
1507 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1510 t0 = jit_get_reg(jit_class_gpr);
1512 ltr_u(r0, rn(t0), r1);
1517 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1520 SLTU(r0, _ZERO_REGNO, r0);
1524 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1528 SLTU(r0, _ZERO_REGNO, r0);
1531 SLTU(r0, _ZERO_REGNO, r1);
1535 _bltr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1539 BLT(r0, r1, br - w);
1544 _blti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1548 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1550 w = bltr(br, r0, rn(t0));
1556 _bltr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1560 BLTU(r0, r1, br - w);
1565 _blti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1569 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1571 w = bltr_u(br, r0, rn(t0));
1577 _bler(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1581 BGE(r1, r0, br - w);
1586 _blei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1590 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1592 w = bler(br, r0, rn(t0));
1598 _bler_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1602 BGEU(r1, r0, br - w);
1607 _blei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1611 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1613 w = bler_u(br, r0, rn(t0));
1619 _beqr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1623 BEQ(r1, r0, br - w);
1628 _beqi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1632 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1634 w = beqr(br, r0, rn(t0));
1640 _bger(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1644 BGE(r0, r1, br - w);
1649 _bgei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1653 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1655 w = bger(br, r0, rn(t0));
1661 _bger_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1665 BGEU(r0, r1, br - w);
1670 _bgei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1674 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1676 w = bger_u(br, r0, rn(t0));
1682 _bgtr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1686 BLT(r1, r0, br - w);
1691 _bgti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1695 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1697 w = bgtr(br, r0, rn(t0));
1703 _bgtr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1707 BLTU(r1, r0, br - w);
1712 _bgti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1716 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1718 w = bgtr_u(br, r0, rn(t0));
1724 _bner(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1728 BNE(r1, r0, br - w);
1733 _bnei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1737 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1739 w = bner(br, r0, rn(t0));
1745 _boaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1749 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1750 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1752 SLT(rn(t0), r1, _ZERO_REGNO);
1757 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1759 BNE(rn(t0), _ZERO_REGNO, 0);
1761 SLT(rn(t1), r0, rn(t1));
1763 JAL(_ZERO_REGNO, 0);
1765 patch_at(w, _jit->pc.w);
1766 SLT(rn(t1), rn(t1), r0);
1768 patch_at(jal, _jit->pc.w);
1770 BNE(rn(t1), _ZERO_REGNO, br - w);
1777 _boaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1781 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1783 w = boaddr(br, r0, rn(t0));
1789 _boaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1793 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1794 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1795 addr(rn(t0), r0, r1);
1796 SLTU(rn(t1), rn(t0), r0);
1799 BNE(_ZERO_REGNO, rn(t1), br - w);
1806 _boaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1810 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1812 w = boaddr_u(br, r0, rn(t0));
1818 _bxaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1822 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1823 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1825 SLT(rn(t0), r1, _ZERO_REGNO);
1830 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1832 BNE(rn(t0), _ZERO_REGNO, 0);
1834 SLT(rn(t1), r0, rn(t1));
1836 JAL(_ZERO_REGNO, 0);
1838 patch_at(w, _jit->pc.w);
1839 SLT(rn(t1), rn(t1), r0);
1841 patch_at(jal, _jit->pc.w);
1843 BEQ(rn(t1), _ZERO_REGNO, br - w);
1850 _bxaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1854 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1856 w = bxaddr(br, r0, rn(t0));
1862 _bxaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1866 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1867 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1868 addr(rn(t0), r0, r1);
1869 SLTU(rn(t1), rn(t0), r0);
1872 BEQ(_ZERO_REGNO, rn(t1), br - w);
1879 _bxaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1883 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1885 w = bxaddr_u(br, r0, rn(t0));
1891 _bosubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1895 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1896 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1898 SLT(rn(t0), _ZERO_REGNO, r1);
1903 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1905 BNE(rn(t0), _ZERO_REGNO, 0);
1907 SLT(rn(t1), r0, rn(t1));
1909 JAL(_ZERO_REGNO, 0);
1911 patch_at(w, _jit->pc.w);
1912 SLT(rn(t1), rn(t1), r0);
1914 patch_at(jal, _jit->pc.w);
1916 BNE(rn(t1), _ZERO_REGNO, br - w);
1923 _bosubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1927 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1929 w = bosubr(br, r0, rn(t0));
1935 _bosubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1939 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1940 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1941 subr(rn(t0), r0, r1);
1942 SLTU(rn(t1), r0, rn(t0));
1945 BNE(_ZERO_REGNO, rn(t1), br - w);
1952 _bosubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1956 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1958 w = bosubr_u(br, r0, rn(t0));
1964 _bxsubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1968 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1969 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1971 SLT(rn(t0), _ZERO_REGNO, r1);
1976 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1978 BNE(rn(t0), _ZERO_REGNO, 0);
1980 SLT(rn(t1), r0, rn(t1));
1982 JAL(_ZERO_REGNO, 0);
1984 patch_at(w, _jit->pc.w);
1985 SLT(rn(t1), rn(t1), r0);
1987 patch_at(jal, _jit->pc.w);
1989 BEQ(rn(t1), _ZERO_REGNO, br - w);
1996 _bxsubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2000 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2002 w = bxsubr(br, r0, rn(t0));
2008 _bxsubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2012 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2013 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2014 subr(rn(t0), r0, r1);
2015 SLTU(rn(t1), r0, rn(t0));
2018 BEQ(_ZERO_REGNO, rn(t1), br - w);
2025 _bxsubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2029 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2031 w = bxsubr_u(br, r0, rn(t0));
2037 _bmsr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2041 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2042 AND(rn(t0), r0, r1);
2044 BNE(_ZERO_REGNO, rn(t0), br - w);
2050 _bmsi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2054 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2056 w = bmsr(br, r0, rn(t0));
2062 _bmcr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2066 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2067 AND(rn(t0), r0, r1);
2069 BEQ(_ZERO_REGNO, rn(t0), br - w);
2075 _bmci(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2079 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2081 w = bmcr(br, r0, rn(t0));
2087 _jmpi(jit_state_t *_jit, jit_word_t i0)
2094 JAL(_ZERO_REGNO, dsp);
2096 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2105 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2109 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2110 w = movi_p(rn(t0), i0);
2117 _calli(jit_state_t *_jit, jit_word_t i0)
2124 JAL(_RA_REGNO, dsp);
2126 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2135 _calli_p(jit_state_t *_jit, jit_word_t i0)
2139 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2140 w = movi_p(rn(t0), i0);
2147 _prolog(jit_state_t *_jit, jit_node_t *node)
2149 jit_int32_t reg, offs;
2150 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2151 jit_int32_t frame = -_jitc->function->frame;
2153 assert(_jitc->function->self.aoff >= frame);
2154 if (_jitc->function->assume_frame)
2156 _jitc->function->self.aoff = frame;
2158 if (_jitc->function->allocar)
2159 _jitc->function->self.aoff &= -16;
2160 _jitc->function->stack = ((_jitc->function->self.alen -
2161 /* align stack at 16 bytes */
2162 _jitc->function->self.aoff) + 15) & -16;
2164 if (_jitc->function->stack)
2165 _jitc->function->need_stack = 1;
2166 if (!_jitc->function->need_frame && !_jitc->function->need_stack) {
2167 /* check if any callee save register needs to be saved */
2168 for (reg = 0; reg < _jitc->reglen; ++reg)
2169 if (jit_regset_tstbit(&_jitc->function->regset, reg) &&
2170 (_rvs[reg].spec & jit_class_sav)) {
2171 _jitc->function->need_stack = 1;
2176 if (_jitc->function->need_frame || _jitc->function->need_stack)
2177 subi(_SP_REGNO, _SP_REGNO, jit_framesize());
2178 if (_jitc->function->need_frame) {
2179 stxi(0, _SP_REGNO, _RA_REGNO);
2180 stxi(8, _SP_REGNO, _FP_REGNO);
2182 /* callee save registers */
2183 for (reg = 0, offs = 16; reg < jit_size(iregs); reg++) {
2184 if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
2185 stxi(offs, _SP_REGNO, rn(iregs[reg]));
2186 offs += sizeof(jit_word_t);
2189 for (reg = 0; reg < jit_size(fregs); reg++) {
2190 if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
2191 stxi_d(offs, _SP_REGNO, rn(fregs[reg]));
2192 offs += sizeof(jit_float64_t);
2196 if (_jitc->function->need_frame)
2197 movr(_FP_REGNO, _SP_REGNO);
2198 if (_jitc->function->stack)
2199 subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
2200 if (_jitc->function->allocar) {
2201 reg = jit_get_reg(jit_class_gpr);
2202 movi(rn(reg), _jitc->function->self.aoff);
2203 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2206 if (_jitc->function->self.call & jit_call_varargs) {
2207 for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2208 stxi(jit_framesize() - ((8 - reg) * 8),
2209 _FP_REGNO, rn(JIT_RA0 - reg));
2214 _epilog(jit_state_t *_jit, jit_node_t *node)
2216 jit_int32_t reg, offs;
2217 if (_jitc->function->assume_frame)
2219 if (_jitc->function->need_frame) {
2220 movr(_SP_REGNO, _FP_REGNO);
2221 ldxi(_RA_REGNO, _SP_REGNO, 0);
2222 ldxi(_FP_REGNO, _SP_REGNO, 8);
2225 /* callee save registers */
2226 for (reg = 0, offs = 16; reg < jit_size(iregs); reg++) {
2227 if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
2228 ldxi(rn(iregs[reg]), _SP_REGNO, offs);
2229 offs += sizeof(jit_word_t);
2232 for (reg = 0; reg < jit_size(fregs); reg++) {
2233 if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
2234 ldxi_d(rn(fregs[reg]), _SP_REGNO, offs);
2235 offs += sizeof(jit_float64_t);
2239 if (_jitc->function->need_frame || _jitc->function->need_stack)
2240 addi(_SP_REGNO, _SP_REGNO, jit_framesize());
2245 _vastart(jit_state_t *_jit, jit_int32_t r0)
2247 assert(_jitc->function->self.call & jit_call_varargs);
2248 /* Initialize va_list to the first stack argument. */
2249 if (jit_arg_reg_p(_jitc->function->vagp))
2250 addi(r0, _FP_REGNO, jit_framesize() - ((8 - _jitc->function->vagp) * 8));
2252 addi(r0, _FP_REGNO, jit_selfsize());
2256 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2258 assert(_jitc->function->self.call & jit_call_varargs);
2259 /* Load argument. */
2261 /* Update va_list. */
2262 addi(r1, r1, sizeof(jit_word_t));
2266 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2276 # if __WORDSIZE == 64
2277 if (i.U.opcode == 23) { /* AUIPC */
2279 jit_word_t address, relative;
2280 address = get_const(label);
2281 relative = address - instr;
2282 assert(simm32_p(relative));
2283 lo = (jit_int32_t)relative << 20 >> 20;
2285 i.U.imm12_31 = hi >> 12;
2288 if (i.I.opcode == 19 && i.I.funct3 == 0) { /* ADDI */
2295 assert(i.I.opcode == 3 && i.I.funct3 == 3); /* LD */
2298 if (i.U.opcode == 55) { /* LUI */
2299 jit_int32_t lo = (jit_int32_t)label << 20 >> 20;
2300 jit_int32_t hi = label - lo;
2301 i.U.imm12_31 = hi >> 12;
2304 if (i.I.opcode == 27 && i.I.funct3 == 0) { /* ADDIW */
2313 /* b{lt,le,eq,ge,gt,ne}{,_u}? */
2314 else if (i.B.opcode == 99) { /* B{EQ,NE,LT,GE,LTU,GEU} */
2315 jit_word_t jmp = label - instr;
2316 assert(simm12_p(jmp));
2317 i.B.imm11 = (jmp >> 11) & 0x1;
2318 i.B.imm4_1 = (jmp >> 1) & 0xf;
2319 i.B.imm10_5 = (jmp >> 5) & 0x3f;
2320 i.B.imm12 = (jmp >> 12) & 0x1;
2323 else if (i.J.opcode == 111) { /* JAL */
2324 jit_word_t jmp = label - instr;
2325 i.J.imm19_12 = (jmp >> 12) & 0xff;
2326 i.J.imm11 = (jmp >> 11) & 0x1;
2327 i.J.imm10_1 = (jmp >> 1) & 0x3ff;
2328 i.J.imm20 = (jmp >> 20) & 0x1;