2 * Copyright (C) 2019 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 /* FIXME could jit_rewind_prolog() to only use extra 64 bytes
97 * if a variadic jit function that have variadic arguments in
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)
114 * RV32I Base Instruction Set
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)
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)
166 * RV64I Base Instruction Set (in addition to RV32I)
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)
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)
186 * RV32M Standard Extension
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)
197 * RV64M Standard Extension (in addition to RV32M)
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)
205 * RV32A Standard Extension
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)
219 * RV64A Standard Extension (in addition to RV32A)
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)
233 * Pseudo Instructions
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)
244 * Enconding functions
246 # define Rtype(op, rd, fct, rs1, rs2, fct2) \
247 _Rtype(_jit, op, rd, fct, rs1, rs2, fct2)
248 static void _Rtype(jit_state_t*, jit_int32_t, jit_int32_t,
249 jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
250 # define R4type(op, rd, fct, rs1,rs2,fct2,rs3) \
251 _R4type(_jit, op, rd, fct, rs1, rs2, fct2, rs3)
252 static void _R4type(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t,
253 jit_int32_t, jit_int32_t, jit_int32_t, jit_int32_t);
254 # define Itype(op, rd, fct, rs1, imm) \
255 _Itype(_jit, op, rd, fct, rs1, imm)
256 static void _Itype(jit_state_t*, jit_int32_t, jit_int32_t,
257 jit_int32_t, jit_int32_t, jit_int32_t);
258 # if __WORDSIZE == 64
259 # define IStype(op, rd, fct, rs1, sh, imm) \
260 _IStype(_jit, op, rd, fct, rs1, sh, imm)
261 static void _IStype(jit_state_t*, jit_int32_t, jit_int32_t,
262 jit_int32_t, jit_int32_t, jit_int32_t,jit_int32_t);
264 # define Stype(op, fct, rs1, rs2, imm) \
265 _Stype(_jit, op, fct, rs1, rs2, imm)
266 static void _Stype(jit_state_t*, jit_int32_t, jit_int32_t,
267 jit_int32_t, jit_int32_t, jit_int32_t);
268 # define Btype(op, fct, rs1, rs2, imm) \
269 _Btype(_jit, op, fct, rs1, rs2, imm)
270 static void _Btype(jit_state_t*, jit_int32_t, jit_int32_t,
271 jit_int32_t, jit_int32_t, jit_int32_t);
272 # define Utype(op, rd, imm) _Utype(_jit, op, rd, imm)
273 static void _Utype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
274 # define Jtype(op, rd, imm) _Jtype(_jit, op, rd, imm)
275 static void _Jtype(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
277 * Lightning instructions
279 # define nop(im) _nop(_jit, im)
280 static void _nop(jit_state_t*, jit_int32_t);
281 # define addr(r0, r1, r2) ADD(r0, r1, r2)
282 # define addi(r0, r1, im) _addi(_jit, r0, r1, im)
283 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
284 # define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2)
285 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
286 # define addci(r0, r1, im) _addci(_jit, r0, r1, im)
287 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
288 # define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2)
289 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
290 # define addxi(r0, r1, im) _addxi(_jit, r0, r1, im)
291 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
292 # define subr(r0, r1, r2) SUB(r0, r1, r2)
293 # define subi(r0, r1, im) _subi(_jit, r0, r1, im)
294 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
295 # define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2)
296 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
297 # define subci(r0, r1, im) _subci(_jit, r0, r1, im)
298 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
299 # define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2)
300 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
301 # define subxi(r0, r1, im) _subxi(_jit, r0, r1, im)
302 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
303 # define rsbi(r0, r1, im) _rsbi(_jit, r0, r1, im)
304 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
305 # define mulr(r0, r1, r2) MUL(r0, r1, r2)
306 # define muli(r0, r1, im) _muli(_jit, r0, r1, im)
307 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
308 # define divr(r0, r1, r2) DIV(r0, r1, r2)
309 # define divi(r0, r1, im) _divi(_jit, r0, r1, im)
310 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
311 # define divr_u(r0, r1, r2) DIVU(r0, r1, r2)
312 # define divi_u(r0, r1, im) _divi_u(_jit, r0, r1, im)
313 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
314 # define remr(r0, r1, r2) REM(r0, r1, r2)
315 # define remi(r0, r1, im) _remi(_jit, r0, r1, im)
316 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
317 # define remr_u(r0, r1, r2) REMU(r0, r1, r2)
318 # define remi_u(r0, r1, im) _remi_u(_jit, r0, r1, im)
319 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
320 # define qmulr(r0, r1, r2, r3) _qmulr(_jit,r0,r1,r2,r3)
321 static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
322 # define qmuli(r0, r1, r2, i0) _qmuli(_jit,r0,r1,r2,i0)
323 static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
324 # define qmulr_u(r0, r1, r2, r3) _qmulr_u(_jit,r0,r1,r2,r3)
325 static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
326 # define qmuli_u(r0, r1, r2, i0) _qmuli_u(_jit,r0,r1,r2,i0)
327 static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
328 static void _iqdivr(jit_state_t*,jit_bool_t,
329 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
330 # define qdivr(r0,r1,r2,r3) _iqdivr(_jit,1,r0,r1,r2,r3)
331 # define qdivr_u(r0,r1,r2,r3) _iqdivr(_jit,0,r0,r1,r2,r3)
332 static void _iqdivr(jit_state_t*,jit_bool_t,
333 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
334 # define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
335 static void _qdivi(jit_state_t*,jit_int32_t,
336 jit_int32_t,jit_int32_t,jit_word_t);
337 # define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
338 static void _qdivi_u(jit_state_t*,jit_int32_t,
339 jit_int32_t,jit_int32_t,jit_word_t);
340 # define lshr(r0, r1, r2) SLL(r0, r1, r2)
341 # define lshi(r0, r1, im) _lshi(_jit, r0, r1, im)
342 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
343 # define rshr(r0, r1, r2) SRA(r0, r1, r2)
344 # define rshi(r0, r1, im) _rshi(_jit, r0, r1, im)
345 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
346 # define rshr_u(r0, r1, r2) SRL(r0, r1, r2)
347 # define rshi_u(r0, r1, im) _rshi_u(_jit, r0, r1, im)
348 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
349 # define negr(r0, r1) NEG(r0, r1)
350 # define comr(r0, r1) NOT(r0, r1)
351 # define andr(r0, r1, r2) AND(r0, r1, r2)
352 # define andi(r0, r1, im) _andi(_jit, r0, r1, im)
353 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
354 # define orr(r0, r1, r2) OR(r0, r1, r2)
355 # define ori(r0, r1, im) _ori(_jit, r0, r1, im)
356 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
357 # define xorr(r0, r1, r2) XOR(r0, r1, r2)
358 # define xori(r0, r1, im) _xori(_jit, r0, r1, im)
359 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
360 # define ldr_c(r0, r1) LB(r0, r1, 0)
361 # define ldi_c(r0, im) _ldi_c(_jit, r0, im)
362 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
363 # define ldr_uc(r0, r1) LBU(r0, r1, 0)
364 # define ldi_uc(r0, im) _ldi_uc(_jit, r0, im)
365 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
366 # define ldr_s(r0, r1) LH(r0, r1, 0)
367 # define ldi_s(r0, im) _ldi_s(_jit, r0, im)
368 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
369 # define ldr_us(r0, r1) LHU(r0, r1, 0)
370 # define ldi_us(r0, im) _ldi_us(_jit, r0, im)
371 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
372 # define ldr_i(r0, r1) LW(r0, r1, 0)
373 # define ldi_i(r0, im) _ldi_i(_jit, r0, im)
374 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
375 # define ldr_ui(r0, r1) LWU(r0, r1, 0)
376 # define ldi_ui(r0, im) _ldi_ui(_jit, r0, im)
377 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
378 # define ldr_l(r0, r1) LD(r0, r1, 0)
379 # define ldi_l(r0, im) _ldi_l(_jit, r0, im)
380 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
381 # define ldxr_c(r0, r1, r2) _ldxr_c(_jit, r0, r1, r2)
382 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
383 # define ldxi_c(r0, r1, im) _ldxi_c(_jit, r0, r1, im)
384 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
385 # define ldxr_uc(r0, r1, r2) _ldxr_uc(_jit, r0, r1, r2)
386 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
387 # define ldxi_uc(r0, r1, im) _ldxi_uc(_jit, r0, r1, im)
388 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
389 # define ldxr_s(r0, r1, r2) _ldxr_s(_jit, r0, r1, r2)
390 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
391 # define ldxi_s(r0, r1, im) _ldxi_s(_jit, r0, r1, im)
392 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
393 # define ldxr_us(r0, r1, r2) _ldxr_us(_jit, r0, r1, r2)
394 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
395 # define ldxi_us(r0, r1, im) _ldxi_us(_jit, r0, r1, im)
396 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
397 # define ldxr_i(r0, r1, r2) _ldxr_i(_jit, r0, r1, r2)
398 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
399 # define ldxi_i(r0, r1, im) _ldxi_i(_jit, r0, r1, im)
400 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
401 # define ldxr_ui(r0, r1, r2) _ldxr_ui(_jit, r0, r1, r2)
402 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
403 # define ldxi_ui(r0, r1, im) _ldxi_ui(_jit, r0, r1, im)
404 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
405 # define ldxr_l(r0, r1, r2) _ldxr_l(_jit, r0, r1, r2)
406 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
407 # define ldxi_l(r0, r1, im) _ldxi_l(_jit, r0, r1, im)
408 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
409 # define str_c(r0, r1) SB(r0, r1, 0)
410 # define sti_c(im, r0) _sti_c(_jit, im, r0)
411 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
412 # define str_s(r0, r1) SH(r0, r1, 0)
413 # define sti_s(im, r0) _sti_s(_jit, im, r0)
414 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
415 # define str_i(r0, r1) SW(r0, r1, 0)
416 # define sti_i(im, r0) _sti_i(_jit, im, r0)
417 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
418 # define str_l(r0, r1) SD(r0, r1, 0)
419 # define sti_l(im, r0) _sti_l(_jit, im, r0)
420 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
421 # define stxr_c(r0, r1, r2) _stxr_c(_jit, r0, r1, r2)
422 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
423 # define stxi_c(i0, r0, r1) _stxi_c(_jit, i0, r0, r1)
424 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
425 # define stxr_s(r0, r1, r2) _stxr_s(_jit, r0, r1, r2)
426 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
427 # define stxi_s(i0, r0, r1) _stxi_s(_jit, i0, r0, r1)
428 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
429 # define stxr_i(r0, r1, r2) _stxr_i(_jit, r0, r1, r2)
430 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
431 # define stxi_i(i0, r0, r1) _stxi_i(_jit, i0, r0, r1)
432 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
433 # define stxr_l(r0, r1, r2) _stxr_l(_jit, r0, r1, r2)
434 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
435 # define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1)
436 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
437 # define bswapr_us(r0, r1) generic_bswapr_us(_jit, r0, r1)
438 # define bswapr_ui(r0, r1) generic_bswapr_ui(_jit, r0, r1)
439 # define bswapr_ul(r0, r1) generic_bswapr_ul(_jit, r0, r1)
440 # define extr_c(r0, r1) _extr_c(_jit, r0, r1)
441 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
442 # define extr_uc(r0, r1) andi(r0, r1, 0xff)
443 # define extr_s(r0, r1) _extr_s(_jit, r0, r1)
444 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
445 # define extr_us(r0, r1) _extr_us(_jit, r0, r1)
446 static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
447 # define extr_i(r0, r1) SEXT_W(r0, r1)
448 # define extr_ui(r0, r1) _extr_ui(_jit, r0, r1)
449 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
450 # define movr(r0, r1) MV(r0, r1)
451 # define movi(r0, im) _movi(_jit, r0, im)
452 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
453 # define movi_p(r0, im) _movi_p(_jit, r0, im)
454 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
455 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
456 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
457 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
458 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
459 # define ltr(r0, r1, r2) SLT(r0, r1, r2)
460 # define lti(r0, r1, im) _lti(_jit, r0, r1, im)
461 static 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)
464 static 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)
466 static 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)
468 static 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)
470 static 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)
472 static 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)
474 static 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)
476 static 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)
478 static 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)
480 static 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)
482 static 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)
484 static 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)
487 static 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)
490 static 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)
492 static 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)
494 static 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)
496 static 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)
498 static 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)
500 static 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)
502 static 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)
504 static 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)
506 static 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)
508 static 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)
510 static 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)
512 static 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)
514 static 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)
516 static 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)
518 static 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)
520 static 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)
522 static 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)
524 static 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)
526 static 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)
528 static 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)
530 static 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)
532 static 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)
534 static 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)
537 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
538 static 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)
541 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
542 static 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)
545 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
546 static 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)
549 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
550 static 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)
553 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
554 static 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)
557 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
558 static 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)
561 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
562 static 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)
565 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
566 static 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)
569 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
570 static 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)
573 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
574 static 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)
577 static void _jmpi(jit_state_t*,jit_word_t);
578 # define jmpi_p(im) _jmpi_p(_jit, im)
579 static 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)
582 static void _calli(jit_state_t*,jit_word_t);
583 # define calli_p(im) _calli_p(_jit, im)
584 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
585 # define prolog(i0) _prolog(_jit,i0)
586 static void _prolog(jit_state_t*,jit_node_t*);
587 # define epilog(i0) _epilog(_jit,i0)
588 static void _epilog(jit_state_t*,jit_node_t*);
589 # define vastart(r0) _vastart(_jit, r0)
590 static void _vastart(jit_state_t*, jit_int32_t);
591 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
592 static 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)
595 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
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)
604 assert(!(op & ~0x7f));
605 assert(!(rd & ~0x1f));
606 assert(!(fct & ~0x07));
607 assert(!(rs1 & ~0x1f));
608 assert(!(rs2 & ~0x1f));
609 assert(!(fct2 & ~0x7f));
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)
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));
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)
646 assert(!(op & ~0x7f));
647 assert(!(rd & ~0x1f));
648 assert(!(fct & ~0x07));
649 assert(!(rs1 & ~0x1f));
650 assert(simm12_p(imm));
659 # if __WORDSIZE == 64
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)
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));
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)
686 assert(!(op & ~0x7f));
687 assert(!(fct & ~0x07));
688 assert(!(rs1 & ~0x1f));
689 assert(!(rs2 & ~0x1f));
690 assert(simm12_p(imm));
692 i.S.imm4_0 = imm & 0x1f;
696 i.S.imm11_5 = (imm >> 5) & 0x7f;
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)
705 assert(!(op & ~0x7f));
706 assert(!(fct & ~0x07));
707 assert(!(rs1 & ~0x1f));
708 assert(!(rs2 & ~0x1f));
709 assert(!(imm & 1) && simm12_p(imm));
711 i.B.imm11 = (imm >> 11) & 0x1;
712 i.B.imm4_1 = (imm >> 1) & 0xf;
716 i.B.imm10_5 = (imm >> 5) & 0x3f;
717 i.B.imm12 = (imm >> 12) & 0x1;
722 _Utype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
725 assert(!(op & ~0x7f));
726 assert(!(rd & ~0x1f));
727 assert(simm20_p(imm));
735 _Jtype(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd, jit_int32_t imm)
738 assert(!(op & ~0x7f));
739 assert(!(rd & ~0x1f));
740 assert(!(imm & 1) && imm <= 1048575 && imm >= -1048576);
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;
751 _nop(jit_state_t *_jit, jit_int32_t im)
753 for (; im > 0; im -= 4)
759 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
765 t0 = jit_get_reg(jit_class_gpr);
767 addr(r0, r1, rn(t0));
773 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
776 if (jit_carry == _NOREG)
777 jit_carry = jit_get_reg(jit_class_gpr);
779 t0 = jit_get_reg(jit_class_gpr);
780 addr(rn(t0), r1, r2);
781 SLTU(rn(jit_carry), rn(t0), r1);
787 SLTU(rn(jit_carry), r0, r1);
792 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
795 if (jit_carry == _NOREG)
796 jit_carry = jit_get_reg(jit_class_gpr);
798 t0 = jit_get_reg(jit_class_gpr);
799 addi(rn(t0), r1, i0);
800 SLTU(rn(jit_carry), rn(t0), r1);
806 SLTU(rn(jit_carry), r0, r1);
811 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
814 assert(jit_carry != _NOREG);
815 t0 = jit_get_reg(jit_class_gpr);
816 movr(rn(t0), rn(jit_carry));
818 addcr(r0, r0, rn(t0));
823 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
826 assert(jit_carry != _NOREG);
827 t0 = jit_get_reg(jit_class_gpr);
828 movr(rn(t0), rn(jit_carry));
830 addcr(r0, r0, rn(t0));
835 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
841 t0 = jit_get_reg(jit_class_gpr);
843 subr(r0, r1, rn(t0));
849 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
852 if (jit_carry == _NOREG)
853 jit_carry = jit_get_reg(jit_class_gpr);
855 t0 = jit_get_reg(jit_class_gpr);
856 subr(rn(t0), r1, r2);
857 SLTU(rn(jit_carry), r1, rn(t0));
863 SLTU(rn(jit_carry), r1, r0);
868 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
871 if (jit_carry == _NOREG)
872 jit_carry = jit_get_reg(jit_class_gpr);
874 t0 = jit_get_reg(jit_class_gpr);
875 subi(rn(t0), r1, i0);
876 SLTU(rn(jit_carry), r1, rn(t0));
882 SLTU(rn(jit_carry), r1, r0);
887 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
890 assert(jit_carry != _NOREG);
891 t0 = jit_get_reg(jit_class_gpr);
892 movr(rn(t0), rn(jit_carry));
894 subcr(r0, r0, rn(t0));
899 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
902 assert(jit_carry != _NOREG);
903 t0 = jit_get_reg(jit_class_gpr);
904 movr(rn(t0), rn(jit_carry));
906 subcr(r0, r0, rn(t0));
911 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
918 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
921 t0 = jit_get_reg(jit_class_gpr);
923 mulr(r0, r1, rn(t0));
928 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
931 t0 = jit_get_reg(jit_class_gpr);
933 divr(r0, r1, rn(t0));
938 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
941 t0 = jit_get_reg(jit_class_gpr);
943 divr_u(r0, r1, rn(t0));
948 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
951 t0 = jit_get_reg(jit_class_gpr);
953 remr(r0, r1, rn(t0));
958 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
961 t0 = jit_get_reg(jit_class_gpr);
963 remr_u(r0, r1, rn(t0));
968 _qmulr(jit_state_t *_jit, jit_int32_t r0,
969 jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
972 if (r0 == r2 || r0 == r3) {
973 t0 = jit_get_reg(jit_class_gpr);
974 mulr(rn(t0), r2, r3);
979 if (r0 == r2 || r0 == r3) {
986 _qmuli(jit_state_t *_jit, jit_int32_t r0,
987 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
990 t0 = jit_get_reg(jit_class_gpr);
992 qmulr(r0, r1, r2, rn(t0));
997 _qmulr_u(jit_state_t *_jit, jit_int32_t r0,
998 jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1001 if (r0 == r2 || r0 == r3) {
1002 t0 = jit_get_reg(jit_class_gpr);
1003 mulr(rn(t0), r2, r3);
1008 if (r0 == r2 || r0 == r3) {
1015 _qmuli_u(jit_state_t *_jit, jit_int32_t r0,
1016 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1019 t0 = jit_get_reg(jit_class_gpr);
1021 qmulr_u(r0, r1, r2, rn(t0));
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)
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);
1037 if (r1 == r2 || r1 == r3) {
1038 sv1 = jit_get_reg(jit_class_gpr);
1046 divr_u(rg0, r2, r3);
1060 _qdivi(jit_state_t *_jit, jit_int32_t r0,
1061 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1064 t0 = jit_get_reg(jit_class_gpr);
1066 qdivr(r0, r1, r2, rn(t0));
1071 _qdivi_u(jit_state_t *_jit, jit_int32_t r0,
1072 jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1075 t0 = jit_get_reg(jit_class_gpr);
1077 qdivr_u(r0, r1, r2, rn(t0));
1082 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1087 assert(i0 > 0 && i0 < 64);
1093 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1098 assert(i0 > 0 && i0 < 64);
1104 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1109 assert(i0 > 0 && i0 < 64);
1115 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1121 t0 = jit_get_reg(jit_class_gpr);
1123 andr(r0, r1, rn(t0));
1129 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1135 t0 = jit_get_reg(jit_class_gpr);
1137 orr(r0, r1, rn(t0));
1143 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1149 t0 = jit_get_reg(jit_class_gpr);
1151 xorr(r0, r1, rn(t0));
1156 # define DEFLD(T,O) \
1158 _ldi_##T(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0) \
1161 L##O(r0, _ZERO_REGNO, i0); \
1164 t0 = jit_get_reg(jit_class_gpr); \
1166 ldr_##T(r0, rn(t0)); \
1167 jit_unget_reg(t0); \
1172 _ldxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
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); \
1182 _ldxi_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)\
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); \
1203 # define DEFST(T, O) \
1205 _sti_##T(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0) \
1208 S##O(_ZERO_REGNO, r0, i0); \
1211 t0 = jit_get_reg(jit_class_gpr); \
1213 str_##T(rn(t0), r0); \
1214 jit_unget_reg(t0); \
1219 _stxr_##T(jit_state_t *_jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)\
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); \
1229 _stxi_##T(jit_state_t *_jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)\
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); \
1248 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1255 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1262 _extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1269 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1276 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1279 jit_int32_t lo = (jit_int32_t)i0 << 20 >> 20;
1280 jit_int32_t hi = i0 - lo;
1287 ADDIW(r0, _ZERO_REGNO, lo);
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));
1295 lshi(rn(t0), rn(t0), 32);
1296 addr(r0, r0, rn(t0));
1302 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1306 jit_int32_t ww = i0 << 32 >> 32;
1307 jit_int32_t lo = ww << 20 >> 20;
1308 jit_int32_t hi = ww - lo;
1310 t0 = jit_get_reg(jit_class_gpr);
1314 lo = ww << 20 >> 20;
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));
1325 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1328 w = beqi(_jit->pc.w, r2, 0);
1330 patch_at(w, _jit->pc.w);
1334 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1337 w = bnei(_jit->pc.w, r2, 0);
1339 patch_at(w, _jit->pc.w);
1343 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1349 t0 = jit_get_reg(jit_class_gpr);
1351 ltr(r0, r1, rn(t0));
1357 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1363 t0 = jit_get_reg(jit_class_gpr);
1365 ltr_u(r0, r1, rn(t0));
1371 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1378 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1382 SLT(r0, _ZERO_REGNO, r1);
1386 t0 = jit_get_reg(jit_class_gpr);
1388 ler(r0, r1, rn(t0));
1394 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1401 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1405 SLTU(r0, _ZERO_REGNO, r1);
1409 t0 = jit_get_reg(jit_class_gpr);
1411 ler_u(r0, r1, rn(t0));
1417 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1420 SLTU(r0, _ZERO_REGNO, r0);
1425 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1429 SLTU(r0, _ZERO_REGNO, r0);
1432 SLTU(r0, _ZERO_REGNO, r1);
1437 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1444 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1447 t0 = jit_get_reg(jit_class_gpr);
1449 ger(r0, r1, rn(t0));
1454 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1461 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1464 t0 = jit_get_reg(jit_class_gpr);
1466 ger_u(r0, r1, rn(t0));
1471 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1474 t0 = jit_get_reg(jit_class_gpr);
1476 ltr(r0, rn(t0), r1);
1481 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1484 t0 = jit_get_reg(jit_class_gpr);
1486 ltr_u(r0, rn(t0), r1);
1491 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1494 SLTU(r0, _ZERO_REGNO, r0);
1498 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1502 SLTU(r0, _ZERO_REGNO, r0);
1505 SLTU(r0, _ZERO_REGNO, r1);
1509 _bltr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1513 BLT(r0, r1, br - w);
1518 _blti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1522 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1524 w = bltr(br, r0, rn(t0));
1530 _bltr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1534 BLTU(r0, r1, br - w);
1539 _blti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1543 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1545 w = bltr_u(br, r0, rn(t0));
1551 _bler(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1555 BGE(r1, r0, br - w);
1560 _blei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1564 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1566 w = bler(br, r0, rn(t0));
1572 _bler_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1576 BGEU(r1, r0, br - w);
1581 _blei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1585 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1587 w = bler_u(br, r0, rn(t0));
1593 _beqr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1597 BEQ(r1, r0, br - w);
1602 _beqi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1606 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1608 w = beqr(br, r0, rn(t0));
1614 _bger(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1618 BGE(r0, r1, br - w);
1623 _bgei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1627 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1629 w = bger(br, r0, rn(t0));
1635 _bger_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1639 BGEU(r0, r1, br - w);
1644 _bgei_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1648 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1650 w = bger_u(br, r0, rn(t0));
1656 _bgtr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1660 BLT(r1, r0, br - w);
1665 _bgti(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1669 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1671 w = bgtr(br, r0, rn(t0));
1677 _bgtr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1681 BLTU(r1, r0, br - w);
1686 _bgti_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1690 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1692 w = bgtr_u(br, r0, rn(t0));
1698 _bner(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1702 BNE(r1, r0, br - w);
1707 _bnei(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1711 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1713 w = bner(br, r0, rn(t0));
1719 _boaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1723 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1724 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1726 SLT(rn(t0), r1, _ZERO_REGNO);
1731 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1733 BNE(rn(t0), _ZERO_REGNO, 0);
1735 SLT(rn(t1), r0, rn(t1));
1737 JAL(_ZERO_REGNO, 0);
1739 patch_at(w, _jit->pc.w);
1740 SLT(rn(t1), rn(t1), r0);
1742 patch_at(jal, _jit->pc.w);
1744 BNE(rn(t1), _ZERO_REGNO, br - w);
1751 _boaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1755 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1757 w = boaddr(br, r0, rn(t0));
1763 _boaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
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);
1773 BNE(_ZERO_REGNO, rn(t1), br - w);
1780 _boaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1784 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1786 w = boaddr_u(br, r0, rn(t0));
1792 _bxaddr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1796 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1797 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1799 SLT(rn(t0), r1, _ZERO_REGNO);
1804 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1806 BNE(rn(t0), _ZERO_REGNO, 0);
1808 SLT(rn(t1), r0, rn(t1));
1810 JAL(_ZERO_REGNO, 0);
1812 patch_at(w, _jit->pc.w);
1813 SLT(rn(t1), rn(t1), r0);
1815 patch_at(jal, _jit->pc.w);
1817 BEQ(rn(t1), _ZERO_REGNO, br - w);
1824 _bxaddi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1828 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1830 w = bxaddr(br, r0, rn(t0));
1836 _bxaddr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
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);
1846 BEQ(_ZERO_REGNO, rn(t1), br - w);
1853 _bxaddi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1857 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1859 w = bxaddr_u(br, r0, rn(t0));
1865 _bosubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1869 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1870 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1872 SLT(rn(t0), _ZERO_REGNO, r1);
1877 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1879 BNE(rn(t0), _ZERO_REGNO, 0);
1881 SLT(rn(t1), r0, rn(t1));
1883 JAL(_ZERO_REGNO, 0);
1885 patch_at(w, _jit->pc.w);
1886 SLT(rn(t1), rn(t1), r0);
1888 patch_at(jal, _jit->pc.w);
1890 BNE(rn(t1), _ZERO_REGNO, br - w);
1897 _bosubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1901 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1903 w = bosubr(br, r0, rn(t0));
1909 _bosubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
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));
1919 BNE(_ZERO_REGNO, rn(t1), br - w);
1926 _bosubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1930 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1932 w = bosubr_u(br, r0, rn(t0));
1938 _bxsubr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
1942 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1943 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1945 SLT(rn(t0), _ZERO_REGNO, r1);
1950 /* overflow = r1 < 0 ? t1 < r0 : r0 < t1 */
1952 BNE(rn(t0), _ZERO_REGNO, 0);
1954 SLT(rn(t1), r0, rn(t1));
1956 JAL(_ZERO_REGNO, 0);
1958 patch_at(w, _jit->pc.w);
1959 SLT(rn(t1), rn(t1), r0);
1961 patch_at(jal, _jit->pc.w);
1963 BEQ(rn(t1), _ZERO_REGNO, br - w);
1970 _bxsubi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
1974 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
1976 w = bxsubr(br, r0, rn(t0));
1982 _bxsubr_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
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));
1992 BEQ(_ZERO_REGNO, rn(t1), br - w);
1999 _bxsubi_u(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2003 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2005 w = bxsubr_u(br, r0, rn(t0));
2011 _bmsr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2015 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2016 AND(rn(t0), r0, r1);
2018 BNE(_ZERO_REGNO, rn(t0), br - w);
2024 _bmsi(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2028 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2030 w = bmsr(br, r0, rn(t0));
2036 _bmcr(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_int32_t r1)
2040 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2041 AND(rn(t0), r0, r1);
2043 BEQ(_ZERO_REGNO, rn(t0), br - w);
2049 _bmci(jit_state_t *_jit, jit_word_t br, jit_int32_t r0, jit_word_t i0)
2053 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2055 w = bmcr(br, r0, rn(t0));
2061 _jmpi(jit_state_t *_jit, jit_word_t i0)
2065 dsp = i0 - _jit->pc.w;
2067 JAL(_ZERO_REGNO, dsp);
2069 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2077 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
2081 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2082 w = movi_p(rn(t0), i0);
2089 _calli(jit_state_t *_jit, jit_word_t i0)
2093 dsp = i0 - _jit->pc.w;
2095 JAL(_RA_REGNO, dsp);
2097 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2105 _calli_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 _prolog(jit_state_t *_jit, jit_node_t *node)
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)
2125 _jitc->function->self.aoff = frame;
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));
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));
2198 _epilog(jit_state_t *_jit, jit_node_t *node)
2200 if (_jitc->function->assume_frame)
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);
2256 _vastart(jit_state_t *_jit, jit_int32_t r0)
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));
2263 addi(r0, _FP_REGNO, _jitc->function->self.size);
2267 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2269 assert(_jitc->function->self.call & jit_call_varargs);
2270 /* Load argument. */
2272 /* Update va_list. */
2273 addi(r1, r1, sizeof(jit_word_t));
2277 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
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;
2294 if (i.I.opcode == 27 && i.I.funct3 == 0) { /* ADDIW */
2295 i.I.imm11_0 = lo & 0xfff;
2298 if (i.U.opcode == 55) { /* LUI */
2300 lo = ww << 20 >> 20;
2302 i.U.imm12_31 = hi >> 12;
2305 if (i.I.opcode == 27 && i.I.funct3 == 0) { /* ADDIW */
2306 i.I.imm11_0 = lo & 0xfff;
2309 assert(i.IS.opcode == 19); /* SLLI */
2310 assert(i.IS.shamt == 32);
2312 assert(i.R.opcode == 51); /* ADD */
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;
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;