2 * Copyright (C) 2012-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
17 * Paulo Cesar Pereira de Andrade
21 /* FIXME Should need qemu 7.2 -- apparently broken with qemu 7.0 */
22 #define PCREL_BROKEN 1
26 #if __BYTE_ORDER == __LITTLE_ENDIAN
27 struct { jit_uint32_t _:26; jit_uint32_t b : 6; } hc;
28 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } rs;
29 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fm;
30 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fr;
31 struct { jit_uint32_t _:18; jit_uint32_t b : 3; } pD;
32 struct { jit_uint32_t _:19; jit_uint32_t b : 2; } pW;
33 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rt;
34 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } ft;
35 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rd;
36 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } fs;
37 struct { jit_uint32_t _: 7; jit_uint32_t b : 9; } i9;
38 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } ic;
39 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fd;
40 struct { jit_uint32_t b : 6; } tc;
41 struct { jit_uint32_t b : 5; } cn;
42 struct { jit_uint32_t b : 11; } cc;
43 struct { jit_uint32_t b : 16; } is;
44 struct { jit_uint32_t b : 18; } iD;
45 struct { jit_uint32_t b : 19; } iW;
46 struct { jit_uint32_t b : 26; } ii;
48 struct { jit_uint32_t b : 6; } hc;
49 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } rs;
50 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fm;
51 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fr;
52 struct { jit_uint32_t _:11; jit_uint32_t b : 3; } pD;
53 struct { jit_uint32_t _:11; jit_uint32_t b : 2; } pW;
54 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rt;
55 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } ft;
56 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rd;
57 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } fs;
58 struct { jit_uint32_t _:16; jit_uint32_t b : 9; } i9;
59 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } ic;
60 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fd;
61 struct { jit_uint32_t _:26; jit_uint32_t b : 6; } tc;
62 struct { jit_uint32_t _:27; jit_uint32_t b : 5; } cn;
63 struct { jit_uint32_t _:21; jit_uint32_t b : 11; } cc;
64 struct { jit_uint32_t _:16; jit_uint32_t b : 16; } is;
65 struct { jit_uint32_t _:14; jit_uint32_t b : 18; } iD;
66 struct { jit_uint32_t _:13; jit_uint32_t b : 19; } iW;
67 struct { jit_uint32_t _: 6; jit_uint32_t b : 26; } ii;
71 #define jit_mips2_p() (jit_cpu.release >= 2)
72 #define jit_mips6_p() (jit_cpu.release >= 6)
73 #define jit_unaligned_p() (jit_cpu.unaligned)
74 # define _ZERO_REGNO 0
75 # define _T0_REGNO 0x08
76 # define _T1_REGNO 0x09
77 # define _T2_REGNO 0x0a
78 # define _T3_REGNO 0x0b
79 # define _T4_REGNO 0x0c
80 # define _T5_REGNO 0x0d
81 # define _T6_REGNO 0x0e
82 # define _T7_REGNO 0x0f
83 # define _S0_REGNO 0x10
84 # define _S1_REGNO 0x11
85 # define _S2_REGNO 0x12
86 # define _S3_REGNO 0x13
87 # define _S4_REGNO 0x14
88 # define _S5_REGNO 0x15
89 # define _S6_REGNO 0x16
90 # define _S7_REGNO 0x17
91 # define _T8_REGNO 0x18
92 # define _T9_REGNO 0x19
93 # define _SP_REGNO 0x1d
94 # define _BP_REGNO 0x1e
95 # define _RA_REGNO 0x1f
96 # define _F16_REGNO 16
97 # define _F18_REGNO 18
98 # define _F20_REGNO 20
99 # define _F22_REGNO 22
100 # define _F24_REGNO 24
101 # define _F26_REGNO 26
102 # define _F28_REGNO 28
103 # define _F30_REGNO 30
104 # if __WORDSIZE == 32
105 # define ldr(u,v) ldr_i(u,v)
106 # define ldi(u,v) ldi_i(u,v)
107 # define ldxr(u,v,w) ldxr_i(u,v,w)
108 # define ldxi(u,v,w) ldxi_i(u,v,w)
109 # define str(u,v) str_i(u,v)
110 # define sti(u,v) sti_i(u,v)
111 # define stxr(u,v,w) stxr_i(u,v,w)
112 # define stxi(u,v,w) stxi_i(u,v,w)
114 # define ldr(u,v) ldr_l(u,v)
115 # define ldi(u,v) ldi_l(u,v)
116 # define ldxr(u,v,w) ldxr_l(u,v,w)
117 # define ldxi(u,v,w) ldxi_l(u,v,w)
118 # define str(u,v) str_l(u,v)
119 # define sti(u,v) sti_l(u,v)
120 # define stxr(u,v,w) stxr_l(u,v,w)
121 # define stxi(u,v,w) stxi_l(u,v,w)
123 /* can_relative_jump_p(im) => can_sign_extend_short_p(im << 2) */
124 # define can_relative_jump_p(im) ((im) >= -130712 && (im) <= 131068)
125 /* can_compact_jump_p(im) => can_sign_extend_i26_p(im << 2) */
126 # define can_compact_jump_p(im) ((im) >= -268435456 && (im) <= 268435452)
127 # define can_sign_extend_short_p(im) ((im) >= -32768 && (im) <= 32767)
128 # define can_zero_extend_short_p(im) ((im) >= 0 && (im) <= 65535)
129 # define can_sign_extend_i18_p(im) ((im) >= -262144 && (im) <= 262143)
130 # define can_sign_extend_i19_p(im) ((im) >= -524288 && (im) <= 524287)
131 # define can_sign_extend_i26_p(im) ((im) >= -67108864 && (im) <= 67108863)
132 # define is_low_mask(im) (((im) & 1) ? (__builtin_popcountl((im) + 1) <= 1) : 0)
133 # define is_middle_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
134 # define is_high_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) == 0) : 0)
135 # define masked_bits_count(im) __builtin_popcountl(im)
136 # define unmasked_bits_count(im) (__WORDSIZE - masked_bits_count(im))
137 # if __WORDSIZE == 32
138 # define can_sign_extend_int_p(im) 1
139 # define can_zero_extend_int_p(im) 1
141 # define can_sign_extend_int_p(im) \
142 (((im) >= 0 && (im) <= 0x7fffffffL) || \
143 ((im) < 0 && (im) >= -0x80000000L))
144 # define can_zero_extend_int_p(im) ((im) >= 0 && (im) <= 0xffffffff)
146 # define MIPS_SPECIAL 0x00
147 # define MIPS_REGIMM 0x01
149 # define MIPS_SRL 0x02
150 # define MIPS_JAL 0x03
151 # define MIPS_SRA 0x03
152 # define MIPS_BEQ 0x04
153 # define MIPS_BNE 0x05
154 # define MIPS_BLEZ 0x06
155 # define MIPS_BGTZ 0x07
156 # define MIPS_ADDI 0x08
157 # define MIPS_ADDIU 0x09
158 # define MIPS_SLTI 0x0a
159 # define MIPS_SLTIU 0x0b
160 # define MIPS_ANDI 0x0c
161 # define MIPS_ORI 0x0d
162 # define MIPS_XORI 0x0e
163 # define MIPS_LUI 0x0f
164 # define MIPS_COP0 0x10
165 # define MIPS_COP1 0x11
166 # define MIPS_COP2 0x12
167 # define MIPS_COP1X 0x13
168 # define MIPS_BEQL 0x14
169 # define MIPS_BNEL 0x15
170 # define MIPS_BLEZL 0x16
171 # define MIPS_BGTZL 0x17
172 # define MIPS_DADDI 0x18
173 # define MIPS_DADDIU 0x19
174 # define MIPS_LDL 0x1a
175 # define MIPS_LDR 0x1b
176 # define MIPS_SPECIAL2 0x1c
177 # define MIPS_JALX 0x1d
178 # define MIPS_DAUI 0x1d
179 # define MIPS_SPECIAL3 0x1f
180 # define MIPS_LB 0x20
181 # define MIPS_LH 0x21
182 # define MIPS_LWL 0x22
183 # define MIPS_LW 0x23
184 # define MIPS_LBU 0x24
185 # define MIPS_LHU 0x25
186 # define MIPS_LWR 0x26
187 # define MIPS_LWU 0x27
188 # define MIPS_SB 0x28
189 # define MIPS_SH 0x29
190 # define MIPS_SWL 0x2a
191 # define MIPS_SW 0x2b
192 # define MIPS_SDL 0x2c
193 # define MIPS_SDR 0x2d
194 # define MIPS_SWR 0x2e
195 # define MIPS_CACHE 0x2f
196 # define MIPS_LL 0x30
197 # define MIPS_LWC1 0x31
198 # define MIPS_LWC2 0x32
199 # define MIPS_PREF 0x33
200 # define MIPS_LLD 0x34
201 # define MIPS_LDC1 0x35
202 # define MIPS_LDC2 0x36
203 # define MIPS_LD 0x37
204 # define MIPS_SC 0x38
205 # define MIPS_BC_R6 0x32
206 # define MIPS_BALC 0x3a
207 # define MIPS_PCREL 0x3b
208 # define MIPS_SCD 0x3c
209 # define MIPS_SDC1 0x3d
210 # define MIPS_SDC2 0x3e
211 # define MIPS_SWC1 0x39
212 # define MIPS_SWC2 0x3a
213 # define MIPS_SD 0x3f
214 # define MIPS_MF 0x00
215 # define MIPS_DMF 0x01
216 # define MIPS_CF 0x02
217 # define MIPS_MFH 0x03
218 # define MIPS_MT 0x04
219 # define MIPS_DMT 0x05
220 # define MIPS_CT 0x06
221 # define MIPS_MTH 0x07
222 # define MIPS_BC 0x08
223 # define MIPS_BC1EQZ 0x09 /* release 6 */
224 # define MIPS_BC1NEZ 0x0d /* release 6 */
225 # define MIPS_WRPGPR 0x0e
226 # define MIPS_BGZAL 0x11
227 # define MIPS_MFMC0 0x11
228 # define MIPS_BCF 0x00
229 # define MIPS_BLTZ 0x00
230 # define MIPS_BCT 0x01
231 # define MIPS_BGEZ 0x01
232 # define MIPS_BCFL 0x02
233 # define MIPS_BLTZL 0x02
234 # define MIPS_BCTL 0x03
235 # define MIPS_BGEZL 0x03
236 # define MIPS_TGEI 0x08
237 # define MIPS_TGEIU 0x09
238 # define MIPS_TLTI 0x0a
239 # define MIPS_TLTIU 0x0b
240 # define MIPS_TEQI 0x0c
241 # define MIPS_TNEI 0x0e
242 # define MIPS_BLTZAL 0x10
243 # define MIPS_BGEZAL 0x11
244 # define MIPS_BLTZALL 0x12
245 # define MIPS_BGEZALL 0x13
246 # define MIPS_SYNCI 0x1f
247 # define MIPS_WSBH 0x02
248 # define MIPS_DSBH 0x02
249 # define MIPS_DSHD 0x05
250 # define MIPS_SEB 0x10
251 # define MIPS_SEH 0x18
252 # define MIPS_MADD 0x00
253 # define MIPS_SLL 0x00
254 # define MIPS_EXT 0x00
255 # define MIPS_DEXTM 0x01
256 # define MIPS_MADDU 0x01
257 # define MIPS_MOVFT 0x01
258 # define MIPS_TLBR 0x01
259 # define MIPS_MUL 0x02
260 # define MIPS_DEXTU 0x02
261 # define MIPS_TLBWI 0x02
262 # define MIPS_DEXT 0x03
263 # define MIPS_SLLV 0x04
264 # define MIPS_INS 0x04
265 # define MIPS_MSUB 0x04
266 # define MIPS_DINSM 0x05
267 # define MIPS_MSUBU 0x05
268 # define MIPS_SRLV 0x06
269 # define MIPS_DINSU 0x06
270 # define MIPS_TLBWR 0x06
271 # define MIPS_SRAV 0x07
272 # define MIPS_DINS 0x07
273 # define MIPS_JR 0x08
274 # define MIPS_TLBP 0x08
275 # define MIPS_JALR 0x09
276 # define MIPS_MOVZ 0x0a
277 # define MIPS_MOVN 0x0b
278 # define MIPS_SYSCALL 0x0c
279 # define MIPS_BREAK 0x0d
280 # define MIPS_PREFX 0x0f
281 # define MIPS_SYNC 0x0f
282 # define MIPS_MFHI 0x10
283 # define MIPS_MTHI 0x11
284 # define MIPS_MFLO 0x12
285 # define MIPS_MTLO 0x13
286 # define MIPS_DSLLV 0x14
287 # define MIPS_DSRLV 0x16
288 # define MIPS_DSRAV 0x17
289 # define MIPS_MULT 0x18
290 # define MIPS_ERET 0x18
291 # define MIPS_MULTU 0x19
292 # define MIPS_DIV 0x1a
293 # define MIPS_DIVU 0x1b
294 # define MIPS_DMULT 0x1c
295 # define MIPS_DMULTU 0x1d
296 # define MIPS_DDIV 0x1e
297 # define MIPS_DDIVU 0x1f
298 # define MIPS_DERET 0x1f
299 # define MIPS_ADD 0x20
300 # define MIPS_CLZ 0x20
301 # define MIPS_BSHFL 0x20
302 # define MIPS_ADDU 0x21
303 # define MIPS_CLO 0x21
304 # define MIPS_SUB 0x22
305 # define MIPS_SUBU 0x23
306 # define MIPS_AND 0x24
307 # define MIPS_DCLZ 0x24
308 # define MIPS_DBSHFL 0x24
309 # define MIPS_OR 0x25
310 # define MIPS_DCLO 0x25
311 # define MIPS_XOR 0x26
312 # define MIPS_NOR 0x27
313 # define MIPS_SLT 0x2a
314 # define MIPS_SLTU 0x2b
315 # define MIPS_DADD 0x2c
316 # define MIPS_DADDU 0x2d
317 # define MIPS_DSUB 0x2e
318 # define MIPS_DSUBU 0x2f
319 # define MIPS_TGE 0x30
320 # define MIPS_TGEU 0x31
321 # define MIPS_TLT 0x32
322 # define MIPS_TLTU 0x33
323 # define MIPS_TEQ 0x34
324 # define MIPS_TNE 0x36
325 # define MIPS_DSLL 0x38
326 # define MIPS_DSRL 0x3a
327 # define MIPS_DSRA 0x3b
328 # define MIPS_DSLL32 0x3c
329 # define MIPS_DSRL32 0x3e
330 # define MIPS_DSRA32 0x3f
331 # define MIPS_SDBPP 0x3f
332 # define ii(i) *_jit->pc.ui++ = i
333 # define instr(op) _instr(_jit, op)
334 static void _instr(jit_state_t*, jit_int32_t);
335 # define flush() _flush(_jit)
336 static void _flush(jit_state_t*);
337 # define pending() _pending(_jit)
338 static jit_int32_t _pending(jit_state_t*);
339 # define delay(op) _delay(_jit,op)
340 static void _delay(jit_state_t*,jit_int32_t);
341 # define jit_get_reg_for_delay_slot(mask, r0,r1) \
342 _jit_get_reg_for_delay_slot(_jit,mask,r0,r1)
343 static jit_int32_t _jit_get_reg_for_delay_slot(jit_state_t*,jit_int32_t,
344 jit_int32_t, jit_int32_t);
345 # define hrrrit(hc,rs,rt,rd,im,tc) _hrrrit(_jit,hc,rs,rt,rd,im,tc)
347 _hrrrit(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
348 jit_int32_t,jit_int32_t);
349 # define hrrr_t(hc,rs,rt,rd,tc) hrrrit(hc,rs,rt,rd,0,tc)
350 # define rrr_t(rs,rt,rd,tc) hrrr_t(0,rs,rt,rd,tc)
351 # define hrri(hc,rs,rt,im) _hrri(_jit,hc,rs,rt,im)
352 static void _hrri(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
353 # define hrri9(hc,rs,rt,i9,tc) _hrri9(_jit,hc,rs,rt,i9,tc)
354 static void _hrri9(jit_state_t*,jit_int32_t,jit_int32_t,
355 jit_int32_t,jit_int32_t,jit_int32_t);
356 # define hriD(hc,rs,pD,iD) _hriD(_jit,hc,rs,pD,iD)
357 static void _hriD(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
358 # define hriW(hc,rs,pW,iW) _hriW(_jit,hc,rs,pW,iW)
359 static void _hriW(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
360 # define hi(hc,im) _hi(_jit,hc,im)
361 static void _hi(jit_state_t*,jit_int32_t,jit_int32_t);
362 # define NOP(i0) instr(0)
363 # define nop(i0) _nop(_jit,i0)
364 static void _nop(jit_state_t*,jit_int32_t);
365 # define h_ri(hc,rt,im) _hrri(_jit,hc,0,rt,im)
366 # define rrit(rt,rd,im,tc) _hrrrit(_jit,0,0,rt,rd,im,tc)
367 # define AUIPC(rs,im) hrri(MIPS_PCREL,rs,30,im)
368 # define ALUIPC(rs,im) hrri(MIPS_PCREL,rs,31,im)
369 # define ADDIUPC(rs,im) hriW(MIPS_PCREL,rs,0,im)
370 # define LUI(rt,im) h_ri(MIPS_LUI,rt,im)
371 # define AUI(rs,rt) hrri(MIPS_LUI,rs,rt,im) /* mips r6 */
372 # define ADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_ADDU)
373 # define DADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_DADDU)
374 # define ADDIU(rt,rs,im) hrri(MIPS_ADDIU,rs,rt,im)
375 # define DADDIU(rt,rs,im) hrri(MIPS_DADDIU,rs,rt,im)
376 # define SUBU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SUBU)
377 # define DSUBU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_DSUBU)
378 # define MUL(rd,rs,rt) hrrr_t(MIPS_SPECIAL2,rs,rt,rd,MIPS_MUL)
379 # define MULT(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULT)
380 # define MUL_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 24)
381 # define MUH_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 24)
382 # define MULTU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULTU)
383 # define MULU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 25)
384 # define MUHU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 25)
385 # define DMULT(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULT)
386 # define DMUL_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 28)
387 # define DMUH_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 28)
388 # define DMULTU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULTU)
389 # define DMULU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 29)
390 # define DMUHU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 29)
391 # define DIV(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIV)
392 # define DIV_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 26)
393 # define MOD_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 26)
394 # define DIVU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIVU)
395 # define DIVU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 27)
396 # define MODU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 27)
397 # define DDIV(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIV)
398 # define DDIV_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 30)
399 # define DMOD_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 30)
400 # define DDIVU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIVU)
401 # define DDIVU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 2, 31)
402 # define DMODU_R6(rd,rs,rt) hrrrit(MIPS_SPECIAL, rs, rt, rd, 3, 31)
403 # define SLLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SLLV)
404 # define SLL(rd,rt,sa) rrit(rt,rd,sa,MIPS_SLL)
405 # define DSLLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSLLV)
406 # define DSLL(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSLL)
407 # define DSLL32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSLL32)
408 # define SRAV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SRAV)
409 # define SRA(rd,rt,sa) rrit(rt,rd,sa,MIPS_SRA)
410 # define SRLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SRLV)
411 # define SRL(rd,rt,sa) rrit(rt,rd,sa,MIPS_SRL)
412 # define DSRAV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSRAV)
413 # define DSRA(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRA)
414 # define DSRA32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRA32)
415 # define DSRLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSRLV)
416 # define DSRL(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRL)
417 # define DSRL32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRL32)
418 # define INS(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_INS)
419 # define DINS(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_DINS)
420 # define DINSU(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-32-1,pos-32,MIPS_DINSU)
421 # define DINSM(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-32-1,pos,MIPS_DINSM)
422 # define EXT(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_EXT)
423 # define DEXT(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_DEXT)
424 # define DEXTU(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos-32,MIPS_DEXTU)
425 # define DEXTM(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-32-1,pos,MIPS_DEXTM)
426 # define ROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_SRL)
427 # define ROTRV(rd,rt,rs) hrrrit(MIPS_SPECIAL,rs,rt,rd,1,MIPS_SRLV)
428 # define DROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_DSRL)
429 # define DROTR32(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_DSRL32)
430 # define DROTRV(rd,rt,rs) hrrrit(MIPS_SPECIAL,rs,rt,rd,1,MIPS_DSRLV)
431 # define SYNC() rrr_t(_ZERO_REGNO,_ZERO_REGNO,_ZERO_REGNO,MIPS_SYNC)
432 # define MFHI(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFHI)
433 # define MFLO(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFLO)
434 # define MTHI(rs) rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTHI)
435 # define MTLO(rs) rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTLO)
436 # define AND(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_AND)
437 # define ANDI(rt,rs,im) hrri(MIPS_ANDI,rs,rt,im)
438 # define OR(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_OR)
439 # define ORI(rt,rs,im) hrri(MIPS_ORI,rs,rt,im)
440 # define NOR(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_NOR)
441 # define XOR(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_XOR)
442 # define XORI(rt,rs,im) hrri(MIPS_XORI,rs,rt,im)
443 # define LB(rt,of,rb) hrri(MIPS_LB,rb,rt,of)
444 # define LBU(rt,of,rb) hrri(MIPS_LBU,rb,rt,of)
445 # define LH(rt,of,rb) hrri(MIPS_LH,rb,rt,of)
446 # define LHU(rt,of,rb) hrri(MIPS_LHU,rb,rt,of)
447 # define LW(rt,of,rb) hrri(MIPS_LW,rb,rt,of)
448 # define LWPC(rs,im) hriW(MIPS_PCREL,rs,1,im)
449 # define LWU(rt,of,rb) hrri(MIPS_LWU,rb,rt,of)
450 # define LWUPC(rs,im) hriW(MIPS_PCREL,rs,2,im)
451 # define LWL(rt,of,rb) hrri(MIPS_LWL,rb,rt,of)
452 # define LWR(rt,of,rb) hrri(MIPS_LWR,rb,rt,of)
453 # define LD(rt,of,rb) hrri(MIPS_LD,rb,rt,of)
454 # define LDPC(rs,im) hriD(MIPS_PCREL,rs,6,im)
455 # define LL(rt,of,rb) hrri(MIPS_LL,rb,rt,of)
456 # define LL_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,54)
457 # define LLD(rt,of,rb) hrri(MIPS_LLD,rb,rt,of)
458 # define LLD_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,55)
459 # define LDL(rt,of,rb) hrri(MIPS_LDL,rb,rt,of)
460 # define LDR(rt,of,rb) hrri(MIPS_LDR,rb,rt,of)
461 # define SB(rt,of,rb) hrri(MIPS_SB,rb,rt,of)
462 # define SH(rt,of,rb) hrri(MIPS_SH,rb,rt,of)
463 # define SW(rt,of,rb) hrri(MIPS_SW,rb,rt,of)
464 # define SWL(rt,of,rb) hrri(MIPS_SWL,rb,rt,of)
465 # define SWR(rt,of,rb) hrri(MIPS_SWR,rb,rt,of)
466 # define SD(rt,of,rb) hrri(MIPS_SD,rb,rt,of)
467 # define SC(rt,of,rb) hrri(MIPS_SC,rb,rt,of)
468 # define SC_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,38)
469 # define SCD(rt,of,rb) hrri(MIPS_SCD,rb,rt,of)
470 # define SCD_R6(rt,of,rb) hrri9(MIPS_SPECIAL3,rb,rt,of,39)
471 # define SDL(rt,of,rb) hrri(MIPS_SDL,rb,rt,of)
472 # define SDR(rt,of,rb) hrri(MIPS_SDR,rb,rt,of)
473 # define WSBH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_WSBH,MIPS_BSHFL)
474 # define SEB(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEB,MIPS_BSHFL)
475 # define SEH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEH,MIPS_BSHFL)
476 # define DSBH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_DSBH,MIPS_DBSHFL)
477 # define DSHD(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_DSHD,MIPS_DBSHFL)
478 # define SLT(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLT)
479 # define SLTU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLTU)
480 # define SLTI(rt,rs,im) hrri(MIPS_SLTI,rs,rt,im)
481 # define SLTIU(rt,rs,im) hrri(MIPS_SLTIU,rs,rt,im)
482 # define DAUI(rt,rs,im) hrri(MIPS_DAUI,rs,rt,im)
483 # define DAHI(rs,im) hrri(MIPS_REGIMM,rs,6,im)
484 # define DATI(rs,im) hrri(MIPS_REGIMM,rs,30,im)
485 # define BLTZ(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BLTZ,im)
486 # define BLEZ(rs,im) hrri(MIPS_BLEZ,rs,_ZERO_REGNO,im)
487 # define BEQ(rs,rt,im) hrri(MIPS_BEQ,rs,rt,im)
488 # define BGEZ(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BGEZ,im)
489 # define BGTZ(rs,im) hrri(MIPS_BGTZ,rs,_ZERO_REGNO,im)
490 # define BNE(rs,rt,im) hrri(MIPS_BNE,rs,rt,im)
491 # define BGEZAL(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BGEZAL,im)
492 # define JALR(r0) hrrrit(MIPS_SPECIAL,r0,0,_RA_REGNO,0,MIPS_JALR)
493 # if 1 /* This should work for mips r6 or older */
494 # define JR(r0) hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JALR)
495 # else /* This should generate an illegal instruction in mips r6 */
496 # define JR(r0) hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JR)
498 # define CLO_R6(rd,rs) hrrrit(MIPS_SPECIAL,rs,0,rd,1,0x11)
499 # define DCLO_R6(rd,rs) hrrrit(MIPS_SPECIAL,rs,0,rd,1,0x13)
500 # define CLZ_R6(rd,rs) hrrrit(MIPS_SPECIAL,rs,0,rd,1,0x10)
501 # define DCLZ_R6(rd,rs) hrrrit(MIPS_SPECIAL,rs,0,rd,1,0x12)
502 # define BITSWAP(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,0,0x20)
503 # define DBITSWAP(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,0,0x24)
504 # define CLO(rd,rs) hrrrit(MIPS_SPECIAL2,rs,rd,rd,0,MIPS_CLO)
505 # define DCLO(rd,rs) hrrrit(MIPS_SPECIAL2,rs,rd,rd,0,MIPS_DCLO)
506 # define CLZ(rd,rs) hrrrit(MIPS_SPECIAL2,rs,rd,rd,0,MIPS_CLZ)
507 # define DCLZ(rd,rs) hrrrit(MIPS_SPECIAL2,rs,rd,rd,0,MIPS_DCLZ)
508 # define J(i0) hi(MIPS_J,i0)
509 # define JAL(i0) hi(MIPS_JAL,i0)
510 # define BC_R6(i0) hi(MIPS_BC_R6,i0)
511 # define BALC(i0) hi(MIPS_BALC,i0)
512 # define MOVN(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVN)
513 # define MOVZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVZ)
514 # define SELEQZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,53)
515 # define SELNEZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,55)
516 # define comr(r0,r1) xori(r0,r1,-1)
517 # define negr(r0,r1) subr(r0,_ZERO_REGNO,r1)
518 # define clor(r0, r1) _clor(_jit, r0, r1)
519 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
520 # define clzr(r0, r1) _clzr(_jit, r0, r1)
521 static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
522 # define ctor(r0, r1) _ctor(_jit, r0, r1)
523 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
524 # define ctzr(r0, r1) _ctzr(_jit, r0, r1)
525 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
526 # define rbitr(r0, r1) _rbitr(_jit, r0, r1)
527 static void _rbitr(jit_state_t*, jit_int32_t, jit_int32_t);
528 # if __WORDSIZE == 32
529 # define addr(rd,rs,rt) ADDU(rd,rs,rt)
530 # define addiu(r0,r1,i0) ADDIU(r0,r1,i0)
531 # define subr(rd,rs,rt) SUBU(rd,rs,rt)
532 # define mult(rs,rt) MULT(rs,rt)
533 # define mul_r6(rd,rs,rt) MUL_R6(rd,rs,rt)
534 # define muh_r6(rd,rs,rt) MUH_R6(rd,rs,rt)
535 # define multu(rs,rt) MULTU(rs,rt)
536 # define mulu_r6(rd,rs,rt) MULU_R6(rd,rs,rt)
537 # define muhu_r6(rd,rs,rt) MUHU_R6(rd,rs,rt)
538 # define div(rs,rt) DIV(rs,rt)
539 # define divu(rs,rt) DIVU(rs,rt)
540 # define div_r6(rd,rs,rt) DIV_R6(rd,rs,rt)
541 # define divu_r6(rd,rs,rt) DIVU_R6(rd,rs,rt)
542 # define mod_r6(rd,rs,rt) MOD_R6(rd,rs,rt)
543 # define modu_r6(rd,rs,rt) MODU_R6(rd,rs,rt)
545 # define addr(rd,rs,rt) DADDU(rd,rs,rt)
546 # define addiu(r0,r1,i0) DADDIU(r0,r1,i0)
547 # define subr(rd,rs,rt) DSUBU(rd,rs,rt)
548 # define mult(rs,rt) DMULT(rs,rt)
549 # define mul_r6(rd,rs,rt) DMUL_R6(rd,rs,rt)
550 # define muh_r6(rd,rs,rt) DMUH_R6(rd,rs,rt)
551 # define multu(rs,rt) DMULTU(rs,rt)
552 # define mulu_r6(rd,rs,rt) DMULU_R6(rd,rs,rt)
553 # define muhu_r6(rd,rs,rt) DMUHU_R6(rd,rs,rt)
554 # define div(rs,rt) DDIV(rs,rt)
555 # define divu(rs,rt) DDIVU(rs,rt)
556 # define div_r6(rd,rs,rt) DDIV_R6(rd,rs,rt)
557 # define divu_r6(rd,rs,rt) DDIVU_R6(rd,rs,rt)
558 # define mod_r6(rd,rs,rt) DMOD_R6(rd,rs,rt)
559 # define modu_r6(rd,rs,rt) DMODU_R6(rd,rs,rt)
561 # define mips_extr(rd,rt,lsb,nb) _mips_extr(_jit,rd,rt,lsb,nb)
562 static void _mips_extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
563 # define insr(rd,rt,lsb,nb) _insr(_jit,rd,rt,lsb,nb)
564 static void _insr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
565 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
566 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
567 #define addcr(r0,r1,r2) _addcr(_jit,r0,r1,r2)
568 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
569 #define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
570 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
571 # define addxr(r0,r1,r2) _addxr(_jit,r0,r1,r2)
572 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
573 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
574 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
575 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
576 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
577 # define subcr(r0,r1,r2) _subcr(_jit,r0,r1,r2)
578 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
579 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
580 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
581 # define subxr(r0,r1,r2) _subxr(_jit,r0,r1,r2)
582 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
583 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
584 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
585 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
586 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
587 # define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
588 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
589 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
590 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
591 # define hmulr(r0,r1,r2) _hmulr(_jit,r0,r1,r2)
592 static void _hmulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
593 # define hmuli(r0,r1,i0) _hmuli(_jit,r0,r1,i0)
594 static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
595 # define hmulr_u(r0,r1,r2) _hmulr_u(_jit,r0,r1,r2)
596 static void _hmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
597 # define hmuli_u(r0,r1,i0) _hmuli_u(_jit,r0,r1,i0)
598 static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
599 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
600 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
601 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
602 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
603 jit_int32_t,jit_int32_t,jit_bool_t);
604 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
605 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
606 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
607 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
608 jit_int32_t,jit_word_t,jit_bool_t);
609 # define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
610 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
611 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
612 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
613 # define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
614 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
615 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
616 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
617 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
618 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
619 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
620 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
621 jit_int32_t,jit_int32_t,jit_bool_t);
622 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
623 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
624 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
625 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
626 jit_int32_t,jit_word_t,jit_bool_t);
627 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
628 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
629 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
630 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
631 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
632 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
633 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
634 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
635 # if __WORDSIZE == 32
636 # define lshr(r0,r1,r2) SLLV(r0,r1,r2)
637 # define lshi(r0,r1,i0) SLL(r0,r1,i0)
638 # define rshr(r0,r1,r2) SRAV(r0,r1,r2)
639 # define rshi(r0,r1,i0) SRA(r0,r1,i0)
640 # define rshr_u(r0,r1,r2) SRLV(r0,r1,r2)
641 # define rshi_u(r0,r1,i0) SRL(r0,r1,i0)
643 # define lshr(r0,r1,r2) DSLLV(r0,r1,r2)
644 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
645 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
646 # define rshr(r0,r1,r2) DSRAV(r0,r1,r2)
647 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
648 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
649 # define rshr_u(r0,r1,r2) DSRLV(r0,r1,r2)
650 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
651 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
653 # define qlshr(r0,r1,r2,r3) xlshr(1,r0,r1,r2,r3)
654 # define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3)
655 # define xlshr(s,r0,r1,r2,r3) _xlshr(_jit,s,r0,r1,r2,r3)
657 _xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
658 # define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0)
659 # define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0)
660 # define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0)
662 _xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
663 # define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3)
664 # define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3)
665 # define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3)
667 _xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
668 # define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0)
669 # define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0)
670 # define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0)
672 _xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
673 # define lrotr(r0,r1,r2) _lrotr(_jit,r0,r1,r2)
674 static void _lrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
675 # define lroti(r0,r1,i0) rroti(r0,r1,__WORDSIZE-i0)
676 # define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2)
677 static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
678 # define rroti(r0,r1,i0) _rroti(_jit,r0,r1,i0)
679 static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
680 # define andr(r0,r1,r2) AND(r0,r1,r2)
681 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
682 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
683 # define orr(r0,r1,r2) OR(r0,r1,r2)
684 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
685 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
686 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
687 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
688 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
689 # define movr(r0,r1) _movr(_jit,r0,r1)
690 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
691 # define movi(r0,i0) _movi(_jit,r0,i0)
692 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
693 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
694 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
695 # define movnr(r0, r1, r2) _movnr(_jit, r0, r1, r2)
696 static void _movnr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
697 # define movzr(r0, r1, r2) _movzr(_jit, r0, r1, r2)
698 static void _movzr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
699 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
700 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
701 jit_int32_t,jit_int32_t,jit_word_t);
702 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
703 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
704 # define ldr_c(r0,r1) LB(r0,0,r1)
705 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
706 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
707 # define ldr_uc(r0,r1) LBU(r0,0,r1)
708 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
709 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
710 # define ldr_s(r0,r1) LH(r0,0,r1)
711 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
712 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
713 # define ldr_us(r0,r1) LHU(r0,0,r1)
714 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
715 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
716 # define ldr_i(r0,r1) LW(r0,0,r1)
717 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
718 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
719 # if __WORDSIZE == 64
720 # define ldr_ui(r0,r1) LWU(r0,0,r1)
721 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
722 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
723 # define ldr_l(r0,r1) LD(r0,0,r1)
724 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
725 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
727 # define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
728 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
729 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
730 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
731 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
732 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
733 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
734 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
735 # define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
736 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
737 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
738 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
739 # define ldxr_us(r0,r1,r2) _ldxr_us(_jit,r0,r1,r2)
740 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
741 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
742 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
743 # define ldxr_i(r0,r1,r2) _ldxr_i(_jit,r0,r1,r2)
744 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
745 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
746 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
747 # if __WORDSIZE == 64
748 # define ldxr_ui(r0,r1,r2) _ldxr_ui(_jit,r0,r1,r2)
749 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
750 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
751 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
752 # define ldxr_l(r0,r1,r2) _ldxr_l(_jit,r0,r1,r2)
753 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
754 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
755 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
757 # define unldr(r0, r1, i0) _unldr(_jit, r0, r1, i0)
758 static void _unldr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
759 # define unldi(r0, i0, i1) _unldi(_jit, r0, i0, i1)
760 static void _unldi(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
761 # define unldr_u(r0, r1, i0) _unldr_u(_jit, r0, r1, i0)
762 static void _unldr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
763 # define unldi_u(r0, i0, i1) _unldi_u(_jit, r0, i0, i1)
764 static void _unldi_u(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
765 # define str_c(r0,r1) SB(r1,0,r0)
766 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
767 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
768 # define str_s(r0,r1) SH(r1,0,r0)
769 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
770 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
771 # define str_i(r0,r1) SW(r1,0,r0)
772 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
773 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
774 # if __WORDSIZE == 64
775 # define str_l(r0,r1) SD(r1,0,r0)
776 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
777 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
779 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
780 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
781 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
782 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
783 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
784 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
785 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
786 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
787 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
788 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
789 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
790 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
791 # if __WORDSIZE == 64
792 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
793 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
794 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
795 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
797 # define unstr(r0, r1, i0) _unstr(_jit, r0, r1, i0)
798 static void _unstr(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
799 # define unsti(i0, r0, i1) _unsti(_jit, i0, r0, i1)
800 static void _unsti(jit_state_t*, jit_word_t, jit_int32_t, jit_word_t);
801 # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1)
802 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
803 # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1)
804 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
805 # if __WORDSIZE == 64
806 # define bswapr_ul(r0,r1) _bswapr_ul(_jit,r0,r1)
807 static void _bswapr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
809 #define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1)
810 static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
811 #define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1)
812 static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
813 #define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1)
814 static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
815 # define extr_c(r0,r1) _extr_c(_jit,r0,r1)
816 static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
817 # define extr_uc(r0,r1) ANDI(r0,r1,0xff)
818 # define extr_s(r0,r1) _extr_s(_jit,r0,r1)
819 static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
820 # define extr_us(r0,r1) ANDI(r0,r1,0xffff)
821 # if __WORDSIZE == 64
822 # define extr_i(r0,r1) SLL(r0,r1,0)
823 # define extr_ui(r0,r1) _extr_ui(_jit,r0,r1)
824 static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
826 # define ltr(r0,r1,r2) SLT(r0,r1,r2)
827 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
828 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
829 # define ltr_u(r0,r1,r2) SLTU(r0,r1,r2)
830 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
831 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
832 #define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
833 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
834 #define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
835 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
836 #define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
837 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
838 #define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
839 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
840 #define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
841 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
842 #define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
843 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
844 #define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
845 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
846 #define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
847 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
848 #define ger_u(r0,r1,i0) _ger_u(_jit,r0,r1,i0)
849 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
850 #define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
851 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
852 # define gtr(r0,r1,r2) SLT(r0,r2,r1)
853 #define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
854 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
855 # define gtr_u(r0,r1,r2) SLTU(r0,r2,r1)
856 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
857 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
858 #define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
859 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
860 #define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
861 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
862 #define bltr(i0,r0,r1) bger(i0,r1,r0)
863 #define bltr_u(i0,r0,r1) bger_u(i0,r1,r0)
864 #define blti(i0,r0,i1) _bgei(_jit,i0,r0,i1,0,1)
865 #define blti_u(i0,r0,i1) _bgei(_jit,i0,r0,i1,1,1)
866 #define bler(i0,r0,r1) _bgtr(_jit,i0,r1,r0,0,1)
867 #define bler_u(i0,r0,r1) _bgtr(_jit,i0,r1,r0,1,1)
868 #define blei(i0,r0,i1) _bgti(_jit,i0,r0,i1,0,1)
869 #define blei_u(i0,r0,i1) _bgti(_jit,i0,r0,i1,1,1)
870 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
871 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
872 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
873 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
874 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1,0)
875 #define bger_u(i0,r0,r1) _bger(_jit,i0,r0,r1,1)
876 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
878 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1,0,0)
879 #define bgei_u(i0,r0,i1) _bgei(_jit,i0,r0,i1,1,0)
880 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
881 jit_bool_t,jit_bool_t);
882 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1,0,0)
883 #define bgtr_u(i0,r0,r1) _bgtr(_jit,i0,r0,r1,1,0)
884 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t,
885 jit_bool_t,jit_bool_t);
886 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1,0,0)
887 #define bgti_u(i0,r0,i1) _bgti(_jit,i0,r0,i1,1,0)
888 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t,
889 jit_bool_t,jit_bool_t);
890 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
891 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
892 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
893 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
894 # define jmpr(r0) _jmpr(_jit,r0)
895 static void _jmpr(jit_state_t*,jit_int32_t);
896 # define jmpi(i0,patch) _jmpi(_jit,i0,patch)
897 static jit_word_t _jmpi(jit_state_t*,jit_word_t,jit_bool_t);
898 # define jmpi_p(i0) _jmpi_p(_jit,i0)
899 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
900 # define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
901 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
902 # define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
903 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
904 # define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
905 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
906 # define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
907 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
908 # define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
909 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
910 # define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
911 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
912 # define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
913 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
914 # define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
915 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
916 # define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
917 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
918 # define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
919 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
920 # define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
921 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
922 # define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
923 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
924 # define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
925 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
926 # define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
927 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
928 # define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
929 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
930 # define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
931 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
932 # define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
933 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
934 # define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
935 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
936 # define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
937 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
938 # define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
939 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
940 # define callr(r0) _callr(_jit,r0)
941 static void _callr(jit_state_t*,jit_int32_t);
942 # define calli(i0,i1) _calli(_jit,i0,i1)
943 static jit_word_t _calli(jit_state_t*,jit_word_t,jit_bool_t);
944 # define calli_p(i0) _calli_p(_jit,i0)
945 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
946 # define prolog(node) _prolog(_jit,node)
947 static void _prolog(jit_state_t*,jit_node_t*);
948 # define epilog(node) _epilog(_jit,node)
949 static void _epilog(jit_state_t*,jit_node_t*);
950 # define vastart(r0) _vastart(_jit, r0)
951 static void _vastart(jit_state_t*, jit_int32_t);
952 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
953 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
954 #define patch_abs(instr,label) _patch_abs(_jit,instr,label)
955 static void _patch_abs(jit_state_t*,jit_word_t,jit_word_t);
956 #define patch_at(jump,label) _patch_at(_jit,jump,label)
957 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
958 /* definitions used by jit_get_reg_for_delay_slot() */
959 #include "jit_mips-fpu.c"
964 _instr(jit_state_t *_jit, jit_int32_t op)
966 if (_jitc->inst.pend)
969 _jitc->inst.pend = 1;
974 _flush(jit_state_t *_jit)
976 if (_jitc->inst.pend) {
978 _jitc->inst.pend = 0;
983 _pending(jit_state_t *_jit)
986 if (_jitc->inst.pend) {
988 _jitc->inst.pend = 0;
996 _delay(jit_state_t *_jit, jit_int32_t op)
998 assert(_jitc->inst.pend);
1000 _jitc->inst.pend = 0;
1005 _jit_get_reg_for_delay_slot(jit_state_t *_jit, jit_int32_t mask,
1006 jit_int32_t reg0, jit_int32_t reg1)
1009 jit_int32_t reg, r0, r1, r2/*, xreg*/, regs[3];
1010 /* If will emit a pending instruction */
1011 if (_jitc->inst.pend)
1012 i.op = _jitc->inst.op;
1013 /* Else if at least one instruction emited, check it */
1014 else if (_jit->pc.uc > _jit->code.ptr)
1015 i.op = _jit->pc.ui[-1];
1019 regs[0] = regs[1] = regs[2]/* = xreg*/ = -1;
1021 case MIPS_SPECIAL: /* 00 */
1023 case MIPS_SLLV: /* 04 */
1024 case MIPS_SRLV: /* 06 */
1025 case MIPS_SRAV: /* 07 */
1026 case MIPS_DSLLV: /* 14 */
1027 case MIPS_DSRLV: /* 16 */
1028 case MIPS_DSRAV: /* 17 */
1029 case MIPS_ADDU: /* 21 */
1030 case MIPS_SUBU: /* 23 */
1031 case MIPS_AND: /* 24 */
1032 case MIPS_OR: /* 25 */
1033 case MIPS_XOR: /* 26 */
1034 case MIPS_NOR: /* 27 */
1035 case MIPS_SLT: /* 2a */
1036 case MIPS_SLTU: /* 2b */
1037 case MIPS_DADDU: /* 2d */
1038 case MIPS_DSUBU: /* 2f */
1039 if (mask & jit_class_gpr) {
1046 case MIPS_MULT: /* 18 */
1048 case MIPS_MULTU: /* 19 */
1050 case MIPS_DIV: /* 1a */
1052 case MIPS_DIVU: /* 1b */
1054 case MIPS_DMULT: /* 1c */
1056 case MIPS_DMULTU: /* 1d */
1058 case MIPS_DDIV: /* 1e */
1060 case MIPS_DDIVU: /* 1f */
1061 if (jit_mips6_p()) {
1062 assert(i.ic.b == 2 || i.ic.b == 3);
1063 if (mask & jit_class_gpr) {
1070 assert(i.rd.b == 0);
1071 if (mask & jit_class_gpr) {
1079 case MIPS_MFHI: /* 10 */
1081 case MIPS_MTHI: /* 11 */
1083 case MIPS_MFLO: /* 12 */
1085 case MIPS_MTLO: /* 13 */
1086 if (mask & jit_class_gpr) {
1087 if (jit_mips6_p()) {
1088 assert(i.ic.b == 1);
1092 assert(!i.rs.b && !i.rt.b);
1099 case MIPS_JR: /* 08 */
1100 assert(!jit_mips6_p());
1101 case MIPS_JALR: /* 09 */
1102 /* check for proper/known encondig */
1104 if (mask & jit_class_gpr) {
1110 case MIPS_SLL: /* 00 */
1111 /* If cannot have a shift in delay slot */
1112 if (!jit_cpu.sll_delay)
1114 case MIPS_SRL: /* 02 */
1115 case MIPS_SRA: /* 03 */
1116 case MIPS_DSLL: /* 38 */
1117 case MIPS_DSRL: /* 3a */
1118 case MIPS_DSRA: /* 3b */
1119 case MIPS_DSLL32: /* 3c */
1120 case MIPS_DSRA32: /* 3f */
1121 case MIPS_DSRL32: /* 3e */
1122 /* shift (or rotate if i.rs.b == 1) */
1123 assert(i.rs.b == 0 || i.rs.b == 1);
1124 if (mask & jit_class_gpr) {
1130 case MIPS_SYNC: /* 0f */
1131 assert(i.rs.b == 0 && i.rt.b == 0 && i.rd.b == 0);
1132 if (mask & jit_class_gpr)
1133 regs[0] = regs[1] = regs[2] = 0;
1135 case MIPS_MOVZ: /* 0a */
1136 case MIPS_MOVN: /* 0b */
1137 assert(!jit_mips6_p() && i.ic.b == 0);
1138 if (mask & jit_class_gpr) {
1148 assert(jit_mips6_p() && i.ic.b == 0);
1149 if (mask & jit_class_gpr) {
1159 case MIPS_REGIMM: /* 01 */
1165 assert(jit_mips6_p());
1166 case MIPS_BLTZ: /* 00 */
1167 case MIPS_BGEZ: /* 01 */
1168 case MIPS_BGEZAL: /* 11 */
1173 if (mask & jit_class_gpr) {
1175 regs[1] = regs[2] = 0;
1178 case MIPS_BC_R6: /* 32 */
1179 case MIPS_BALC: /* 3a */
1180 assert(jit_mips6_p());
1181 case MIPS_J: /* 02 */
1182 case MIPS_JAL: /* 03 */
1183 if (mask & jit_class_gpr)
1184 regs[0] = regs[1] = regs[2] = 0;
1186 case MIPS_LUI: /* 0f */
1187 assert(jit_mips6_p() || i.rs.b == 0);
1188 if (mask & jit_class_gpr) {
1190 regs[1] = i.rs.b; /* AUI if non zero */
1194 case MIPS_SPECIAL2: /* 1c */
1196 case MIPS_CLZ: /* 20 */
1197 case MIPS_CLO: /* 21 */
1198 case MIPS_DCLZ: /* 24 */
1199 case MIPS_DCLO: /* 25 */
1200 assert(!jit_mips6_p() && i.rt.b == i.rd.b && i.ic.b == 0);
1201 if (mask & jit_class_gpr) {
1207 case MIPS_MUL: /* 02 */
1208 assert(jit_mips2_p() && i.ic.b == 0);
1209 if (mask & jit_class_gpr) {
1219 case MIPS_SPECIAL3: /* 1f */
1221 case MIPS_EXT: /* 00 */
1222 case MIPS_DEXTM: /* 01 */
1223 case MIPS_DEXTU: /* 02 */
1224 case MIPS_DEXT: /* 03 */
1225 case MIPS_INS: /* 04 */
1226 case MIPS_DINSM: /* 05 */
1227 case MIPS_DINSU: /* 06 */
1228 case MIPS_DINS: /* 07 */
1229 if (mask & jit_class_gpr) {
1236 case MIPS_BSHFL: /* 20 */
1238 case MIPS_DBSHFL: /* 24 */
1241 case MIPS_WSBH: /* 02 */
1242 case MIPS_DSHD: /* 05 */
1243 case MIPS_SEB: /* 10 */
1244 case MIPS_SEH: /* 18 */
1245 if (mask & jit_class_gpr) {
1251 /* BITSWAP DBITSWAP */
1253 assert(jit_mips6_p() && i.rt.b == 0);
1254 if (mask & jit_class_gpr) {
1272 assert(jit_mips6_p());
1273 if (mask & jit_class_gpr) {
1283 case MIPS_COP1: /* 11 */
1285 case MIPS_ADD_fmt: /* 00 */
1287 case MIPS_MF: /* 00 */
1288 case MIPS_DMF: /* 01 */
1289 case MIPS_MFH: /* 03 */
1290 case MIPS_MT: /* 04 */
1291 case MIPS_DMT: /* 05 */
1292 case MIPS_MTH: /* 07 */
1293 assert(i.ic.b == 0);
1294 /* If these cop1 instructions in delay slot
1296 if (!jit_cpu.cop1_delay)
1298 if (mask & jit_class_gpr) {
1300 regs[1] = regs[2] = 0;
1309 case MIPS_MADDF: /* 18 */
1310 case MIPS_MSUBF: /* 19 */
1311 assert(jit_mips6_p());
1312 case MIPS_SUB_fmt: /* 01 */
1313 case MIPS_MUL_fmt: /* 02 */
1314 case MIPS_DIV_fmt: /* 03 */
1317 assert(i.rs.b == MIPS_fmt_S ||
1319 i.rs.b == MIPS_fmt_D);
1320 if (mask & jit_class_gpr)
1321 regs[0] = regs[1] = regs[2] = 0;
1328 case MIPS_SQRT_fmt: /* 04 */
1329 case MIPS_ABS_fmt: /* 05 */
1330 case MIPS_MOV_fmt: /* 06 */
1331 case MIPS_NEG_fmt: /* 07 */
1332 assert((i.rs.b == MIPS_fmt_S || i.rs.b == MIPS_fmt_D) &&
1334 if (mask & jit_class_gpr)
1335 regs[0] = regs[1] = regs[2] = 0;
1341 case MIPS_CVT_fmt_S: /* 20 */
1342 case MIPS_CVT_fmt_D: /* 21 */
1343 case MIPS_CVT_fmt_W: /* 24 */
1344 case MIPS_CVT_fmt_L: /* 25 */
1346 case MIPS_fmt_S:/* 10 */
1347 case MIPS_fmt_D:/* 11 */
1348 case MIPS_fmt_W:/* 14 */
1349 case MIPS_fmt_L:/* 15 */
1354 assert(i.rt.b == 0);
1355 if (mask & jit_class_gpr)
1356 regs[0] = regs[1] = regs[2] = 0;
1362 case MIPS_cond_F: /* 30 */
1363 case MIPS_cond_UN: /* 31 */
1364 case MIPS_cond_EQ: /* 32 */
1365 case MIPS_cond_UEQ: /* 33 */
1366 case MIPS_cond_OLT: /* 34 */
1367 case MIPS_cond_ULT: /* 35 */
1368 case MIPS_cond_OLE: /* 36 */
1369 case MIPS_cond_ULE: /* 37 */
1370 case MIPS_cond_SF: /* 38 */
1371 case MIPS_cond_NGLE: /* 39 */
1372 case MIPS_cond_SEQ: /* 3a */
1373 case MIPS_cond_NGL: /* 3b */
1374 case MIPS_cond_LT: /* 3c */
1375 case MIPS_cond_NGE: /* 3d */
1376 case MIPS_cond_LE: /* 3e */
1377 case MIPS_cond_UGT: /* 3f */
1378 assert(!jit_mips6_p() &&
1380 (i.fm.b == MIPS_fmt_S ||
1382 i.fm.b == MIPS_fmt_D));
1383 if (mask & jit_class_gpr)
1384 regs[0] = regs[1] = regs[2] = 0;
1392 case MIPS_cmp_AF: /* 00 */
1393 case MIPS_cmp_UN: /* 01 */
1394 case MIPS_cmp_EQ: /* 02 */
1395 case MIPS_cmp_UEQ: /* 03 */
1396 case MIPS_cmp_LT: /* 04 */
1397 case MIPS_cmp_ULT: /* 05 */
1398 case MIPS_cmp_LE: /* 06 */
1399 case MIPS_cmp_ULE: /* 07 */
1400 case MIPS_cmp_SAF: /* 08 */
1401 case MIPS_cmp_SUN: /* 09 */
1402 case MIPS_cmp_SEQ: /* 0a */
1403 case MIPS_cmp_SUEQ:/* 0b */
1404 case MIPS_cmp_SLT: /* 0c */
1405 case MIPS_cmp_SULT:/* 0d */
1406 case MIPS_cmp_SLE: /* 0e */
1407 case MIPS_cmp_SULE:/* 0f */
1408 assert(jit_mips6_p() &&
1410 (i.rs.b == MIPS_condn_S ||
1412 i.rs.b == MIPS_condn_D));
1413 if (mask & jit_class_gpr)
1414 regs[0] = regs[1] = regs[2] = 0;
1425 case MIPS_BC: /* 08 */
1426 assert(!jit_mips6_p() &&
1428 (i.rs.b == MIPS_BCF ||
1430 i.rs.b == MIPS_BCT));
1431 if (mask & jit_class_gpr)
1432 regs[0] = regs[1] = regs[2] = 0;
1438 case MIPS_BC1EQZ:/* 09 */
1439 case MIPS_BC1NEZ:/* 0a */
1440 assert(jit_mips6_p());
1441 if (mask & jit_class_gpr)
1442 regs[0] = regs[1] = regs[2] = 0;
1452 case MIPS_COP1X: /* 13 */
1454 case MIPS_MADD_fmt_S:
1455 case MIPS_MADD_fmt_D:
1456 case MIPS_MSUB_fmt_S:
1457 case MIPS_MSUB_fmt_D:
1458 case MIPS_NMADD_fmt_S:
1459 case MIPS_NMADD_fmt_D:
1460 case MIPS_NMSUB_fmt_S:
1461 case MIPS_NMSUB_fmt_D:
1462 assert(!jit_mips6_p());
1463 if (mask & jit_class_gpr)
1464 regs[0] = regs[1] = regs[2] = 0;
1469 /* FIXME No need to compute and check it.
1470 * If asking for a tmeporary fpr, code will
1472 /* xreg = i.fr.b; */
1479 case MIPS_DAUI: /* JALX */ /* 1d */
1480 /* Do not generate JALX. No microMIPS64 or MIPS16e support */
1481 assert(jit_mips6_p() && i.rs.b != 0);
1482 case MIPS_ADDIU: /* 09 */
1483 case MIPS_SLTI: /* 0a */
1484 case MIPS_SLTIU: /* 0b */
1485 case MIPS_ANDI: /* 0c */
1486 case MIPS_ORI: /* 0d */
1487 case MIPS_XORI: /* 0e */
1488 case MIPS_DADDIU: /* 18 */
1489 case MIPS_LDL: /* 1a */
1490 case MIPS_LDR: /* 1b */
1491 case MIPS_LB: /* 20 */
1492 case MIPS_LH: /* 21 */
1493 case MIPS_LW: /* 23 */
1494 case MIPS_LBU: /* 24 */
1495 case MIPS_LHU: /* 25 */
1496 case MIPS_LWU: /* 27 */
1497 case MIPS_SB: /* 28 */
1498 case MIPS_SH: // 29 */
1499 case MIPS_SW: /* 2b */
1500 case MIPS_LD: /* 37 */
1501 case MIPS_SD: /* 3f */
1502 if (mask & jit_class_gpr) {
1508 case MIPS_LWL: /* 22 */
1509 case MIPS_LWR: /* 26 */
1510 if (!jit_cpu.lwl_lwr_delay)
1512 case MIPS_SWL: /* 2a */
1513 case MIPS_SWR: /* 2e */
1514 case MIPS_SDL: /* 2c */
1515 case MIPS_SDR: /* 2d */
1516 assert(!(jit_mips6_p()));
1517 if (mask & jit_class_gpr) {
1523 case MIPS_LL: /* 30 */
1524 case MIPS_LLD: /* 34 */
1525 case MIPS_SC: /* 38 */
1526 case MIPS_SCD: /* 3c */
1527 assert(!jit_mips6_p() && i.ic.b == 0);
1528 if (mask & jit_class_gpr) {
1534 case MIPS_BLEZ: /* 06 */
1535 case MIPS_BGTZ: /* 07 */
1536 assert(i.rt.b == 0);
1537 if (mask & jit_class_gpr) {
1539 regs[1] = regs[2] = 0;
1542 case MIPS_LWC1: /* 31 */
1543 case MIPS_LDC1: /* 35 */
1544 case MIPS_SWC1: /* 39 */
1545 case MIPS_SDC1: /* 3d */
1546 /* If these cop1 instructions in delay wont not work */
1547 if (!jit_cpu.cop1_delay)
1549 if (mask & jit_class_gpr) {
1557 case MIPS_BEQ: /* 04 */
1558 case MIPS_BNE: /* 05 */
1559 assert(i.rt.b == 0);
1560 if (mask & jit_class_gpr) {
1568 case MIPS_PCREL: /* 0x3b */
1569 assert(jit_mips6_p());
1571 case 0x1e: /* AUIPC */
1572 case 0x1f: /* ALUIPC */
1575 assert(i.pD.b == 1 ||/* LDPC */
1576 i.pW.b == 0 ||/* ADDIUPC */
1577 i.pW.b == 1 ||/* LWPC */
1578 i.pW.b == 2); /* LWUPC */
1581 if (mask & jit_class_gpr) {
1583 regs[1] = regs[2] = 0;
1590 /* If cannot move instruction do delay slot */
1591 if (_jitc->inst.pend &&
1592 (((mask & jit_class_fpr) || reg0) &&
1593 (reg0 == regs[0] || reg0 == regs[1] || reg0 == regs[2])) ||
1594 (((mask & jit_class_fpr) || reg1) &&
1595 (reg1 == regs[0] || reg1 == regs[1] || reg1 == regs[2]))) {
1598 /* Get a temporary register */
1600 reg = jit_get_reg(mask|jit_class_nospill);
1601 /* Make sure will not use a register in use by delay slot */
1602 if (_jitc->inst.pend) {
1603 if (rn(reg) == regs[0] ||
1604 rn(reg) == regs[1] || rn(reg) == regs[2]) {
1606 reg = jit_get_reg(mask|jit_class_nospill);
1607 if (rn(reg) == regs[0] ||
1608 rn(reg) == regs[1] || rn(reg) == regs[2]) {
1610 reg = jit_get_reg(mask|jit_class_nospill);
1611 if (rn(reg) == regs[0] ||
1612 rn(reg) == regs[1] || rn(reg) == regs[2]) {
1614 reg = jit_get_reg(mask|jit_class_nospill);
1622 if (reg == JIT_NOREG) {
1623 /* Cannot get a register to optimize delay slot */
1625 /* Must find a free register */
1626 if (!(mask & jit_class_chk))
1629 assert(reg != JIT_NOREG || (mask & jit_class_chk));
1634 _hrrrit(jit_state_t *_jit,jit_int32_t hc,
1635 jit_int32_t rs, jit_int32_t rt, jit_int32_t rd,
1636 jit_int32_t ic, jit_int32_t tc)
1649 _hrri(jit_state_t *_jit, jit_int32_t hc,
1650 jit_int32_t rs, jit_int32_t rt, jit_int32_t im)
1662 _hrri9(jit_state_t *_jit, jit_int32_t hc,
1663 jit_int32_t rs, jit_int32_t rt, jit_int32_t i9, jit_int32_t tc)
1676 _hriD(jit_state_t *_jit, jit_int32_t hc,
1677 jit_int32_t rs, jit_int32_t pD, jit_int32_t iD)
1688 _hriW(jit_state_t *_jit, jit_int32_t hc,
1689 jit_int32_t rs, jit_int32_t pW, jit_int32_t iW)
1700 _hi(jit_state_t *_jit, jit_int32_t hc, jit_int32_t im)
1709 _nop(jit_state_t *_jit, jit_int32_t i0)
1711 for (; i0 > 0; i0 -= 4)
1717 _mips_extr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1718 jit_int32_t pos, jit_int32_t size)
1722 if (__WORDSIZE == 32)
1723 EXT(r0, r1, pos, size);
1725 DEXTU(r0, r1, pos, size);
1727 DEXTM(r0, r1, pos, size);
1729 DEXT(r0, r1, pos, size);
1733 _insr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1734 jit_int32_t pos, jit_int32_t size)
1738 if (__WORDSIZE == 32)
1739 INS(r0, r1, pos, size);
1741 DINSU(r0, r1, pos, size);
1743 DINSM(r0, r1, pos, size);
1745 DINS(r0, r1, pos, size);
1749 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1751 #if __WORDSIZE == 32
1754 else if (jit_mips2_p())
1757 fallback_clo(r0, r1);
1759 assert(jit_mips2_p());
1768 _clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1770 #if __WORDSIZE == 32
1773 else if (jit_mips2_p())
1776 fallback_clz(r0, r1);
1778 assert(jit_mips2_p());
1787 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1789 if (jit_mips6_p()) {
1800 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1802 if (jit_mips6_p()) {
1809 t0 = jit_get_reg(jit_class_gpr);
1810 t1 = jit_get_reg(jit_class_gpr);
1813 andr(rn(t0), rn(t0), r1);
1815 xori(rn(t1), r0, __WORDSIZE - 1);
1816 movnr(r0, rn(t1), rn(t0));
1824 _rbitr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1826 if (jit_mips6_p()) {
1827 #if __WORDSIZE == 32
1836 fallback_rbit(r0, r1);
1840 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1845 else if (can_sign_extend_short_p(i0))
1848 if (jit_mips6_p()) {
1851 # if __BYTE_ORDER == __LITTLE_ENDIAN
1853 jit_word_t aui : 16;
1854 # if __WORDSIZE == 64
1855 jit_word_t ahi : 16;
1856 jit_word_t ati : 16;
1859 # if __WORDSIZE == 64
1860 jit_word_t ati : 16;
1861 jit_word_t ahi : 16;
1863 jit_word_t aui : 16;
1870 if (r0 == r1 && ((jit_word_t)bits.b.aui << 16) == i0)
1871 /* FIXME It should not be required r0 == r1 per
1872 * documentation, but this is now it works in qemu
1873 * for DAUI. Assume AUI has the same restriction. */
1874 DAUI(r1, r0, bits.b.aui & 0xffff);
1875 #if __WORDSIZE == 64
1876 else if (r0 == r1 && ((jit_word_t)bits.b.ahi << 32) == i0)
1877 DAHI(r0, bits.b.ahi & 0xffff);
1878 else if (r0 == r1 && ((jit_word_t)bits.b.ati << 48) == i0)
1879 DATI(r0, bits.b.ati & 0xffff);
1886 reg = jit_get_reg(jit_class_gpr);
1888 addr(r0, r1, rn(reg));
1895 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1899 if (jit_carry == _NOREG)
1900 jit_carry = jit_get_reg(jit_class_gpr);
1902 t0 = jit_get_reg(jit_class_gpr);
1903 addr(rn(t0), r1, r2);
1904 SLTU(rn(jit_carry), rn(t0), r1);
1910 SLTU(rn(jit_carry), r0, r1);
1915 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1919 if (jit_carry == _NOREG)
1920 jit_carry = jit_get_reg(jit_class_gpr);
1921 t0 = jit_get_reg(jit_class_gpr);
1923 if (can_sign_extend_short_p(i0))
1924 addiu(rn(t0), r1, i0);
1927 addr(rn(t0), r1, rn(t0));
1929 SLTU(rn(jit_carry), rn(t0), r1);
1933 if (can_sign_extend_short_p(i0))
1937 addr(r0, r1, rn(t0));
1939 SLTU(rn(jit_carry), r0, r1);
1945 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1949 assert(jit_carry != _NOREG);
1950 t0 = jit_get_reg(jit_class_gpr);
1951 movr(rn(t0), rn(jit_carry));
1953 addcr(r0, r0, rn(t0));
1958 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1962 assert(jit_carry != _NOREG);
1963 t0 = jit_get_reg(jit_class_gpr);
1964 movr(rn(t0), rn(jit_carry));
1966 addcr(r0, r0, rn(t0));
1971 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1976 else if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
1979 reg = jit_get_reg(jit_class_gpr);
1981 subr(r0, r1, rn(reg));
1987 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1991 if (jit_carry == _NOREG)
1992 jit_carry = jit_get_reg(jit_class_gpr);
1994 t0 = jit_get_reg(jit_class_gpr);
1995 subr(rn(t0), r1, r2);
1996 SLTU(rn(jit_carry), r1, rn(t0));
2002 SLTU(rn(jit_carry), r1, r0);
2007 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2011 if (jit_carry == _NOREG)
2012 jit_carry = jit_get_reg(jit_class_gpr);
2013 t0 = jit_get_reg(jit_class_gpr);
2015 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
2016 addiu(rn(t0), r1, -i0);
2019 subr(rn(t0), r1, rn(t0));
2021 SLTU(rn(jit_carry), r1, rn(t0));
2025 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
2029 subr(r0, r1, rn(t0));
2031 SLTU(rn(jit_carry), r1, r0);
2037 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2041 assert(jit_carry != _NOREG);
2042 t0 = jit_get_reg(jit_class_gpr);
2043 movr(rn(t0), rn(jit_carry));
2045 subcr(r0, r0, rn(t0));
2050 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2054 assert(jit_carry != _NOREG);
2055 t0 = jit_get_reg(jit_class_gpr);
2056 movr(rn(t0), rn(jit_carry));
2058 subcr(r0, r0, rn(t0));
2063 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2070 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2075 if (jit_mips2_p() && __WORDSIZE == 32)
2085 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2089 reg = jit_get_reg(jit_class_gpr);
2091 mulr(r0, r1, rn(reg));
2096 _hmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2107 _hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2110 reg = jit_get_reg(jit_class_gpr);
2112 hmulr(r0, r1, rn(reg));
2117 _hmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2120 muhu_r6(r0, r1, r2);
2128 _hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2131 reg = jit_get_reg(jit_class_gpr);
2133 hmulr_u(r0, r1, rn(reg));
2138 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2139 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
2142 if (jit_mips6_p()) {
2143 if (r0 == r2 || r0 == r3) {
2144 t0 = jit_get_reg(jit_class_gpr);
2146 mul_r6(rn(t0), r2, r3);
2148 mulu_r6(rn(t0), r2, r3);
2154 mulu_r6(r0, r2, r3);
2159 muhu_r6(r1, r2, r3);
2160 if (r0 == r2 || r0 == r3) {
2176 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2177 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
2180 reg = jit_get_reg(jit_class_gpr);
2182 iqmulr(r0, r1, r2, rn(reg), sign);
2187 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2198 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2201 reg = jit_get_reg(jit_class_gpr);
2203 divr(r0, r1, rn(reg));
2208 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2211 divu_r6(r0, r1, r2);
2219 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2222 reg = jit_get_reg(jit_class_gpr);
2224 divr_u(r0, r1, rn(reg));
2229 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2230 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
2233 if (jit_mips6_p()) {
2234 if (r0 == r2 || r0 == r3)
2235 t0 = jit_get_reg(jit_class_gpr);
2242 div_r6(rn(t0), r2, r3);
2247 divu_r6(r0, r2, r3);
2249 divu_r6(rn(t0), r2, r3);
2250 modu_r6(r1, r2, r3);
2268 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2269 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
2272 reg = jit_get_reg(jit_class_gpr);
2274 iqdivr(r0, r1, r2, rn(reg), sign);
2279 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2290 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2293 reg = jit_get_reg(jit_class_gpr);
2295 remr(r0, r1, rn(reg));
2300 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2303 modu_r6(r0, r1, r2);
2311 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2314 reg = jit_get_reg(jit_class_gpr);
2316 remr_u(r0, r1, rn(reg));
2320 #if __WORDSIZE == 64
2322 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2324 assert(i0 >= 0 && i0 <= 63);
2328 DSLL32(r0, r1, i0 - 32);
2332 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2334 assert(i0 >= 0 && i0 <= 63);
2338 DSRA32(r0, r1, i0 - 32);
2342 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2344 assert(i0 >= 0 && i0 <= 63);
2348 DSRL32(r0, r1, i0 - 32);
2353 _xlshr(jit_state_t *_jit, jit_bool_t sign,
2354 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2357 jit_word_t over, zero, done, done_over;
2358 jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3;
2359 s0 = jit_get_reg(jit_class_gpr);
2361 if (r0 == r2 || r1 == r2) {
2362 s2 = jit_get_reg(jit_class_gpr);
2368 if (r0 == r3 || r1 == r3) {
2369 s3 = jit_get_reg(jit_class_gpr);
2375 if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) {
2381 rsbi(t0, t3, __WORDSIZE);
2388 zero = beqi(_jit->pc.w, t3, 0);
2389 over = beqi(_jit->pc.w, t3, __WORDSIZE);
2390 done = jmpi(_jit->pc.w, 1);
2392 patch_at(over, _jit->pc.w);
2395 done_over = jmpi(_jit->pc.w, 1);
2398 patch_at(zero, _jit->pc.w);
2400 rshi(r1, t2, __WORDSIZE - 1);
2404 patch_at(done, _jit->pc.w);
2405 patch_at(done_over, _jit->pc.w);
2409 rshi(t0, t2, __WORDSIZE - 1);
2414 /* Branchless but 4 bytes longer than branching fallback */
2418 eqi(t1, t3, __WORDSIZE);
2430 _xlshi(jit_state_t *_jit, jit_bool_t sign,
2431 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2436 rshi(r1, r2, __WORDSIZE - 1);
2440 else if (i0 == __WORDSIZE) {
2445 assert((jit_uword_t)i0 <= __WORDSIZE);
2447 rshi(r1, r2, __WORDSIZE - i0);
2449 rshi_u(r1, r2, __WORDSIZE - i0);
2455 _xrshr(jit_state_t *_jit, jit_bool_t sign,
2456 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2459 jit_word_t over, zero, done, done_over;
2460 jit_int32_t t0, s0, t1, s1, t2, s2, t3, s3;
2461 s0 = jit_get_reg(jit_class_gpr);
2463 if (r0 == r2 || r1 == r2) {
2464 s2 = jit_get_reg(jit_class_gpr);
2470 if (r0 == r3 || r1 == r3) {
2471 s3 = jit_get_reg(jit_class_gpr);
2477 if ((s1 = jit_get_reg(jit_class_gpr|jit_class_nospill|jit_class_chk))) {
2483 rsbi(t0, t3, __WORDSIZE);
2490 zero = beqi(_jit->pc.w, t3, 0);
2491 over = beqi(_jit->pc.w, t3, __WORDSIZE);
2492 done = jmpi(_jit->pc.w, 1);
2494 patch_at(over, _jit->pc.w);
2497 rshi(r0, t2, __WORDSIZE - 1);
2500 done_over = jmpi(_jit->pc.w, 1);
2503 patch_at(zero, _jit->pc.w);
2505 rshi(r1, t2, __WORDSIZE - 1);
2509 patch_at(done, _jit->pc.w);
2510 patch_at(done_over, _jit->pc.w);
2516 rshi(t0, t2, __WORDSIZE - 1);
2521 eqi(t1, t3, __WORDSIZE);
2533 _xrshi(jit_state_t *_jit, jit_bool_t sign,
2534 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2539 rshi(r1, r2, __WORDSIZE - 1);
2543 else if (i0 == __WORDSIZE) {
2546 rshi(r0, r2, __WORDSIZE - 1);
2551 assert((jit_uword_t)i0 <= __WORDSIZE);
2552 lshi(r1, r2, __WORDSIZE - i0);
2561 _lrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2564 if (jit_mips2_p()) {
2565 if (r0 != r1 && r0 != r2) {
2566 rsbi(r0, r2, __WORDSIZE);
2570 reg = jit_get_reg(jit_class_gpr);
2571 rsbi(rn(reg), r2, __WORDSIZE);
2572 rrotr(r0, r1, rn(reg));
2577 fallback_lrotr(r0, r1, r2);
2581 _rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2583 if (jit_mips2_p()) {
2584 #if __WORDSIZE == 32
2591 fallback_rrotr(r0, r1, r2);
2595 _rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2597 assert(i0 >= 0 && i0 <= __WORDSIZE - 1);
2598 if (jit_mips2_p()) {
2599 #if __WORDSIZE == 32
2605 DROTR32(r0, r1, i0 - 32);
2609 fallback_rroti(r0, r1, i0);
2613 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2616 if (can_zero_extend_short_p(i0))
2618 else if (is_low_mask(i0)) {
2620 mips_extr(r0, r1, 0, masked_bits_count(i0));
2622 lshi(r0, r1, unmasked_bits_count(i0));
2623 rshi_u(r0, r0, unmasked_bits_count(i0));
2625 } else if (is_high_mask(i0)) {
2626 if (jit_mips2_p() && r0 == r1)
2627 insr(r0, _ZERO_REGNO, 0, unmasked_bits_count(i0));
2629 rshi(r0, r1, unmasked_bits_count(i0));
2630 lshi(r0, r0, unmasked_bits_count(i0));
2632 } else if (jit_mips2_p() && is_middle_mask(i0)) {
2633 mips_extr(r0, r1, __builtin_ctzl(i0), masked_bits_count(i0));
2634 lshi(r0, r0, __builtin_ctzl(i0));
2635 } else if (jit_mips2_p() && is_middle_mask(~i0)) {
2638 insr(r0, _ZERO_REGNO, __builtin_ctzl(~i0), masked_bits_count(~i0));
2640 reg = jit_get_reg(jit_class_gpr);
2642 AND(r0, r1, rn(reg));
2648 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2651 if (can_zero_extend_short_p(i0))
2654 reg = jit_get_reg(jit_class_gpr);
2656 OR(r0, r1, rn(reg));
2662 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2665 if (can_zero_extend_short_p(i0))
2668 reg = jit_get_reg(jit_class_gpr);
2670 XOR(r0, r1, rn(reg));
2676 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2679 orr(r0, r1, _ZERO_REGNO);
2683 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2686 OR(r0, _ZERO_REGNO, _ZERO_REGNO);
2687 else if (can_sign_extend_short_p(i0))
2688 addiu(r0, _ZERO_REGNO, i0);
2689 else if (can_zero_extend_short_p(i0))
2690 ORI(r0, _ZERO_REGNO, i0);
2692 /* Check if loading some constant reachable address */
2693 if (jit_mips6_p()) {
2695 w = i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0));
2699 if (can_sign_extend_i19_p(d)) {
2705 if (can_sign_extend_int_p(w)) {
2706 jit_int32_t lo = (jit_int32_t)w << 16 >> 16;
2707 jit_int32_t hi = w - lo;
2708 AUIPC(r0, hi >> 16);
2714 if (can_sign_extend_int_p(i0))
2716 else if (can_zero_extend_int_p(i0)) {
2717 if (i0 & 0xffff0000) {
2718 ORI(r0, _ZERO_REGNO, i0 >> 16);
2722 # if __WORDSIZE == 64
2724 movi(r0, (jit_uword_t)i0 >> 32);
2725 if (i0 & 0xffff0000) {
2727 ORI(r0, r0, i0 >> 16);
2741 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2746 # if __WORDSIZE == 32
2751 ORI(r0, r0, i0 >> 32);
2753 ORI(r0, r0, i0 >> 16);
2762 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2765 if (jit_mips6_p()) {
2766 reg = jit_get_reg(jit_class_gpr);
2767 SELNEZ(rn(reg), r1, r2);
2769 OR(r0, r0, rn(reg));
2777 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2780 if (jit_mips6_p()) {
2781 reg = jit_get_reg(jit_class_gpr);
2782 SELEQZ(rn(reg), r1, r2);
2784 OR(r0, r0, rn(reg));
2792 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2793 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
2795 jit_int32_t r1_reg, iscasi;
2796 jit_word_t retry, done, jump0, jump1;
2797 if ((iscasi = (r1 == _NOREG))) {
2798 r1_reg = jit_get_reg(jit_class_gpr);
2806 # if __WORDSIZE == 32
2807 if (jit_mips6_p()) LL_R6(r0, 0, r1);
2810 if (jit_mips6_p()) LLD_R6(r0, 0, r1);
2811 else LLD(r0, 0, r1);
2815 BNE(r0, r2, 1); /* bne done r0 r2 */
2816 movi(r0, 0); /* set to 0 in delay slot */
2818 movr(r0, r3); /* after jump and delay slot */
2819 /* store new value */
2820 # if __WORDSIZE == 32
2821 if (jit_mips6_p()) SC_R6(r0, 0, r1);
2824 if (jit_mips6_p()) SCD_R6(r0, 0, r1);
2825 else SCD(r0, 0, r1);
2829 BEQ(r0, _ZERO_REGNO, 0); /* beqi retry r0 0 */
2830 movi(r0, 1); /* set to 1 in delay slot */
2836 patch_at(jump0, done);
2837 patch_at(jump1, retry);
2839 jit_unget_reg(r1_reg);
2843 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2846 if (can_sign_extend_short_p(i0))
2847 LB(r0, i0, _ZERO_REGNO);
2849 reg = jit_get_reg(jit_class_gpr);
2857 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2860 if (can_sign_extend_short_p(i0))
2861 LBU(r0, i0, _ZERO_REGNO);
2863 reg = jit_get_reg(jit_class_gpr);
2865 ldr_uc(r0, rn(reg));
2871 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2874 if (can_sign_extend_short_p(i0))
2875 LH(r0, i0, _ZERO_REGNO);
2877 reg = jit_get_reg(jit_class_gpr);
2885 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2888 if (can_sign_extend_short_p(i0))
2889 LHU(r0, i0, _ZERO_REGNO);
2891 reg = jit_get_reg(jit_class_gpr);
2893 ldr_us(r0, rn(reg));
2899 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2903 if (jit_mips6_p()) {
2906 w = (i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 2;
2907 if (can_sign_extend_i19_p(w)) {
2913 if (can_sign_extend_short_p(i0))
2914 LW(r0, i0, _ZERO_REGNO);
2916 reg = jit_get_reg(jit_class_gpr);
2926 #if __WORDSIZE == 64
2928 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2932 if (jit_mips6_p()) {
2935 w = (i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 2;
2936 if (can_sign_extend_i19_p(w)) {
2942 if (can_sign_extend_short_p(i0))
2943 LWU(r0, i0, _ZERO_REGNO);
2945 reg = jit_get_reg(jit_class_gpr);
2947 ldr_ui(r0, rn(reg));
2956 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2960 if (jit_mips6_p()) {
2962 w = (i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 3;
2963 if (can_sign_extend_i18_p(w)) {
2968 if (can_sign_extend_short_p(i0))
2969 LD(r0, i0, _ZERO_REGNO);
2971 reg = jit_get_reg(jit_class_gpr);
2981 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
2988 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2990 if (can_sign_extend_short_p(i0))
2999 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3006 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3008 if (can_sign_extend_short_p(i0))
3017 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3024 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3026 if (can_sign_extend_short_p(i0))
3035 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3042 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3044 if (can_sign_extend_short_p(i0))
3053 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3060 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3062 if (can_sign_extend_short_p(i0))
3070 #if __WORDSIZE == 64
3072 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3079 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3081 if (can_sign_extend_short_p(i0))
3090 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3097 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3099 if (can_sign_extend_short_p(i0))
3108 #if __WORDSIZE == 32
3109 # define LOAD_LEFT LWL
3110 # define LOAD_RIGHT LWR
3112 # define LOAD_LEFT LDL
3113 # define LOAD_RIGHT LDR
3116 _unldr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3119 if (jit_unaligned_p()) {
3120 assert(i0 >= 1 && i0 <= sizeof(jit_word_t));
3125 t0 = jit_get_reg(jit_class_gpr);
3131 #if __BYTE_ORDER == __LITTLE_ENDIAN
3132 LOAD_LEFT(r0, sizeof(jit_word_t) - 1, r2);
3133 LOAD_RIGHT(r0, 0, r2);
3135 LOAD_LEFT(r0, 0, r2);
3136 LOAD_RIGHT(r0, sizeof(jit_word_t) - 1, r2);
3142 #if __BYTE_ORDER == __LITTLE_ENDIAN
3145 rshi(r0, r0, __WORDSIZE - 16);
3149 #if __BYTE_ORDER == __LITTLE_ENDIAN
3150 lshi(r0, r0, __WORDSIZE - 24);
3152 rshi(r0, r0, __WORDSIZE - 24);
3154 #if __WORDSIZE == 32
3158 # if __BYTE_ORDER == __LITTLE_ENDIAN
3161 rshi(r0, r0, __WORDSIZE - 32);
3165 #if __WORDSIZE == 64
3167 # if __BYTE_ORDER == __LITTLE_ENDIAN
3168 lshi(r0, r0, __WORDSIZE - 40);
3170 rshi(r0, r0, __WORDSIZE - 40);
3173 # if __BYTE_ORDER == __LITTLE_ENDIAN
3174 lshi(r0, r0, __WORDSIZE - 48);
3176 rshi(r0, r0, __WORDSIZE - 48);
3179 # if __BYTE_ORDER == __LITTLE_ENDIAN
3180 lshi(r0, r0, __WORDSIZE - 56);
3182 rshi(r0, r0, __WORDSIZE - 56);
3191 generic_unldr(r0, r1, i0);
3195 _unldi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
3198 if (jit_unaligned_p()) {
3199 t0 = jit_get_reg(jit_class_gpr);
3201 unldr(r0, rn(t0), i1);
3205 generic_unldi(r0, i0, i1);
3209 _unldr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3212 if (jit_unaligned_p()) {
3213 assert(i0 >= 1 && i0 <= sizeof(jit_word_t));
3218 t0 = jit_get_reg(jit_class_gpr);
3224 #if __BYTE_ORDER == __LITTLE_ENDIAN
3225 LOAD_LEFT(r0, sizeof(jit_word_t) - 1, r2);
3226 LOAD_RIGHT(r0, 0, r2);
3228 LOAD_LEFT(r0, 0, r2);
3229 LOAD_RIGHT(r0, sizeof(jit_word_t) - 1, r2);
3235 #if __BYTE_ORDER == __LITTLE_ENDIAN
3238 rshi_u(r0, r0, __WORDSIZE - 16);
3242 #if __BYTE_ORDER == __LITTLE_ENDIAN
3243 lshi(r0, r0, __WORDSIZE - 24);
3245 rshi_u(r0, r0, __WORDSIZE - 24);
3247 #if __WORDSIZE == 32
3251 # if __BYTE_ORDER == __LITTLE_ENDIAN
3254 rshi_u(r0, r0, __WORDSIZE - 32);
3258 #if __WORDSIZE == 64
3260 # if __BYTE_ORDER == __LITTLE_ENDIAN
3261 lshi(r0, r0, __WORDSIZE - 40);
3263 rshi_u(r0, r0, __WORDSIZE - 40);
3266 # if __BYTE_ORDER == __LITTLE_ENDIAN
3267 lshi(r0, r0, __WORDSIZE - 48);
3269 rshi_u(r0, r0, __WORDSIZE - 48);
3272 # if __BYTE_ORDER == __LITTLE_ENDIAN
3273 lshi(r0, r0, __WORDSIZE - 56);
3275 rshi_u(r0, r0, __WORDSIZE - 56);
3284 generic_unldr_u(r0, r1, i0);
3290 _unldi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
3293 if (jit_unaligned_p()) {
3294 t0 = jit_get_reg(jit_class_gpr);
3296 unldr_u(r0, rn(t0), i1);
3300 generic_unldi_u(r0, i0, i1);
3304 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3307 if (can_sign_extend_short_p(i0))
3308 SB(r0, i0, _ZERO_REGNO);
3310 reg = jit_get_reg(jit_class_gpr);
3318 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3321 if (can_sign_extend_short_p(i0))
3322 SH(r0, i0, _ZERO_REGNO);
3324 reg = jit_get_reg(jit_class_gpr);
3332 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3335 if (can_sign_extend_short_p(i0))
3336 SW(r0, i0, _ZERO_REGNO);
3338 reg = jit_get_reg(jit_class_gpr);
3345 #if __WORDSIZE == 64
3347 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3350 if (can_sign_extend_short_p(i0))
3351 SD(r0, i0, _ZERO_REGNO);
3353 reg = jit_get_reg(jit_class_gpr);
3362 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3365 reg = jit_get_reg(jit_class_gpr);
3366 addr(rn(reg), r0, r1);
3372 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3375 if (can_sign_extend_short_p(i0))
3378 reg = jit_get_reg(jit_class_gpr);
3379 addi(rn(reg), r0, i0);
3386 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3389 reg = jit_get_reg(jit_class_gpr);
3390 addr(rn(reg), r0, r1);
3396 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3399 if (can_sign_extend_short_p(i0))
3402 reg = jit_get_reg(jit_class_gpr);
3403 addi(rn(reg), r0, i0);
3410 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3413 reg = jit_get_reg(jit_class_gpr);
3414 addr(rn(reg), r0, r1);
3420 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3423 if (can_sign_extend_short_p(i0))
3426 reg = jit_get_reg(jit_class_gpr);
3427 addi(rn(reg), r0, i0);
3433 #if __WORDSIZE == 64
3435 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
3438 reg = jit_get_reg(jit_class_gpr);
3439 addr(rn(reg), r0, r1);
3445 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3448 if (can_sign_extend_short_p(i0))
3451 reg = jit_get_reg(jit_class_gpr);
3452 addi(rn(reg), r0, i0);
3460 _unstr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3462 assert(i0 > 0 && i0 <= sizeof(jit_word_t));
3463 if (jit_unaligned_p()) {
3466 #if __BYTE_ORDER == __LITTLE_ENDIAN
3474 #if __WORDSIZE == 64
3476 # if __BYTE_ORDER == __LITTLE_ENDIAN
3486 /* FIXME Cost of loading memory contents, creating masks,
3487 * and'ing, and or'ing values to use SW* or SD* might
3488 * larger than using fallback. */
3489 /* FIXME Probably not, and would be without branches. */
3490 fallback_unstr(r0, r1, i0);
3495 generic_unstr(r0, r1, i0);
3499 _unsti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
3502 if (jit_unaligned_p()) {
3503 if (i1 == 4 || i1 == 8) {
3504 reg = jit_get_reg(jit_class_gpr);
3506 unstr(rn(reg), r0, i1);
3510 fallback_unsti(i0, r0, i1);
3513 generic_unsti(i0, r0, i1);
3517 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3519 if (jit_mips2_p()) {
3523 generic_bswapr_us(_jit, r0, r1);
3528 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3530 if (jit_mips2_p()) {
3531 if (__WORDSIZE == 64) {
3535 mips_extr(r0, r0, 0, 32);
3541 generic_bswapr_ui(_jit, r0, r1);
3545 #if __WORDSIZE == 64
3547 _bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3549 if (jit_mips2_p()) {
3554 generic_bswapr_ul(_jit, r0, r1);
3559 _extr(jit_state_t *_jit,
3560 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3562 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3563 if ( i1 == __WORDSIZE)
3566 # if __BYTE_ORDER == __BIG_ENDIAN
3567 i0 = __WORDSIZE - (i0 + i1);
3569 if (__WORDSIZE - (i0 + i1)) {
3570 lshi(r0, r1, __WORDSIZE - (i0 + i1));
3571 rshi(r0, r0, __WORDSIZE - i1);
3574 rshi(r0, r1, __WORDSIZE - i1);
3579 _extr_u(jit_state_t *_jit,
3580 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3582 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3583 if (jit_mips2_p()) {
3584 if (i1 == __WORDSIZE)
3587 # if __BYTE_ORDER == __BIG_ENDIAN
3588 i0 = __WORDSIZE - (i0 + i1);
3590 #if __WORDSIZE == 32
3591 EXT(r0, r1, i0, i1);
3593 if (i0 < 32 && i1 <= 32)
3594 DEXT(r0, r1, i0, i1);
3595 else if (i0 < 32 && i1 > 32)
3596 DEXTM(r0, r1, i0, i1);
3598 assert(i0 >= 32 && i1 <= 32);
3599 DEXTU(r0, r1, i0, i1);
3605 fallback_ext_u(r0, r1, i0, i1);
3609 _depr(jit_state_t *_jit,
3610 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3612 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3613 if (jit_mips2_p()) {
3614 if (i1 == __WORDSIZE)
3617 # if __BYTE_ORDER == __BIG_ENDIAN
3618 i0 = __WORDSIZE - (i0 + i1);
3620 #if __WORDSIZE == 32
3621 INS(r0, r1, i0, i1);
3623 if (i0 < 32 && i1 <= 32 && (i0 + i1) <= 32)
3624 DINS(r0, r1, i0, i1);
3625 else if (i0 < 32 && i1 >= 2 && (i0 + i1) > 32)
3626 DINSM(r0, r1, i0, i1);
3628 assert(i0 >= 32 && i1 >= 1 && i1 <= 32 && (i0 + i1) > 32);
3629 DINSU(r0, r1, i0, i1);
3635 fallback_dep(r0, r1, i0, i1);
3639 _extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3644 lshi(r0, r1, __WORDSIZE - 8);
3645 rshi(r0, r0, __WORDSIZE - 8);
3650 _extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3655 lshi(r0, r1, __WORDSIZE - 16);
3656 rshi(r0, r0, __WORDSIZE - 16);
3660 # if __WORDSIZE == 64
3662 _extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3665 DEXT(r0, r1, 0, 32);
3674 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3678 if (can_sign_extend_short_p(i0))
3681 reg = jit_get_reg(jit_class_gpr);
3683 ltr(r0, r1, rn(reg));
3689 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3693 if (can_sign_extend_short_p(i0))
3696 reg = jit_get_reg(jit_class_gpr);
3698 ltr_u(r0, r1, rn(reg));
3704 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3711 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3715 if (can_sign_extend_short_p(i0 + 1))
3716 SLTI(r0, r1, i0 + 1);
3718 reg = jit_get_reg(jit_class_gpr);
3720 ler(r0, r1, rn(reg));
3726 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3733 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3737 if (can_sign_extend_short_p(i0 + 1))
3738 SLTIU(r0, r1, i0 + 1);
3740 reg = jit_get_reg(jit_class_gpr);
3742 ler_u(r0, r1, rn(reg));
3748 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3755 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3766 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3773 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3777 if (can_sign_extend_short_p(i0)) {
3781 reg = jit_get_reg(jit_class_gpr);
3783 ger(r0, r1, rn(reg));
3789 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3796 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3800 if (can_sign_extend_short_p(i0)) {
3804 reg = jit_get_reg(jit_class_gpr);
3806 ger_u(r0, r1, rn(reg));
3812 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3817 SLT(r0, _ZERO_REGNO, r1);
3819 reg = jit_get_reg(jit_class_gpr);
3821 SLT(r0, rn(reg), r1);
3827 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3832 SLTU(r0, _ZERO_REGNO, r1);
3834 reg = jit_get_reg(jit_class_gpr);
3836 SLTU(r0, rn(reg), r1);
3842 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3845 SLTU(r0, _ZERO_REGNO, r0);
3849 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3853 SLTU(r0, _ZERO_REGNO, r0);
3856 SLTU(r0, _ZERO_REGNO, r1);
3860 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3863 jit_int32_t op, reg;
3864 /* Just to not move incorrectly instruction to delay slot */
3865 reg = jit_get_reg_for_delay_slot(jit_class_gpr|jit_class_chk, r0, r1);
3867 /* implicit flush() */
3869 BEQ(r0, r1, ((i0 - w) >> 2) - 1);
3871 if (reg != JIT_NOREG)
3877 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
3880 jit_int32_t op, reg;
3882 w = beqr(i0, r0, _ZERO_REGNO);
3884 reg = jit_get_reg_for_delay_slot(jit_class_gpr, r0, _ZERO_REGNO);
3889 BEQ(r0, rn(reg), ((i0 - w) >> 2) - 1);
3897 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
3901 jit_int32_t op, reg;
3902 reg = jit_get_reg_for_delay_slot(jit_class_gpr, r0, r1);
3905 SLTU(rn(reg), r0, r1);
3907 SLT(rn(reg), r0, r1);
3910 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
3917 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
3918 jit_bool_t sltiu, jit_bool_t bne)
3923 jit_int32_t op, t0, mask;
3924 zero_p = !sltiu && i1 == 0;
3925 /* Even if zero_p allocate one as a mean to avoid incorrect delay slot */
3926 mask = jit_class_gpr;
3928 mask |= jit_class_chk;
3929 t0 = jit_get_reg_for_delay_slot(mask, r0, _ZERO_REGNO);
3930 if (can_sign_extend_short_p(i1)) {
3934 SLTIU(rn(t0), r0, i1);
3936 SLTI(rn(t0), r0, i1);
3940 d = ((i0 - w) >> 2) - 1;
3943 BNE(rn(t0), _ZERO_REGNO, d);
3949 BEQ(rn(t0), _ZERO_REGNO, d);
3958 SLTU(rn(t0), r0, rn(t0));
3960 SLT(rn(t0), r0, rn(t0));
3964 BNE(rn(t0), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
3966 BEQ(rn(t0), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
3969 if (t0 != JIT_NOREG)
3975 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1,
3976 jit_bool_t sltu, jit_bool_t inv)
3979 jit_int32_t op, reg;
3980 reg = jit_get_reg_for_delay_slot(jit_class_gpr, r0, r1);
3983 SLTU(rn(reg), r1, r0);
3985 SLT(rn(reg), r1, r0);
3989 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
3991 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
3998 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1,
3999 jit_bool_t sltiu, jit_bool_t inv)
4002 jit_int32_t op, t0, mask;
4003 mask = jit_class_gpr;
4005 mask |= jit_class_chk;
4006 /* Allocate even if i0 == 0 as a way to avoid incorrect delay slot */
4007 t0 = jit_get_reg_for_delay_slot(mask, r0, _ZERO_REGNO);
4010 /* implicit flush() */
4014 BEQ(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4016 BLEZ(r0, ((i0 - w) >> 2) - 1);
4020 BNE(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4022 BGTZ(r0, ((i0 - w) >> 2) - 1);
4029 SLTU(rn(t0), rn(t0), r0);
4031 SLT(rn(t0), rn(t0), r0);
4035 BEQ(rn(t0), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4037 BNE(rn(t0), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4040 if (t0 != JIT_NOREG)
4046 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4049 jit_int32_t op, reg;
4050 /* Just to not move incorrectly instruction to delay slot */
4051 reg = jit_get_reg_for_delay_slot(jit_class_gpr|jit_class_chk, r0, r1);
4053 /* implicit flush() */
4055 BNE(r0, r1, ((i0 - w) >> 2) - 1);
4057 if (reg != JIT_NOREG)
4063 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4066 jit_int32_t op, reg;
4068 w = bner(i0, r0, _ZERO_REGNO);
4070 reg = jit_get_reg_for_delay_slot(jit_class_gpr, r0, _ZERO_REGNO);
4075 BNE(r0, rn(reg), ((i0 - w) >> 2) - 1);
4083 _jmpr(jit_state_t *_jit, jit_int32_t r0)
4086 /* make sure delay slot does not use r0 */
4087 t0 = jit_get_reg_for_delay_slot(jit_class_gpr|jit_class_chk,
4092 if (t0 != JIT_NOREG)
4097 _jmpi(jit_state_t *_jit, jit_word_t i0, jit_bool_t patch)
4102 if (jit_mips6_p() && !(i0 & 3)) {
4103 disp = ((i0 - (_jit->pc.w + (_jitc->inst.pend ? 4 : 0))) >> 2) - 1;
4104 if (patch || can_sign_extend_i26_p(disp)) {
4107 /* Compact branch instructions do not have a delay slot */
4109 goto done_without_delay;
4113 /* try to get a pending instruction before the jump */
4114 t0 = jit_get_reg_for_delay_slot(jit_class_gpr, _ZERO_REGNO, _ZERO_REGNO);
4116 /* implicit flush() */
4118 if (jit_mips2_p()) {
4119 disp = ((i0 - w) >> 2) - 1;
4120 if (patch || can_sign_extend_short_p(disp)) {
4121 BEQ(_ZERO_REGNO, _ZERO_REGNO, disp);
4125 if (((w + sizeof(jit_int32_t)) & 0xf0000000) == (i0 & 0xf0000000))
4126 J((i0 & ~0xf0000000) >> 2);
4129 w = movi_p(rn(t0), i0);
4144 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
4148 /* Get a register without side effects in delay slot */
4149 t0 = jit_get_reg_for_delay_slot(jit_class_gpr, _ZERO_REGNO, _ZERO_REGNO);
4150 /* Check for a instruction that can be executed in the delay slot */
4152 /* implicit flush() */
4155 flush(); /* movi_p will be patched */
4163 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4170 /* t1 = r0 + r1; overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
4171 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4172 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4173 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4174 SLT(rn(t0), r1, _ZERO_REGNO); /* t0 = r1 < 0 */
4175 addr(rn(t1), r0, r1); /* t1 = r0 + r1 */
4176 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
4177 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
4178 movzr(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
4179 /* cannot optimize delay slot */
4182 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4194 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4201 if (can_sign_extend_short_p(i1)) {
4202 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4203 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4204 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4205 SLTI(rn(t0), _ZERO_REGNO, i1);
4206 addiu(rn(t1), r0, i1);
4207 SLT(rn(t2), r0, rn(t1));
4208 SLT(rn(t1), rn(t1), r0);
4209 movzr(rn(t1), rn(t2), rn(t0));
4210 /* cannot optimize delay slot */
4213 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4222 t0 = jit_get_reg(jit_class_gpr);
4224 w = boaddr(i0, r0, rn(t0));
4231 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4237 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4238 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4239 addr(rn(t0), r0, r1);
4240 SLTU(rn(t1), rn(t0), r0);
4242 /* cannot optimize delay slot */
4244 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4254 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4260 if (can_sign_extend_short_p(i0)) {
4261 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4262 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4263 addiu(rn(t0), r0, i1);
4264 SLTU(rn(t1), rn(t0), r0);
4266 /* cannot optimize delay slot */
4268 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4276 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4278 w = boaddr_u(i0, r0, rn(t0));
4285 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4292 /* t1 = r0 + r1; overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
4293 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4294 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4295 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4296 SLT(rn(t0), r1, _ZERO_REGNO); /* t0 = r1 < 0 */
4297 addr(rn(t1), r0, r1); /* t1 = r0 + r1 */
4298 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
4299 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
4300 movzr(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
4301 /* cannot optimize delay slot */
4304 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4316 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4323 if (can_sign_extend_short_p(i1)) {
4324 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4325 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4326 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4327 SLTI(rn(t0), _ZERO_REGNO, i1);
4328 addiu(rn(t1), r0, i1);
4329 SLT(rn(t2), r0, rn(t1));
4330 SLT(rn(t1), rn(t1), r0);
4331 movzr(rn(t1), rn(t2), rn(t0));
4332 /* cannot optimize delay slot */
4335 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4344 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4346 w = bxaddr(i0, r0, rn(t0));
4353 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4359 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4360 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4361 addr(rn(t0), r0, r1);
4362 SLTU(rn(t1), rn(t0), r0);
4363 /* cannot optimize delay slot */
4366 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4376 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4382 if (can_sign_extend_short_p(i0)) {
4383 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4384 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4385 addiu(rn(t0), r0, i1);
4386 SLTU(rn(t1), rn(t0), r0);
4387 /* cannot optimize delay slot */
4390 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4398 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4400 w = bxaddr_u(i0, r0, rn(t0));
4407 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4414 /* t1 = r0 - r1; overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
4415 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4416 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4417 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4418 SLT(rn(t0), _ZERO_REGNO, r1); /* t0 = 0 < r1 */
4419 subr(rn(t1), r0, r1); /* t1 = r0 - r1 */
4420 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
4421 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
4422 movzr(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
4425 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4437 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4444 if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
4445 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4446 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4447 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4448 SLTI(rn(t0), _ZERO_REGNO, i1);
4449 addiu(rn(t1), r0, -i1);
4450 SLT(rn(t2), rn(t1), r0);
4451 SLT(rn(t1), r0, rn(t1));
4452 movzr(rn(t1), rn(t2), rn(t0));
4455 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4464 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4466 w = bosubr(i0, r0, rn(t0));
4473 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4479 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4480 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4481 subr(rn(t0), r0, r1);
4482 SLTU(rn(t1), r0, rn(t0));
4483 /* cannot optimize delay slot */
4486 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4496 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4502 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
4503 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4504 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4505 addiu(rn(t0), r0, -i1);
4506 SLTU(rn(t1), r0, rn(t0));
4507 /* cannot optimize delay slot */
4510 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4518 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4520 w = bosubr_u(i0, r0, rn(t0));
4527 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4534 /* t1 = r0 - r1; overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
4535 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4536 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4537 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4538 SLT(rn(t0), _ZERO_REGNO, r1); /* t0 = 0 < r1 */
4539 subr(rn(t1), r0, r1); /* t1 = r0 - r1 */
4540 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
4541 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
4542 movzr(rn(t1), rn(t2), rn(t0)); /* if (t0 == 0) t1 = t2 */
4543 /* cannot optimize delay slot */
4546 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4558 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4565 if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
4566 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4567 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4568 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4569 SLTI(rn(t0), _ZERO_REGNO, i1);
4570 addiu(rn(t1), r0, -i1);
4571 SLT(rn(t2), rn(t1), r0);
4572 SLT(rn(t1), r0, rn(t1));
4573 movzr(rn(t1), rn(t2), rn(t0));
4574 /* cannot optimize delay slot */
4577 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
4586 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4588 w = bxsubr(i0, r0, rn(t0));
4595 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4601 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4602 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4603 subr(rn(t0), r0, r1);
4604 SLTU(rn(t1), r0, rn(t0));
4605 /* cannot optimize delay slot */
4608 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4618 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4624 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
4625 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4626 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4627 addiu(rn(t0), r0, -i1);
4628 SLTU(rn(t1), r0, rn(t0));
4629 /* cannot optimize delay slot */
4632 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
4640 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
4642 w = bxsubr_u(i0, r0, rn(t0));
4649 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4653 t0 = jit_get_reg_for_delay_slot(jit_class_gpr, r0, r1);
4655 AND(rn(t0), r0, r1);
4658 BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
4665 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4669 t0 = jit_get_reg_for_delay_slot(jit_class_gpr, r0, _ZERO_REGNO);
4671 andi(rn(t0), r0, i1);
4674 BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
4681 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
4685 t0 = jit_get_reg_for_delay_slot(jit_class_gpr, r0, r1);
4687 AND(rn(t0), r0, r1);
4690 BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
4697 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
4701 t0 = jit_get_reg_for_delay_slot(jit_class_gpr, r0, _ZERO_REGNO);
4703 andi(rn(t0), r0, i1);
4706 BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
4713 _callr(jit_state_t *_jit, jit_int32_t r0)
4716 if (r0 != _T9_REGNO) {
4719 movr(_T9_REGNO, r0);
4723 /* make sure delay slot does not use r0 */
4724 t0 = jit_get_reg_for_delay_slot(jit_class_gpr|jit_class_chk,
4729 if (t0 != JIT_NOREG)
4735 _calli(jit_state_t *_jit, jit_word_t i0, jit_bool_t patch)
4741 if (jit_mips6_p() && !(i0 & 3)) {
4742 disp = ((i0 - (w + (_jitc->inst.pend ? 4 : 0))) >> 2) - 1;
4743 if (patch || can_sign_extend_i26_p(disp)) {
4746 /* Compact branch instructions do not have a delay slot */
4752 if (jit_mips2_p()) {
4753 disp = ((i0 - (w + _jitc->inst.pend ? 4 : 0)) >> 2) - 1;
4754 if (patch || can_sign_extend_short_p(disp)) {
4756 BGEZAL(_ZERO_REGNO, disp); /* Renamed to BAL in mips release 6 */
4763 if (((w + sizeof(jit_int32_t)) & 0xf0000000) == (i0 & 0xf0000000)) {
4764 if (can_sign_extend_short_p(i0)) {
4765 JAL((i0 & ~0xf0000000) >> 2);
4767 addiu(_T9_REGNO, _ZERO_REGNO, i0);
4769 else if (can_zero_extend_short_p(i0)) {
4770 JAL((i0 & ~0xf0000000) >> 2);
4772 ORI(_T9_REGNO, _ZERO_REGNO, i0);
4774 else if (can_sign_extend_int_p(i0)) {
4776 LUI(_T9_REGNO, i0 >> 16);
4777 JAL((i0 & ~0xf0000000) >> 2);
4779 ORI(_T9_REGNO, _T9_REGNO, i0);
4782 JAL((i0 & ~0xf0000000) >> 2);
4784 LUI(_T9_REGNO, i0 >> 16);
4792 /* make sure delay slot does not use _T9_REGNO */
4793 t0 = jit_get_reg_for_delay_slot(jit_class_gpr|jit_class_chk,
4794 _T9_REGNO, _ZERO_REGNO);
4795 /* try to get an instruction before the call */
4797 movi(_T9_REGNO, i0);
4800 if (t0 != JIT_NOREG)
4808 _calli_p(jit_state_t *_jit, jit_word_t i0)
4812 /* make sure delay slot does not use _T9_REGNO */
4813 t0 = jit_get_reg_for_delay_slot(jit_class_gpr|jit_class_chk,
4814 _T9_REGNO, _ZERO_REGNO);
4816 /* implicit flush() */
4818 movi_p(_T9_REGNO, i0);
4821 if (t0 != JIT_NOREG)
4827 _prolog(jit_state_t *_jit, jit_node_t *node)
4829 jit_int32_t reg, offs;
4830 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
4831 jit_int32_t frame = -_jitc->function->frame;
4833 assert(_jitc->function->self.aoff >= frame);
4834 if (_jitc->function->assume_frame)
4836 _jitc->function->self.aoff = frame;
4838 if (_jitc->function->allocar)
4839 _jitc->function->self.aoff &= -8;
4841 _jitc->function->stack = ((_jitc->function->self.alen -
4842 /* align stack at 16 bytes */
4843 _jitc->function->self.aoff) + 15) & -16;
4845 _jitc->function->stack = ((/* first 16 bytes must be allocated */
4846 (_jitc->function->self.alen > 16 ?
4847 _jitc->function->self.alen : 16) -
4848 /* align stack at 8 bytes */
4849 _jitc->function->self.aoff) + 7) & -8;
4853 if (_jitc->function->stack)
4854 _jitc->function->need_stack = 1;
4855 if (!_jitc->function->need_frame && !_jitc->function->need_stack) {
4856 /* check if any callee save register needs to be saved */
4857 for (reg = 0; reg < _jitc->reglen; ++reg)
4858 if (jit_regset_tstbit(&_jitc->function->regset, reg) &&
4859 (_rvs[reg].spec & jit_class_sav)) {
4860 _jitc->function->need_stack = 1;
4865 /* Need always a frame due to the need to always allocate 16 bytes */
4869 if (_jitc->function->need_frame || _jitc->function->need_stack)
4870 subi(_SP_REGNO, _SP_REGNO, jit_framesize());
4871 if (_jitc->function->need_frame) {
4872 stxi(0, _SP_REGNO, _RA_REGNO);
4873 stxi(STACK_SLOT, _SP_REGNO, _BP_REGNO);
4875 /* callee save registers */
4876 for (reg = 0, offs = STACK_SLOT << 1; reg < jit_size(iregs); reg++) {
4877 if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
4878 stxi(offs, _SP_REGNO, rn(iregs[reg]));
4882 for (reg = 0; reg < jit_size(fregs); reg++) {
4883 if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
4884 stxi_d(offs, _SP_REGNO, rn(fregs[reg]));
4885 offs += sizeof(jit_float64_t);
4889 if (_jitc->function->need_frame)
4890 movr(_BP_REGNO, _SP_REGNO);
4893 if (_jitc->function->stack)
4894 subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
4895 if (_jitc->function->allocar) {
4896 reg = jit_get_reg(jit_class_gpr);
4897 movi(rn(reg), _jitc->function->self.aoff);
4898 stxi_i(_jitc->function->aoffoff, _BP_REGNO, rn(reg));
4902 if (_jitc->function->self.call & jit_call_varargs) {
4903 for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg) {
4904 offs = jit_framesize() - ((NUM_WORD_ARGS - reg) * STACK_SLOT);
4906 SD(rn(_A0 - reg), offs, _BP_REGNO);
4908 offs += 16 + WORD_ADJUST;
4909 stxi(offs, _BP_REGNO, rn(_A0 - reg));
4916 _epilog(jit_state_t *_jit, jit_node_t *node)
4918 jit_int32_t reg, offs;
4919 if (_jitc->function->assume_frame)
4922 if (_jitc->function->need_frame) {
4923 movr(_SP_REGNO, _BP_REGNO);
4924 ldxi(_RA_REGNO, _SP_REGNO, 0);
4925 ldxi(_BP_REGNO, _SP_REGNO, STACK_SLOT);
4928 /* callee save registers */
4929 for (reg = 0, offs = STACK_SLOT << 1; reg < jit_size(iregs); reg++) {
4930 if (jit_regset_tstbit(&_jitc->function->regset, iregs[reg])) {
4931 ldxi(rn(iregs[reg]), _SP_REGNO, offs);
4932 offs += sizeof(jit_word_t);
4935 for (reg = 0; reg < jit_size(fregs); reg++) {
4936 if (jit_regset_tstbit(&_jitc->function->regset, fregs[reg])) {
4937 ldxi_d(rn(fregs[reg]), _SP_REGNO, offs);
4938 offs += sizeof(jit_float64_t);
4943 if (_jitc->function->need_frame || _jitc->function->need_stack)
4944 addi(_SP_REGNO, _SP_REGNO, jit_framesize());
4951 _vastart(jit_state_t *_jit, jit_int32_t r0)
4953 assert(_jitc->function->self.call & jit_call_varargs);
4955 /* Initialize va_list to the first stack argument. */
4956 if (jit_arg_reg_p(_jitc->function->vagp))
4959 ((NUM_WORD_ARGS - _jitc->function->vagp) * STACK_SLOT));
4962 addi(r0, _BP_REGNO, jit_selfsize());
4966 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
4968 /* Load argument. */
4970 ldxi(r0, r1, WORD_ADJUST);
4975 /* Update va_list. */
4976 addi(r1, r1, STACK_SLOT);
4980 _patch_abs(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
4989 #if __WORDSIZE == 32
4991 assert(i.hc.b == MIPS_LUI);
4992 i.is.b = label >> 16;
4995 assert(i.hc.b == MIPS_ORI);
5000 assert(i.hc.b == MIPS_LUI);
5001 i.is.b = label >> 48;
5004 assert(i.hc.b == MIPS_ORI);
5005 i.is.b = label >> 32;
5009 assert(i.hc.b == MIPS_ORI);
5010 i.is.b = label >> 16;
5014 assert(i.hc.b == MIPS_ORI);
5021 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
5032 /* 16 bit immediate opcodes */
5035 case MIPS_BLTZ: case MIPS_BLTZL:
5036 case MIPS_BLTZAL: case MIPS_BLTZALL:
5037 case MIPS_BGEZ: case MIPS_BGEZAL:
5038 case MIPS_BGEZALL: case MIPS_BGEZL:
5039 case MIPS_TEQI: case MIPS_TGEI:
5040 case MIPS_TGEIU: case MIPS_TLTI:
5041 case MIPS_TLTIU: case MIPS_TNEI:
5042 i.is.b = ((label - instr) >> 2) - 1;
5046 assert(!"unhandled branch opcode");
5051 case MIPS_COP1: case MIPS_COP2:
5052 if (jit_mips6_p()) {
5054 case MIPS_BC1EQZ: case MIPS_BC1NEZ:
5055 assert(jit_mips6_p());
5056 i.is.b = ((label - instr) >> 2) - 1;
5060 assert(!"unhandled branch opcode");
5065 assert(i.rs.b == MIPS_BC);
5067 case MIPS_BCF: case MIPS_BCFL:
5068 case MIPS_BCT: case MIPS_BCTL:
5069 assert(!jit_mips6_p());
5070 i.is.b = ((label - instr) >> 2) - 1;
5074 assert(!"unhandled branch opcode");
5080 case MIPS_BLEZ: case MIPS_BLEZL:
5081 case MIPS_BEQ: case MIPS_BEQL:
5082 case MIPS_BGTZ: case MIPS_BGTZL:
5083 case MIPS_BNE: case MIPS_BNEL:
5084 i.is.b = ((label - instr) >> 2) - 1;
5089 patch_abs(instr, label);
5092 case MIPS_J: case MIPS_JAL:
5094 assert(((instr + sizeof(jit_int32_t)) & 0xf0000000) ==
5095 (label & 0xf0000000));
5096 i.ii.b = (label & ~0xf0000000) >> 2;
5100 case MIPS_BALC: case MIPS_BC_R6:
5101 assert(jit_mips6_p());
5102 i.ii.b = ((label - instr) >> 2) - 1;
5107 assert(!"unhandled branch opcode");