notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Makefile: Fix build on Windows and Android
[pcsx_rearmed.git] / deps / lightning / lib / jit_mips-cpu.c
CommitLineData
4a71579b
PC		 1/*
2 * Copyright (C) 2012-2019 Free Software Foundation, Inc.
3 *
4 * This file is part of GNU lightning.
5 *
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
9 * any later version.
10 *
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
15 *
16 * Authors:
17 * Paulo Cesar Pereira de Andrade
18 */
19
20#if PROTO
21typedef union {
22#if __BYTE_ORDER == __LITTLE_ENDIAN
23 struct { jit_uint32_t _:26; jit_uint32_t b : 6; } hc;
24 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } rs;
25 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fm;
26 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rt;
27 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } ft;
28 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rd;
29 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } fs;
30 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } ic;
31 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fd;
32 struct { jit_uint32_t _: 6; jit_uint32_t b : 10; } tr;
33 struct { jit_uint32_t _: 6; jit_uint32_t b : 20; } br;
34 struct { jit_uint32_t b : 6; } tc;
35 struct { jit_uint32_t b : 11; } cc;
36 struct { jit_uint32_t b : 16; } is;
37 struct { jit_uint32_t b : 26; } ii;
38#else
39 struct { jit_uint32_t b : 6; } hc;
40 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } rs;
41 struct { jit_uint32_t _: 6; jit_uint32_t b : 5; } fm;
42 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } rt;
43 struct { jit_uint32_t _:11; jit_uint32_t b : 5; } ft;
44 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } rd;
45 struct { jit_uint32_t _:16; jit_uint32_t b : 5; } fs;
46 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } ic;
47 struct { jit_uint32_t _:21; jit_uint32_t b : 5; } fd;
48 struct { jit_uint32_t _:21; jit_uint32_t b : 10; } tr;
49 struct { jit_uint32_t _:21; jit_uint32_t b : 20; } br;
50 struct { jit_uint32_t _:26; jit_uint32_t b : 6; } tc;
51 struct { jit_uint32_t _:21; jit_uint32_t b : 11; } cc;
52 struct { jit_uint32_t _:16; jit_uint32_t b : 16; } is;
53 struct { jit_uint32_t _: 6; jit_uint32_t b : 26; } ii;
54#endif
55 int op;
56} jit_instr_t;
57/* FIXME */
58# define jit_mips2_p() 0
59# define _ZERO_REGNO 0
60# define _T0_REGNO 0x08
61# define _T1_REGNO 0x09
62# define _T2_REGNO 0x0a
63# define _T3_REGNO 0x0b
64# define _T4_REGNO 0x0c
65# define _T5_REGNO 0x0d
66# define _T6_REGNO 0x0e
67# define _T7_REGNO 0x0f
68# define _S0_REGNO 0x10
69# define _S1_REGNO 0x11
70# define _S2_REGNO 0x12
71# define _S3_REGNO 0x13
72# define _S4_REGNO 0x14
73# define _S5_REGNO 0x15
74# define _S6_REGNO 0x16
75# define _S7_REGNO 0x17
76# define _T8_REGNO 0x18
77# define _T9_REGNO 0x19
78# define _SP_REGNO 0x1d
79# define _BP_REGNO 0x1e
80# define _RA_REGNO 0x1f
81# define _F16_REGNO 16
82# define _F18_REGNO 18
83# define _F20_REGNO 20
84# define _F22_REGNO 22
85# define _F24_REGNO 24
86# define _F26_REGNO 26
87# define _F28_REGNO 28
88# define _F30_REGNO 30
89# if __WORDSIZE == 32
90# if NEW_ABI
91# define stack_framesize 144
92# else
93# define stack_framesize 112
94# endif
95# define ldr(u,v) ldr_i(u,v)
96# define ldi(u,v) ldi_i(u,v)
97# define ldxi(u,v,w) ldxi_i(u,v,w)
98# define sti(u,v) sti_i(u,v)
99# define stxi(u,v,w) stxi_i(u,v,w)
100# else
101# define stack_framesize 144
102# define ldr(u,v) ldr_l(u,v)
103# define ldi(u,v) ldi_l(u,v)
104# define ldxi(u,v,w) ldxi_l(u,v,w)
105# define sti(u,v) sti_l(u,v)
106# define stxi(u,v,w) stxi_l(u,v,w)
107# endif
108# define can_sign_extend_short_p(im) ((im) >= -32678 && (im) <= 32767)
109# define can_zero_extend_short_p(im) ((im) >= 0 && (im) <= 65535)
519a9ea1
PC		 110# define is_low_mask(im) (((im) & 1) ? (__builtin_popcountl((im) + 1) == 1) : 0)
111# define is_high_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) == 0) : 0)
112# define masked_bits_count(im) __builtin_popcountl(im)
113# define unmasked_bits_count(im) (__WORDSIZE - masked_bits_count(im))
4a71579b
PC		 114# if __WORDSIZE == 32
115# define can_sign_extend_int_p(im) 1
116# define can_zero_extend_int_p(im) 1
117# else
118# define can_sign_extend_int_p(im) \
119 (((im) >= 0 && (im) <= 0x7fffffffL) || \
120 ((im) < 0 && (im) >= -0x80000000L))
121# define can_zero_extend_int_p(im) ((im) >= 0 && (im) <= 0xffffffff)
122# endif
123# define MIPS_SPECIAL 0x00
124# define MIPS_REGIMM 0x01
125# define MIPS_J 0x02
126# define MIPS_SRL 0x02
127# define MIPS_JAL 0x03
128# define MIPS_SRA 0x03
129# define MIPS_BEQ 0x04
130# define MIPS_BNE 0x05
131# define MIPS_BLEZ 0x06
132# define MIPS_BGTZ 0x07
133# define MIPS_ADDI 0x08
134# define MIPS_ADDIU 0x09
135# define MIPS_SLTI 0x0a
136# define MIPS_SLTIU 0x0b
137# define MIPS_ANDI 0x0c
138# define MIPS_ORI 0x0d
139# define MIPS_XORI 0x0e
140# define MIPS_LUI 0x0f
141# define MIPS_COP0 0x10
142# define MIPS_COP1 0x11
143# define MIPS_COP2 0x12
144# define MIPS_COP1X 0x13
145# define MIPS_BEQL 0x14
146# define MIPS_BNEL 0x15
147# define MIPS_BLEZL 0x16
148# define MIPS_BGTZL 0x17
149# define MIPS_DADDI 0x18
150# define MIPS_DADDIU 0x19
151# define MIPS_LDL 0x1a
152# define MIPS_LDR 0x1b
153# define MIPS_SPECIAL2 0x1c
154# define MIPS_JALX 0x1d
155# define MIPS_SPECIAL3 0x1f
156# define MIPS_LB 0x20
157# define MIPS_LH 0x21
158# define MIPS_LWL 0x22
159# define MIPS_LW 0x23
160# define MIPS_LBU 0x24
161# define MIPS_LHU 0x25
162# define MIPS_LWR 0x26
163# define MIPS_LWU 0x27
164# define MIPS_SB 0x28
165# define MIPS_SH 0x29
166# define MIPS_SWL 0x2a
167# define MIPS_SW 0x2b
168# define MIPS_SWR 0x2e
169# define MIPS_CACHE 0x2f
170# define MIPS_LL 0x30
171# define MIPS_LWC1 0x31
172# define MIPS_LWC2 0x32
173# define MIPS_PREF 0x33
174# define MIPS_LLD 0x34
175# define MIPS_LDC1 0x35
176# define MIPS_LDC2 0x36
177# define MIPS_LD 0x37
178# define MIPS_SC 0x38
179# define MIPS_SCD 0x3c
180# define MIPS_SDC1 0x3d
181# define MIPS_SDC2 0x3e
182# define MIPS_SWC1 0x39
183# define MIPS_SWC2 0x3a
184# define MIPS_SD 0x3f
185# define MIPS_MF 0x00
186# define MIPS_DMF 0x01
187# define MIPS_CF 0x02
188# define MIPS_MFH 0x03
189# define MIPS_MT 0x04
190# define MIPS_DMT 0x05
191# define MIPS_CT 0x06
192# define MIPS_MTH 0x07
193# define MIPS_BC 0x08
194# define MIPS_WRPGPR 0x0e
195# define MIPS_BGZAL 0x11
196# define MIPS_MFMC0 0x11
197# define MIPS_BCF 0x00
198# define MIPS_BLTZ 0x00
199# define MIPS_BCT 0x01
200# define MIPS_BGEZ 0x01
201# define MIPS_BCFL 0x02
202# define MIPS_BLTZL 0x02
203# define MIPS_BCTL 0x03
204# define MIPS_BGEZL 0x03
205# define MIPS_TGEI 0x08
206# define MIPS_TGEIU 0x09
207# define MIPS_TLTI 0x0a
208# define MIPS_TLTIU 0x0b
209# define MIPS_TEQI 0x0c
210# define MIPS_TNEI 0x0e
211# define MIPS_BLTZAL 0x10
212# define MIPS_BGEZAL 0x11
213# define MIPS_BLTZALL 0x12
214# define MIPS_BGEZALL 0x13
215# define MIPS_SYNCI 0x1f
216# define MIPS_WSBH 0x02
217# define MIPS_DBSH 0x02
218# define MIPS_DSHD 0x05
219# define MIPS_SEB 0x10
220# define MIPS_SEH 0x18
221# define MIPS_MADD 0x00
222# define MIPS_SLL 0x00
223# define MIPS_EXT 0x00
224# define MIPS_DEXTM 0x01
225# define MIPS_MADDU 0x01
226# define MIPS_MOVFT 0x01
227# define MIPS_TLBR 0x01
228# define MIPS_MUL 0x02
229# define MIPS_DEXTU 0x02
230# define MIPS_TLBWI 0x02
231# define MIPS_DEXT 0x03
232# define MIPS_SLLV 0x04
233# define MIPS_INS 0x04
234# define MIPS_MSUB 0x04
235# define MIPS_DINSM 0x05
236# define MIPS_MSUBU 0x05
237# define MIPS_SRLV 0x06
238# define MIPS_DINSU 0x06
239# define MIPS_TLBWR 0x06
240# define MIPS_SRAV 0x07
241# define MIPS_DINS 0x07
242# define MIPS_JR 0x08
243# define MIPS_TLBP 0x08
244# define MIPS_JALR 0x09
245# define MIPS_MOVZ 0x0a
246# define MIPS_MOVN 0x0b
247# define MIPS_SYSCALL 0x0c
248# define MIPS_BREAK 0x0d
249# define MIPS_PREFX 0x0f
250# define MIPS_SYNC 0x0f
251# define MIPS_MFHI 0x10
252# define MIPS_MTHI 0x11
253# define MIPS_MFLO 0x12
254# define MIPS_MTLO 0x13
255# define MIPS_DSLLV 0x14
256# define MIPS_DSRLV 0x16
257# define MIPS_DSRAV 0x17
258# define MIPS_MULT 0x18
259# define MIPS_ERET 0x18
260# define MIPS_MULTU 0x19
261# define MIPS_DIV 0x1a
262# define MIPS_DIVU 0x1b
263# define MIPS_DMULT 0x1c
264# define MIPS_DMULTU 0x1d
265# define MIPS_DDIV 0x1e
266# define MIPS_DDIVU 0x1f
267# define MIPS_DERET 0x1f
268# define MIPS_ADD 0x20
269# define MIPS_CLZ 0x20
270# define MIPS_BSHFL 0x20
271# define MIPS_ADDU 0x21
272# define MIPS_CLO 0x21
273# define MIPS_SUB 0x22
274# define MIPS_SUBU 0x23
275# define MIPS_AND 0x24
276# define MIPS_DCLZ 0x24
277# define MIPS_DBSHFL 0x24
278# define MIPS_OR 0x25
279# define MIPS_DCLO 0x25
280# define MIPS_XOR 0x26
281# define MIPS_NOR 0x27
282# define MIPS_SLT 0x2a
283# define MIPS_SLTU 0x2b
284# define MIPS_DADD 0x2c
285# define MIPS_DADDU 0x2d
286# define MIPS_DSUB 0x2e
287# define MIPS_DSUBU 0x2f
288# define MIPS_TGE 0x30
289# define MIPS_TGEU 0x31
290# define MIPS_TLT 0x32
291# define MIPS_TLTU 0x33
292# define MIPS_TEQ 0x34
293# define MIPS_TNE 0x36
294# define MIPS_DSLL 0x38
295# define MIPS_DSRL 0x3a
296# define MIPS_DSRA 0x3b
297# define MIPS_DSLL32 0x3c
298# define MIPS_DSRL32 0x3e
299# define MIPS_DSRA32 0x3f
300# define MIPS_SDBPP 0x3f
301# define ii(i) *_jit->pc.ui++ = i
302static void
303_hrrrit(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
304 jit_int32_t,jit_int32_t);
305# define hrrrit(hc,rs,rt,rd,im,tc) _hrrrit(_jit,hc,rs,rt,rd,im,tc)
306# define hrrr_t(hc,rs,rt,rd,tc) hrrrit(hc,rs,rt,rd,0,tc)
307# define rrr_t(rs,rt,rd,tc) hrrr_t(0,rs,rt,rd,tc)
308# define hrri(hc,rs,rt,im) _hrri(_jit,hc,rs,rt,im)
309static void _hrri(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
310# define hi(hc,im) _hi(_jit,hc,im)
311static void _hi(jit_state_t*,jit_int32_t,jit_int32_t);
312# define NOP(i0) ii(0)
313# define nop(i0) _nop(_jit,i0)
314static void _nop(jit_state_t*,jit_int32_t);
315# define h_ri(hc,rt,im) _hrri(_jit,hc,0,rt,im)
316# define rrit(rt,rd,im,tc) _hrrrit(_jit,0,0,rt,rd,im,tc)
317# define LUI(rt,im) h_ri(MIPS_LUI,rt,im)
318# define ADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_ADDU)
319# define DADDU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_DADDU)
320# define ADDIU(rt,rs,im) hrri(MIPS_ADDIU,rs,rt,im)
321# define DADDIU(rt,rs,im) hrri(MIPS_DADDIU,rs,rt,im)
322# define SUBU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SUBU)
323# define DSUBU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_DSUBU)
324# define MULT(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULT)
325# define MULTU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_MULTU)
326# define DMULT(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULT)
327# define DMULTU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DMULTU)
328# define DIV(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIV)
329# define DIVU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DIVU)
330# define DDIV(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIV)
331# define DDIVU(rs,rt) rrr_t(rs,rt,_ZERO_REGNO,MIPS_DDIVU)
332# define SLLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SLLV)
333# define SLL(rd,rt,sa) rrit(rt,rd,sa,MIPS_SLL)
334# define DSLLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSLLV)
335# define DSLL(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSLL)
336# define DSLL32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSLL32)
337# define SRAV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SRAV)
338# define SRA(rd,rt,sa) rrit(rt,rd,sa,MIPS_SRA)
339# define SRLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_SRLV)
340# define SRL(rd,rt,sa) rrit(rt,rd,sa,MIPS_SRL)
341# define DSRAV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSRAV)
342# define DSRA(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRA)
343# define DSRA32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRA32)
344# define DSRLV(rd,rt,rs) rrr_t(rs,rt,rd,MIPS_DSRLV)
345# define DSRL(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRL)
346# define DSRL32(rd,rt,sa) rrit(rt,rd,sa,MIPS_DSRL32)
519a9ea1
PC		 347# define INS(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_INS)
348# define DINS(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,pos+size-1,pos,MIPS_DINS)
349# define EXT(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_EXT)
350# define DEXT(rt,rs,pos,size) hrrrit(MIPS_SPECIAL3,rs,rt,size-1,pos,MIPS_DEXT)
4a71579b
PC		 351# define ROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_SRL)
352# define DROTR(rd,rt,sa) hrrrit(MIPS_SPECIAL,1,rt,rd,sa,MIPS_DSRL)
353# define MFHI(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFHI)
354# define MFLO(rd) rrr_t(_ZERO_REGNO,_ZERO_REGNO,rd,MIPS_MFLO)
355# define MTHI(rs) rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTHI)
356# define MTLO(rs) rrr_t(rs,_ZERO_REGNO,_ZERO_REGNO,MIPS_MTLO)
357# define AND(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_AND)
358# define ANDI(rt,rs,im) hrri(MIPS_ANDI,rs,rt,im)
359# define OR(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_OR)
360# define ORI(rt,rs,im) hrri(MIPS_ORI,rs,rt,im)
361# define XOR(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_XOR)
362# define XORI(rt,rs,im) hrri(MIPS_XORI,rs,rt,im)
363# define LB(rt,of,rb) hrri(MIPS_LB,rb,rt,of)
364# define LBU(rt,of,rb) hrri(MIPS_LBU,rb,rt,of)
365# define LH(rt,of,rb) hrri(MIPS_LH,rb,rt,of)
366# define LHU(rt,of,rb) hrri(MIPS_LHU,rb,rt,of)
367# define LW(rt,of,rb) hrri(MIPS_LW,rb,rt,of)
368# define LWU(rt,of,rb) hrri(MIPS_LWU,rb,rt,of)
369# define LD(rt,of,rb) hrri(MIPS_LD,rb,rt,of)
370# define SB(rt,of,rb) hrri(MIPS_SB,rb,rt,of)
371# define SH(rt,of,rb) hrri(MIPS_SH,rb,rt,of)
372# define SW(rt,of,rb) hrri(MIPS_SW,rb,rt,of)
373# define SD(rt,of,rb) hrri(MIPS_SD,rb,rt,of)
374# define WSBH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_WSBH,MIPS_BSHFL)
375# define SEB(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEB,MIPS_BSHFL)
376# define SEH(rd,rt) hrrrit(MIPS_SPECIAL3,0,rt,rd,MIPS_SEH,MIPS_BSHFL)
377# define SLT(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLT)
378# define SLTU(rd,rs,rt) rrr_t(rs,rt,rd,MIPS_SLTU)
379# define SLTI(rt,rs,im) hrri(MIPS_SLTI,rs,rt,im)
380# define SLTIU(rt,rs,im) hrri(MIPS_SLTIU,rs,rt,im)
381# define BLTZ(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BLTZ,im)
382# define BLEZ(rs,im) hrri(MIPS_BLEZ,rs,_ZERO_REGNO,im)
383# define BEQ(rs,rt,im) hrri(MIPS_BEQ,rs,rt,im)
384# define BGEZ(rs,im) hrri(MIPS_REGIMM,rs,MIPS_BGEZ,im)
385# define BGTZ(rs,im) hrri(MIPS_BGTZ,rs,_ZERO_REGNO,im)
386# define BNE(rs,rt,im) hrri(MIPS_BNE,rs,rt,im)
387# define JALR(r0) hrrrit(MIPS_SPECIAL,r0,0,_RA_REGNO,0,MIPS_JALR)
388# if 1 /* supports MIPS32 R6 */
389# define JR(r0) hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JALR)
390# else /* does not support MIPS32 R6 */
391# define JR(r0) hrrrit(MIPS_SPECIAL,r0,0,0,0,MIPS_JR)
392# endif
393# define J(i0) hi(MIPS_J,i0)
1f22b268 394# define MOVN(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVN)
4a71579b
PC		 395# define MOVZ(rd,rs,rt) hrrrit(0,rs,rt,rd,0,MIPS_MOVZ)
396# define comr(r0,r1) xori(r0,r1,-1)
397# define negr(r0,r1) subr(r0,_ZERO_REGNO,r1)
398# if __WORDSIZE == 32
399# define addr(rd,rs,rt) ADDU(rd,rs,rt)
400# define addiu(r0,r1,i0) ADDIU(r0,r1,i0)
401# define subr(rd,rs,rt) SUBU(rd,rs,rt)
402# define mult(rs,rt) MULT(rs,rt)
403# define multu(rs,rt) MULTU(rs,rt)
404# define div(rs,rt) DIV(rs,rt)
405# define divu(rs,rt) DIVU(rs,rt)
406# else
407# define addr(rd,rs,rt) DADDU(rd,rs,rt)
408# define addiu(r0,r1,i0) DADDIU(r0,r1,i0)
409# define subr(rd,rs,rt) DSUBU(rd,rs,rt)
410# define mult(rs,rt) DMULT(rs,rt)
411# define multu(rs,rt) DMULTU(rs,rt)
412# define div(rs,rt) DDIV(rs,rt)
413# define divu(rs,rt) DDIVU(rs,rt)
414# endif
415# define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
416static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
417#define addcr(r0,r1,r2) _addcr(_jit,r0,r1,r2)
418static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
419#define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
420static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
421# define addxr(r0,r1,r2) _addxr(_jit,r0,r1,r2)
422static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
423# define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
424static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
425# define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
426static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
427# define subcr(r0,r1,r2) _subcr(_jit,r0,r1,r2)
428static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
429# define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
430static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
431# define subxr(r0,r1,r2) _subxr(_jit,r0,r1,r2)
432static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
433# define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
434static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
435# define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
436static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
437# define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
438static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
439# define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
440static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
441# define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
442# define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
443# define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
444static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
445 jit_int32_t,jit_int32_t,jit_bool_t);
446# define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
447# define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
448# define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
449static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
450 jit_int32_t,jit_word_t,jit_bool_t);
451# define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
452static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
453# define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
454static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
455# define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
456static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
457# define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
458static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
459# define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
460# define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
461# define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
462static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
463 jit_int32_t,jit_int32_t,jit_bool_t);
464# define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
465# define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
466# define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
467static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
468 jit_int32_t,jit_word_t,jit_bool_t);
469# define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
470static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
471# define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
472static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
473# define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
474static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
475# define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
476static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
477# if __WORDSIZE == 32
478# define lshr(r0,r1,r2) SLLV(r0,r1,r2)
479# define lshi(r0,r1,i0) SLL(r0,r1,i0)
480# define rshr(r0,r1,r2) SRAV(r0,r1,r2)
481# define rshi(r0,r1,i0) SRA(r0,r1,i0)
482# define rshr_u(r0,r1,r2) SRLV(r0,r1,r2)
483# define rshi_u(r0,r1,i0) SRL(r0,r1,i0)
484# else
485# define lshr(r0,r1,r2) DSLLV(r0,r1,r2)
486# define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
487static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
488# define rshr(r0,r1,r2) DSRAV(r0,r1,r2)
489# define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
490static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
491# define rshr_u(r0,r1,r2) DSRLV(r0,r1,r2)
492# define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
493static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
494# endif
495# define andr(r0,r1,r2) AND(r0,r1,r2)
496# define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
497static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
498# define orr(r0,r1,r2) OR(r0,r1,r2)
499# define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
500static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
501# define xorr(r0,r1,r2) XOR(r0,r1,r2)
502# define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
503static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
519a9ea1
PC		 504# define movr(r0,r1) _movr(_jit,r0,r1)
505static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
4a71579b
PC		 506# define movi(r0,i0) _movi(_jit,r0,i0)
507static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
508# define movi_p(r0,i0) _movi_p(_jit,r0,i0)
509static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
1f22b268
PC		 510# define movnr(r0,r1,r2) MOVN(r0, r1, r2)
511# define movzr(r0,r1,r2) MOVZ(r0, r1, r2)
4a71579b
PC		 512# define ldr_c(r0,r1) LB(r0,0,r1)
513# define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
514static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
515# define ldr_uc(r0,r1) LBU(r0,0,r1)
516# define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
517static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
518# define ldr_s(r0,r1) LH(r0,0,r1)
519# define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
520static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
521# define ldr_us(r0,r1) LHU(r0,0,r1)
522# define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
523static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
524# define ldr_i(r0,r1) LW(r0,0,r1)
525# define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
526static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
527# if __WORDSIZE == 64
528# define ldr_ui(r0,r1) LWU(r0,0,r1)
529# define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
530static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
531# define ldr_l(r0,r1) LD(r0,0,r1)
532# define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
533static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
534# endif
535# define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
536static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
537# define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
538static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
539# define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
540static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
541# define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
542static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
543# define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
544static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
545# define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
546static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
547# define ldxr_us(r0,r1,r2) _ldxr_us(_jit,r0,r1,r2)
548static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
549# define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
550static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
551# define ldxr_i(r0,r1,r2) _ldxr_i(_jit,r0,r1,r2)
552static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
553# define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
554static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
555# if __WORDSIZE == 64
556# define ldxr_ui(r0,r1,r2) _ldxr_ui(_jit,r0,r1,r2)
557static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
558# define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
559static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
560# define ldxr_l(r0,r1,r2) _ldxr_l(_jit,r0,r1,r2)
561static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
562# define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
563static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
564# endif
565# define str_c(r0,r1) SB(r1,0,r0)
566# define sti_c(i0,r0) _sti_c(_jit,i0,r0)
567static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
568# define str_s(r0,r1) SH(r1,0,r0)
569# define sti_s(i0,r0) _sti_s(_jit,i0,r0)
570static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
571# define str_i(r0,r1) SW(r1,0,r0)
572# define sti_i(i0,r0) _sti_i(_jit,i0,r0)
573static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
574# if __WORDSIZE == 64
575# define str_l(r0,r1) SD(r1,0,r0)
576# define sti_l(i0,r0) _sti_l(_jit,i0,r0)
577static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
578# endif
579# define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
580static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
581# define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
582static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
583# define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
584static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
585# define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
586static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
587# define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
588static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
589# define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
590static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
591# if __WORDSIZE == 64
592# define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
593static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
594# define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
595static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
596# endif
597# if __BYTE_ORDER == __LITTLE_ENDIAN
598# define htonr_us(r0,r1) _htonr_us(_jit,r0,r1)
599static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
600# define htonr_ui(r0,r1) _htonr_ui(_jit,r0,r1)
601static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
602# if __WORDSIZE == 64
603# define htonr_ul(r0,r1) _htonr_ul(_jit,r0,r1)
604static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
605# endif
606# else
607# define htonr_us(r0,r1) extr_us(r0,r1)
608# if __WORDSIZE == 32
609# define htonr_ui(r0,r1) movr(r0,r1)
610# else
611# define htonr_ui(r0,r1) extr_ui(r0,r1)
612# define htonr_ul(r0,r1) movr(r0,r1)
613# endif
614# endif
615# define extr_c(r0,r1) _extr_c(_jit,r0,r1)
616static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
617# define extr_uc(r0,r1) ANDI(r0,r1,0xff)
618# define extr_s(r0,r1) _extr_s(_jit,r0,r1)
619static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
620# define extr_us(r0,r1) ANDI(r0,r1,0xffff)
621# if __WORDSIZE == 64
622# define extr_i(r0,r1) SLL(r0,r1,0)
623# define extr_ui(r0,r1) _extr_ui(_jit,r0,r1)
624static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
625# endif
626# define ltr(r0,r1,r2) SLT(r0,r1,r2)
627# define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
628static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
629# define ltr_u(r0,r1,r2) SLTU(r0,r1,r2)
630# define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
631static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
632#define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
633static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
634#define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
635static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
636#define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
637static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
638#define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
639static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
640#define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
641static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
642#define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
643static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
644#define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
645static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
646#define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
647static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
648#define ger_u(r0,r1,i0) _ger_u(_jit,r0,r1,i0)
649static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
650#define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
651static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
652# define gtr(r0,r1,r2) SLT(r0,r2,r1)
653#define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
654static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
655# define gtr_u(r0,r1,r2) SLTU(r0,r2,r1)
656# define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
657static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
658#define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
659static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
660#define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
661static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
662#define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
663static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
664#define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
665static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
666#define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
667static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
668#define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
669static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
670#define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
671static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
672#define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
673static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
674#define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
675static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
676#define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
677static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
678#define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
679static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
680#define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
681static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
682#define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
683static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
684#define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
685static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
686#define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
687static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
688#define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
689static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
690#define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
691static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
692#define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
693static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
694#define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
695static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
696#define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
697static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
698#define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
699static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
700#define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
701static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
702# define jmpr(r0) _jmpr(_jit,r0)
703static void _jmpr(jit_state_t*,jit_int32_t);
704# define jmpi(i0) _jmpi(_jit,i0)
705static jit_word_t _jmpi(jit_state_t*,jit_word_t);
706# define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
707static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
708# define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
709static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
710# define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
711static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
712# define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
713static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
714# define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
715static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
716# define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
717static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
718# define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
719static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
720# define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
721static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
722# define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
723static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
724# define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
725static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
726# define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
727static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
728# define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
729static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
730# define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
731static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
732# define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
733static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
734# define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
735static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
736# define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
737static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
738# define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
739static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
740# define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
741static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
742# define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
743static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
744# define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
745static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
746# define callr(r0) _callr(_jit,r0)
747static void _callr(jit_state_t*,jit_int32_t);
748# define calli(i0) _calli(_jit,i0)
749static void _calli(jit_state_t*,jit_word_t);
750# define calli_p(i0) _calli_p(_jit,i0)
751static jit_word_t _calli_p(jit_state_t*,jit_word_t);
752# define prolog(node) _prolog(_jit,node)
753static void _prolog(jit_state_t*,jit_node_t*);
754# define epilog(node) _epilog(_jit,node)
755static void _epilog(jit_state_t*,jit_node_t*);
756# define vastart(r0) _vastart(_jit, r0)
757static void _vastart(jit_state_t*, jit_int32_t);
758# define vaarg(r0, r1) _vaarg(_jit, r0, r1)
759static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
760#define patch_abs(instr,label) _patch_abs(_jit,instr,label)
761static void _patch_abs(jit_state_t*,jit_word_t,jit_word_t);
762#define patch_at(jump,label) _patch_at(_jit,jump,label)
763static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
764#endif
765
766#if CODE
767static void
768_hrrrit(jit_state_t *_jit,jit_int32_t hc,
769 jit_int32_t rs, jit_int32_t rt, jit_int32_t rd,
770 jit_int32_t ic, jit_int32_t tc)
771{
772 jit_instr_t i;
773 i.tc.b = tc;
774 i.ic.b = ic;
775 i.rd.b = rd;
776 i.rt.b = rt;
777 i.rs.b = rs;
778 i.hc.b = hc;
779 ii(i.op);
780}
781
782static void
783_hrri(jit_state_t *_jit, jit_int32_t hc,
784 jit_int32_t rs, jit_int32_t rt, jit_int32_t im)
785{
786 jit_instr_t i;
787 i.op = 0;
788 i.is.b = im;
789 i.rt.b = rt;
790 i.rs.b = rs;
791 i.hc.b = hc;
792 ii(i.op);
793}
794
795static void
796_hi(jit_state_t *_jit, jit_int32_t hc, jit_int32_t im)
797{
798 jit_instr_t i;
799 i.ii.b = im;
800 i.hc.b = hc;
801 ii(i.op);
802}
803
804static void
805_nop(jit_state_t *_jit, jit_int32_t i0)
806{
807 for (; i0 > 0; i0 -= 4)
808 NOP();
809 assert(i0 == 0);
810}
811
812static void
813_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
814{
815 jit_int32_t reg;
816 if (i0 == 0)
817 movr(r0, r1);
818 else if (can_sign_extend_short_p(i0))
819 addiu(r0, r1, i0);
820 else {
821 reg = jit_get_reg(jit_class_gpr);
822 movi(rn(reg), i0);
823 addr(r0, r1, rn(reg));
824 jit_unget_reg(reg);
825 }
826}
827
828static void
829_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
830{
831 jit_int32_t t0;
832
833 if (jit_carry == _NOREG)
834 jit_carry = jit_get_reg(jit_class_gpr);
835 if (r0 == r1) {
836 t0 = jit_get_reg(jit_class_gpr);
837 addr(rn(t0), r1, r2);
838 SLTU(rn(jit_carry), rn(t0), r1);
839 movr(r0, rn(t0));
840 jit_unget_reg(t0);
841 }
842 else {
843 addr(r0, r1, r2);
844 SLTU(rn(jit_carry), r0, r1);
845 }
846}
847
848static void
849_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
850{
851 jit_int32_t t0;
852
853 if (jit_carry == _NOREG)
854 jit_carry = jit_get_reg(jit_class_gpr);
855 t0 = jit_get_reg(jit_class_gpr);
856 if (r0 == r1) {
857 if (can_sign_extend_short_p(i0))
858 addiu(rn(t0), r1, i0);
859 else {
860 movi(rn(t0), i0);
861 addr(rn(t0), r1, rn(t0));
862 }
863 SLTU(rn(jit_carry), rn(t0), r1);
864 movr(r0, rn(t0));
865 }
866 else {
867 if (can_sign_extend_short_p(i0))
868 addiu(r0, r1, i0);
869 else {
870 movi(rn(t0), i0);
871 addr(r0, r1, rn(t0));
872 }
873 SLTU(rn(jit_carry), r0, r1);
874 }
875 jit_unget_reg(t0);
876}
877
878static void
879_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
880{
881 jit_int32_t t0;
882
883 assert(jit_carry != _NOREG);
884 t0 = jit_get_reg(jit_class_gpr);
885 movr(rn(t0), rn(jit_carry));
886 addcr(r0, r1, r2);
887 addcr(r0, r0, rn(t0));
888 jit_unget_reg(t0);
889}
890
891static void
892_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
893{
894 jit_int32_t t0;
895
896 assert(jit_carry != _NOREG);
897 t0 = jit_get_reg(jit_class_gpr);
898 movr(rn(t0), rn(jit_carry));
899 addci(r0, r1, i0);
900 addcr(r0, r0, rn(t0));
901 jit_unget_reg(t0);
902}
903
904static void
905_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
906{
907 jit_int32_t reg;
908 if (i0 == 0)
909 movr(r0, r1);
910 else if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
911 addiu(r0, r1, -i0);
912 else {
913 reg = jit_get_reg(jit_class_gpr);
914 movi(rn(reg), i0);
915 subr(r0, r1, rn(reg));
916 jit_unget_reg(reg);
917 }
918}
919
920static void
921_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
922{
923 jit_int32_t t0;
924
925 if (jit_carry == _NOREG)
926 jit_carry = jit_get_reg(jit_class_gpr);
927 if (r0 == r1) {
928 t0 = jit_get_reg(jit_class_gpr);
929 subr(rn(t0), r1, r2);
930 SLTU(rn(jit_carry), r1, rn(t0));
931 movr(r0, rn(t0));
932 jit_unget_reg(t0);
933 }
934 else {
935 subr(r0, r1, r2);
936 SLTU(rn(jit_carry), r1, r0);
937 }
938}
939
940static void
941_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
942{
943 jit_int32_t t0;
944
945 if (jit_carry == _NOREG)
946 jit_carry = jit_get_reg(jit_class_gpr);
947 t0 = jit_get_reg(jit_class_gpr);
948 if (r0 == r1) {
949 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
950 addiu(rn(t0), r1, -i0);
951 else {
952 movi(rn(t0), i0);
953 subr(rn(t0), r1, rn(t0));
954 }
955 SLTU(rn(jit_carry), r1, rn(t0));
956 movr(r0, rn(t0));
957 }
958 else {
959 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000)
960 addiu(r0, r1, -i0);
961 else {
962 movi(rn(t0), i0);
963 subr(r0, r1, rn(t0));
964 }
965 SLTU(rn(jit_carry), r1, r0);
966 }
967 jit_unget_reg(t0);
968}
969
970static void
971_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
972{
973 jit_int32_t t0;
974
975 assert(jit_carry != _NOREG);
976 t0 = jit_get_reg(jit_class_gpr);
977 movr(rn(t0), rn(jit_carry));
978 subcr(r0, r1, r2);
979 subcr(r0, r0, rn(t0));
980 jit_unget_reg(t0);
981}
982
983static void
984_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
985{
986 jit_int32_t t0;
987
988 assert(jit_carry != _NOREG);
989 t0 = jit_get_reg(jit_class_gpr);
990 movr(rn(t0), rn(jit_carry));
991 subci(r0, r1, i0);
992 subcr(r0, r0, rn(t0));
993 jit_unget_reg(t0);
994}
995
996static void
997_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
998{
999 subi(r0, r1, i0);
1000 negr(r0, r0);
1001}
1002
1003static void
1004_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1005{
1006 multu(r1, r2);
1007 MFLO(r0);
1008}
1009
1010static void
1011_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1012{
1013 jit_int32_t reg;
1014
1015 reg = jit_get_reg(jit_class_gpr);
1016 movi(rn(reg), i0);
1017 mulr(r0, r1, rn(reg));
1018 jit_unget_reg(reg);
1019}
1020
1021static void
1022_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1023 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1024{
1025 if (sign)
1026 mult(r2, r3);
1027 else
1028 multu(r2, r3);
1029 MFLO(r0);
1030 MFHI(r1);
1031}
1032
1033static void
1034_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1035 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1036{
1037 jit_int32_t reg;
1038 reg = jit_get_reg(jit_class_gpr);
1039 movi(rn(reg), i0);
1040 iqmulr(r0, r1, r2, rn(reg), sign);
1041 jit_unget_reg(reg);
1042}
1043
1044static void
1045_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1046{
1047 div(r1, r2);
1048 MFLO(r0);
1049}
1050
1051static void
1052_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1053{
1054 jit_int32_t reg;
1055 reg = jit_get_reg(jit_class_gpr);
1056 movi(rn(reg), i0);
1057 divr(r0, r1, rn(reg));
1058 jit_unget_reg(reg);
1059}
1060
1061static void
1062_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1063{
1064 divu(r1, r2);
1065 MFLO(r0);
1066}
1067
1068static void
1069_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1070{
1071 jit_int32_t reg;
1072 reg = jit_get_reg(jit_class_gpr);
1073 movi(rn(reg), i0);
1074 divr_u(r0, r1, rn(reg));
1075 jit_unget_reg(reg);
1076}
1077
1078static void
1079_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1080 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1081{
1082 if (sign)
1083 div(r2, r3);
1084 else
1085 divu(r2, r3);
1086 MFLO(r0);
1087 MFHI(r1);
1088}
1089
1090static void
1091_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1092 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1093{
1094 jit_int32_t reg;
1095 reg = jit_get_reg(jit_class_gpr);
1096 movi(rn(reg), i0);
1097 iqdivr(r0, r1, r2, rn(reg), sign);
1098 jit_unget_reg(reg);
1099}
1100
1101static void
1102_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1103{
1104 div(r1, r2);
1105 MFHI(r0);
1106}
1107
1108static void
1109_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1110{
1111 jit_int32_t reg;
1112 reg = jit_get_reg(jit_class_gpr);
1113 movi(rn(reg), i0);
1114 remr(r0, r1, rn(reg));
1115 jit_unget_reg(reg);
1116}
1117
1118static void
1119_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1120{
1121 divu(r1, r2);
1122 MFHI(r0);
1123}
1124
1125static void
1126_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1127{
1128 jit_int32_t reg;
1129 reg = jit_get_reg(jit_class_gpr);
1130 movi(rn(reg), i0);
1131 remr_u(r0, r1, rn(reg));
1132 jit_unget_reg(reg);
1133}
1134
1135#if __WORDSIZE == 64
1136static void
1137_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1138{
1139 assert(i0 >= 0 && i0 <= 63);
1140 if (i0 < 32)
1141 DSLL(r0, r1, i0);
1142 else
1143 DSLL32(r0, r1, i0 - 32);
1144}
1145
1146static void
1147_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1148{
1149 assert(i0 >= 0 && i0 <= 63);
1150 if (i0 < 32)
1151 DSRA(r0, r1, i0);
1152 else
1153 DSRA32(r0, r1, i0 - 32);
1154}
1155
1156static void
1157_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1158{
1159 assert(i0 >= 0 && i0 <= 63);
1160 if (i0 < 32)
1161 DSRL(r0, r1, i0);
1162 else
1163 DSRL32(r0, r1, i0 - 32);
1164}
1165#endif
1166
1167static void
1168_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1169{
1170 jit_int32_t reg;
1171 if (can_zero_extend_short_p(i0))
1172 ANDI(r0, r1, i0);
519a9ea1
PC		 1173 else if (is_low_mask(i0)) {
1174#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
1175 if (masked_bits_count(i0) <= 32)
1176 EXT(r0, r1, 0, masked_bits_count(i0));
1177 else
1178#endif
1179 {
1180 lshi(r0, r1, unmasked_bits_count(i0));
1181 rshi_u(r0, r0, unmasked_bits_count(i0));
1182 }
1183 } else if (is_high_mask(i0)) {
1184 rshi(r0, r1, unmasked_bits_count(i0));
1185 lshi(r0, r0, unmasked_bits_count(i0));
1186 } else {
4a71579b
PC		 1187 reg = jit_get_reg(jit_class_gpr);
1188 movi(rn(reg), i0);
1189 AND(r0, r1, rn(reg));
1190 jit_unget_reg(reg);
1191 }
1192}
1193
1194static void
1195_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1196{
1197 jit_int32_t reg;
1198 if (can_zero_extend_short_p(i0))
1199 ORI(r0, r1, i0);
1200 else {
1201 reg = jit_get_reg(jit_class_gpr);
1202 movi(rn(reg), i0);
1203 OR(r0, r1, rn(reg));
1204 jit_unget_reg(reg);
1205 }
1206}
1207
1208static void
1209_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1210{
1211 jit_int32_t reg;
1212 if (can_zero_extend_short_p(i0))
1213 XORI(r0, r1, i0);
1214 else {
1215 reg = jit_get_reg(jit_class_gpr);
1216 movi(rn(reg), i0);
1217 XOR(r0, r1, rn(reg));
1218 jit_unget_reg(reg);
1219 }
1220}
1221
519a9ea1
PC		 1222static void
1223_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1224{
1225 if (r0 != r1)
1226 orr(r0, r1, _ZERO_REGNO);
1227}
1228
4a71579b
PC		 1229static void
1230_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1231{
1232 if (i0 == 0)
1233 OR(r0, _ZERO_REGNO, _ZERO_REGNO);
1234 else if (can_sign_extend_short_p(i0))
1235 addiu(r0, _ZERO_REGNO, i0);
1236 else if (can_zero_extend_short_p(i0))
1237 ORI(r0, _ZERO_REGNO, i0);
1238 else {
1239 if (can_sign_extend_int_p(i0))
1240 LUI(r0, i0 >> 16);
1241 else if (can_zero_extend_int_p(i0)) {
1242 if (i0 & 0xffff0000) {
1243 ORI(r0, _ZERO_REGNO, i0 >> 16);
1244 lshi(r0, r0, 16);
1245 }
1246 }
1247# if __WORDSIZE == 64
1248 else {
1249 movi(r0, (jit_uword_t)i0 >> 32);
1250 if (i0 & 0xffff0000) {
1251 lshi(r0, r0, 16);
1252 ORI(r0, r0, i0 >> 16);
1253 lshi(r0, r0, 16);
1254 }
1255 else
1256 lshi(r0, r0, 32);
1257 }
1258# endif
1259 if (i0 & 0xffff)
1260 ORI(r0, r0, i0);
1261 }
1262}
1263
1264static jit_word_t
1265_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1266{
1267 jit_word_t w;
1268
1269 w = _jit->pc.w;
1270# if __WORDSIZE == 32
1271 LUI(r0, i0 >> 16);
1272 ORI(r0, r0, i0);
1273# else
1274 LUI(r0, i0 >> 48);
1275 ORI(r0, r0, i0 >> 32);
1276 lshi(r0, r0, 16);
1277 ORI(r0, r0, i0 >> 16);
1278 lshi(r0, r0, 16);
1279 ORI(r0, r0, i0);
1280# endif
1281
1282 return (w);
1283}
1284
1285static void
1286_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1287{
1288 jit_int32_t reg;
1289 if (can_sign_extend_short_p(i0))
1290 LB(r0, i0, _ZERO_REGNO);
1291 else {
1292 reg = jit_get_reg(jit_class_gpr);
1293 movi(rn(reg), i0);
1294 ldr_c(r0, rn(reg));
1295 jit_unget_reg(reg);
1296 }
1297}
1298
1299static void
1300_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1301{
1302 jit_int32_t reg;
1303 if (can_sign_extend_short_p(i0))
1304 LBU(r0, i0, _ZERO_REGNO);
1305 else {
1306 reg = jit_get_reg(jit_class_gpr);
1307 movi(rn(reg), i0);
1308 ldr_uc(r0, rn(reg));
1309 jit_unget_reg(reg);
1310 }
1311}
1312
1313static void
1314_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1315{
1316 jit_int32_t reg;
1317 if (can_sign_extend_short_p(i0))
1318 LH(r0, i0, _ZERO_REGNO);
1319 else {
1320 reg = jit_get_reg(jit_class_gpr);
1321 movi(rn(reg), i0);
1322 ldr_s(r0, rn(reg));
1323 jit_unget_reg(reg);
1324 }
1325}
1326
1327static void
1328_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1329{
1330 jit_int32_t reg;
1331 if (can_sign_extend_short_p(i0))
1332 LHU(r0, i0, _ZERO_REGNO);
1333 else {
1334 reg = jit_get_reg(jit_class_gpr);
1335 movi(rn(reg), i0);
1336 ldr_us(r0, rn(reg));
1337 jit_unget_reg(reg);
1338 }
1339}
1340
1341static void
1342_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1343{
1344 jit_int32_t reg;
1345 if (can_sign_extend_short_p(i0))
1346 LW(r0, i0, _ZERO_REGNO);
1347 else {
1348 reg = jit_get_reg(jit_class_gpr);
1349 movi(rn(reg), i0);
1350 ldr_i(r0, rn(reg));
1351 jit_unget_reg(reg);
1352 }
1353}
1354
1355#if __WORDSIZE == 64
1356static void
1357_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1358{
1359 jit_int32_t reg;
1360 if (can_sign_extend_short_p(i0))
1361 LWU(r0, i0, _ZERO_REGNO);
1362 else {
1363 reg = jit_get_reg(jit_class_gpr);
1364 movi(rn(reg), i0);
1365 ldr_ui(r0, rn(reg));
1366 jit_unget_reg(reg);
1367 }
1368}
1369
1370static void
1371_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1372{
1373 jit_int32_t reg;
1374 if (can_sign_extend_short_p(i0))
1375 LD(r0, i0, _ZERO_REGNO);
1376 else {
1377 reg = jit_get_reg(jit_class_gpr);
1378 movi(rn(reg), i0);
1379 ldr_l(r0, rn(reg));
1380 jit_unget_reg(reg);
1381 }
1382}
1383#endif
1384
1385static void
1386_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1387{
1388 jit_int32_t reg;
1389 reg = jit_get_reg(jit_class_gpr);
1390 addr(rn(reg), r1, r2);
1391 ldr_c(r0, rn(reg));
1392 jit_unget_reg(reg);
1393}
1394
1395static void
1396_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1397{
1398 jit_int32_t reg;
1399 if (can_sign_extend_short_p(i0))
1400 LB(r0, i0, r1);
1401 else {
1402 reg = jit_get_reg(jit_class_gpr);
1403 addi(rn(reg), r1, i0);
1404 ldr_c(r0, rn(reg));
1405 jit_unget_reg(reg);
1406 }
1407}
1408
1409static void
1410_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1411{
1412 jit_int32_t reg;
1413 reg = jit_get_reg(jit_class_gpr);
1414 addr(rn(reg), r1, r2);
1415 ldr_uc(r0, rn(reg));
1416 jit_unget_reg(reg);
1417}
1418
1419static void
1420_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1421{
1422 jit_int32_t reg;
1423 if (can_sign_extend_short_p(i0))
1424 LBU(r0, i0, r1);
1425 else {
1426 reg = jit_get_reg(jit_class_gpr);
1427 addi(rn(reg), r1, i0);
1428 ldr_uc(r0, rn(reg));
1429 jit_unget_reg(reg);
1430 }
1431}
1432
1433static void
1434_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1435{
1436 jit_int32_t reg;
1437 reg = jit_get_reg(jit_class_gpr);
1438 addr(rn(reg), r1, r2);
1439 ldr_s(r0, rn(reg));
1440 jit_unget_reg(reg);
1441}
1442
1443static void
1444_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1445{
1446 jit_int32_t reg;
1447 if (can_sign_extend_short_p(i0))
1448 LH(r0, i0, r1);
1449 else {
1450 reg = jit_get_reg(jit_class_gpr);
1451 addi(rn(reg), r1, i0);
1452 ldr_s(r0, rn(reg));
1453 jit_unget_reg(reg);
1454 }
1455}
1456
1457static void
1458_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1459{
1460 jit_int32_t reg;
1461 reg = jit_get_reg(jit_class_gpr);
1462 addr(rn(reg), r1, r2);
1463 ldr_us(r0, rn(reg));
1464 jit_unget_reg(reg);
1465}
1466
1467static void
1468_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1469{
1470 jit_int32_t reg;
1471 if (can_sign_extend_short_p(i0))
1472 LHU(r0, i0, r1);
1473 else {
1474 reg = jit_get_reg(jit_class_gpr);
1475 addi(rn(reg), r1, i0);
1476 ldr_us(r0, rn(reg));
1477 jit_unget_reg(reg);
1478 }
1479}
1480
1481static void
1482_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1483{
1484 jit_int32_t reg;
1485 reg = jit_get_reg(jit_class_gpr);
1486 addr(rn(reg), r1, r2);
1487 ldr_i(r0, rn(reg));
1488 jit_unget_reg(reg);
1489}
1490
1491static void
1492_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1493{
1494 jit_int32_t reg;
1495 if (can_sign_extend_short_p(i0))
1496 LW(r0, i0, r1);
1497 else {
1498 reg = jit_get_reg(jit_class_gpr);
1499 addi(rn(reg), r1, i0);
1500 ldr_i(r0, rn(reg));
1501 jit_unget_reg(reg);
1502 }
1503}
1504
1505#if __WORDSIZE == 64
1506static void
1507_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1508{
1509 jit_int32_t reg;
1510 reg = jit_get_reg(jit_class_gpr);
1511 addr(rn(reg), r1, r2);
1512 ldr_ui(r0, rn(reg));
1513 jit_unget_reg(reg);
1514}
1515
1516static void
1517_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1518{
1519 jit_int32_t reg;
1520 if (can_sign_extend_short_p(i0))
1521 LWU(r0, i0, r1);
1522 else {
1523 reg = jit_get_reg(jit_class_gpr);
1524 addi(rn(reg), r1, i0);
1525 ldr_ui(r0, rn(reg));
1526 jit_unget_reg(reg);
1527 }
1528}
1529
1530static void
1531_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1532{
1533 jit_int32_t reg;
1534 reg = jit_get_reg(jit_class_gpr);
1535 addr(rn(reg), r1, r2);
1536 ldr_l(r0, rn(reg));
1537 jit_unget_reg(reg);
1538}
1539
1540static void
1541_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1542{
1543 jit_int32_t reg;
1544 if (can_sign_extend_short_p(i0))
1545 LD(r0, i0, r1);
1546 else {
1547 reg = jit_get_reg(jit_class_gpr);
1548 addi(rn(reg), r1, i0);
1549 ldr_l(r0, rn(reg));
1550 jit_unget_reg(reg);
1551 }
1552}
1553#endif
1554
1555static void
1556_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1557{
1558 jit_int32_t reg;
1559 if (can_sign_extend_short_p(i0))
1560 SB(r0, i0, _ZERO_REGNO);
1561 else {
1562 reg = jit_get_reg(jit_class_gpr);
1563 movi(rn(reg), i0);
1564 str_c(rn(reg), r0);
1565 jit_unget_reg(reg);
1566 }
1567}
1568
1569static void
1570_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1571{
1572 jit_int32_t reg;
1573 if (can_sign_extend_short_p(i0))
1574 SH(r0, i0, _ZERO_REGNO);
1575 else {
1576 reg = jit_get_reg(jit_class_gpr);
1577 movi(rn(reg), i0);
1578 str_s(rn(reg), r0);
1579 jit_unget_reg(reg);
1580 }
1581}
1582
1583static void
1584_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1585{
1586 jit_int32_t reg;
1587 if (can_sign_extend_short_p(i0))
1588 SW(r0, i0, _ZERO_REGNO);
1589 else {
1590 reg = jit_get_reg(jit_class_gpr);
1591 movi(rn(reg), i0);
1592 str_i(rn(reg), r0);
1593 jit_unget_reg(reg);
1594 }
1595}
1596
1597#if __WORDSIZE == 64
1598static void
1599_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1600{
1601 jit_int32_t reg;
1602 if (can_sign_extend_short_p(i0))
1603 SD(r0, i0, _ZERO_REGNO);
1604 else {
1605 reg = jit_get_reg(jit_class_gpr);
1606 movi(rn(reg), i0);
1607 str_l(rn(reg), r0);
1608 jit_unget_reg(reg);
1609 }
1610}
1611#endif
1612
1613static void
1614_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1615{
1616 jit_int32_t reg;
1617 reg = jit_get_reg(jit_class_gpr);
1618 addr(rn(reg), r0, r1);
1619 str_c(rn(reg), r2);
1620 jit_unget_reg(reg);
1621}
1622
1623static void
1624_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1625{
1626 jit_int32_t reg;
1627 if (can_sign_extend_short_p(i0))
1628 SB(r1, i0, r0);
1629 else {
1630 reg = jit_get_reg(jit_class_gpr);
1631 addi(rn(reg), r0, i0);
1632 str_c(rn(reg), r1);
1633 jit_unget_reg(reg);
1634 }
1635}
1636
1637static void
1638_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1639{
1640 jit_int32_t reg;
1641 reg = jit_get_reg(jit_class_gpr);
1642 addr(rn(reg), r0, r1);
1643 str_s(rn(reg), r2);
1644 jit_unget_reg(reg);
1645}
1646
1647static void
1648_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1649{
1650 jit_int32_t reg;
1651 if (can_sign_extend_short_p(i0))
1652 SH(r1, i0, r0);
1653 else {
1654 reg = jit_get_reg(jit_class_gpr);
1655 addi(rn(reg), r0, i0);
1656 str_s(rn(reg), r1);
1657 jit_unget_reg(reg);
1658 }
1659}
1660
1661static void
1662_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1663{
1664 jit_int32_t reg;
1665 reg = jit_get_reg(jit_class_gpr);
1666 addr(rn(reg), r0, r1);
1667 str_i(rn(reg), r2);
1668 jit_unget_reg(reg);
1669}
1670
1671static void
1672_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1673{
1674 jit_int32_t reg;
1675 if (can_sign_extend_short_p(i0))
1676 SW(r1, i0, r0);
1677 else {
1678 reg = jit_get_reg(jit_class_gpr);
1679 addi(rn(reg), r0, i0);
1680 str_i(rn(reg), r1);
1681 jit_unget_reg(reg);
1682 }
1683}
1684
1685#if __WORDSIZE == 64
1686static void
1687_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1 ,jit_int32_t r2)
1688{
1689 jit_int32_t reg;
1690 reg = jit_get_reg(jit_class_gpr);
1691 addr(rn(reg), r0, r1);
1692 str_l(rn(reg), r2);
1693 jit_unget_reg(reg);
1694}
1695
1696static void
1697_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1698{
1699 jit_int32_t reg;
1700 if (can_sign_extend_short_p(i0))
1701 SD(r1, i0, r0);
1702 else {
1703 reg = jit_get_reg(jit_class_gpr);
1704 addi(rn(reg), r0, i0);
1705 str_l(rn(reg), r1);
1706 jit_unget_reg(reg);
1707 }
1708}
1709#endif
1710
1711# if __BYTE_ORDER == __LITTLE_ENDIAN
1712static void
1713_htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1714{
1715 jit_int32_t t0;
1716 t0 = jit_get_reg(jit_class_gpr);
1717 rshi(rn(t0), r1, 8);
1718 andi(r0, r1, 0xff);
1719 andi(rn(t0), rn(t0), 0xff);
1720 lshi(r0, r0, 8);
1721 orr(r0, r0, rn(t0));
1722 jit_unget_reg(t0);
1723}
1724
1725static void
1726_htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1727{
1728 jit_int32_t t0;
1729 jit_int32_t t1;
1730 jit_int32_t t2;
1731 t0 = jit_get_reg(jit_class_gpr);
1732 t1 = jit_get_reg(jit_class_gpr);
1733 t2 = jit_get_reg(jit_class_gpr);
1734 rshi(rn(t0), r1, 24);
1735 rshi(rn(t1), r1, 16);
1736 rshi(rn(t2), r1, 8);
1737 andi(rn(t0), rn(t0), 0xff);
1738 andi(rn(t1), rn(t1), 0xff);
1739 andi(rn(t2), rn(t2), 0xff);
1740 andi(r0, r1, 0xff);
1741 lshi(r0, r0, 24);
1742 lshi(rn(t1), rn(t1), 8);
1743 orr(r0, r0, rn(t0));
1744 lshi(rn(t2), rn(t2), 16);
1745 orr(r0, r0, rn(t1));
1746 orr(r0, r0, rn(t2));
1747 jit_unget_reg(t2);
1748 jit_unget_reg(t1);
1749 jit_unget_reg(t0);
1750}
1751
1752static void
1753_htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1754{
1755 jit_int32_t reg;
1756 reg = jit_get_reg(jit_class_gpr);
1757 rshi_u(rn(reg), r1, 32);
1758 htonr_ui(r0, r1);
1759 htonr_ui(rn(reg), rn(reg));
1760 lshi(r0, r0, 32);
1761 orr(r0, r0, rn(reg));
1762 jit_unget_reg(reg);
1763}
1764# endif
1765
1766static void
1767_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1768{
1769 if (jit_mips2_p())
1770 SEB(r0, r1);
1771 else {
1772 lshi(r0, r1, __WORDSIZE - 8);
1773 rshi(r0, r0, __WORDSIZE - 8);
1774 }
1775}
1776
1777static void
1778_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1779{
1780 if (jit_mips2_p())
1781 SEH(r0, r1);
1782 else {
1783 lshi(r0, r1, __WORDSIZE - 16);
1784 rshi(r0, r0, __WORDSIZE - 16);
1785 }
1786}
1787
1788# if __WORDSIZE == 64
1789static void
1790_extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1791{
1792 lshi(r0, r1, 32);
1793 rshi_u(r0, r0, 32);
1794}
1795# endif
1796
1797static void
1798_lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1799{
1800 jit_int32_t reg;
1801
1802 if (can_sign_extend_short_p(i0))
1803 SLTI(r0, r1, i0);
1804 else {
1805 reg = jit_get_reg(jit_class_gpr);
1806 movi(rn(reg), i0);
1807 ltr(r0, r1, rn(reg));
1808 jit_unget_reg(reg);
1809 }
1810}
1811
1812static void
1813_lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1814{
1815 jit_int32_t reg;
1816
1817 if (can_sign_extend_short_p(i0))
1818 SLTIU(r0, r1, i0);
1819 else {
1820 reg = jit_get_reg(jit_class_gpr);
1821 movi(rn(reg), i0);
1822 ltr_u(r0, r1, rn(reg));
1823 jit_unget_reg(reg);
1824 }
1825}
1826
1827static void
1828_ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1829{
1830 SLT(r0, r2, r1);
1831 XORI(r0, r0, 1);
1832}
1833
1834static void
1835_lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1836{
1837 jit_int32_t reg;
1838
1839 if (i0 == 0) {
1840 SLT(r0, _ZERO_REGNO, r1);
1841 XORI(r0, r0, 1);
1842 }
1843 else {
1844 reg = jit_get_reg(jit_class_gpr);
1845 movi(rn(reg), i0);
1846 ler(r0, r1, rn(reg));
1847 jit_unget_reg(reg);
1848 }
1849}
1850
1851static void
1852_ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1853{
1854 SLTU(r0, r2, r1);
1855 XORI(r0, r0, 1);
1856}
1857
1858static void
1859_lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1860{
1861 jit_int32_t reg;
1862
1863 if (i0 == 0) {
1864 SLTU(r0, _ZERO_REGNO, r1);
1865 XORI(r0, r0, 1);
1866 }
1867 else {
1868 reg = jit_get_reg(jit_class_gpr);
1869 movi(rn(reg), i0);
1870 ler_u(r0, r1, rn(reg));
1871 jit_unget_reg(reg);
1872 }
1873}
1874
1875static void
1876_eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1877{
1878 subr(r0, r1, r2);
1879 SLTU(r0, _ZERO_REGNO, r0);
1880 XORI(r0, r0, 1);
1881}
1882
1883static void
1884_eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1885{
1886 if (i0) {
1887 subi(r0, r1, i0);
1888 SLTU(r0, _ZERO_REGNO, r0);
1889 }
1890 else
1891 SLTU(r0, _ZERO_REGNO, r1);
1892 XORI(r0, r0, 1);
1893}
1894
1895static void
1896_ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1897{
1898 SLT(r0, r1, r2);
1899 XORI(r0, r0, 1);
1900}
1901
1902static void
1903_gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1904{
1905 jit_int32_t reg;
1906
1907 reg = jit_get_reg(jit_class_gpr);
1908 movi(rn(reg), i0);
1909 ger(r0, r1, rn(reg));
1910 jit_unget_reg(reg);
1911}
1912
1913static void
1914_ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1915{
1916 SLTU(r0, r1, r2);
1917 XORI(r0, r0, 1);
1918}
1919
1920static void
1921_gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1922{
1923 jit_int32_t reg;
1924
1925 reg = jit_get_reg(jit_class_gpr);
1926 movi(rn(reg), i0);
1927 ger_u(r0, r1, rn(reg));
1928 jit_unget_reg(reg);
1929}
1930
1931static void
1932_gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1933{
1934 jit_int32_t reg;
1935
1936 if (i0 == 0)
1937 SLT(r0, _ZERO_REGNO, r1);
1938 else {
1939 reg = jit_get_reg(jit_class_gpr);
1940 movi(rn(reg), i0);
1941 SLT(r0, rn(reg), r1);
1942 jit_unget_reg(reg);
1943 }
1944}
1945
1946static void
1947_gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1948{
1949 jit_int32_t reg;
1950
1951 if (i0 == 0)
1952 SLTU(r0, _ZERO_REGNO, r1);
1953 else {
1954 reg = jit_get_reg(jit_class_gpr);
1955 movi(rn(reg), i0);
1956 SLTU(r0, rn(reg), r1);
1957 jit_unget_reg(reg);
1958 }
1959}
1960
1961static void
1962_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1963{
1964 subr(r0, r1, r2);
1965 SLTU(r0, _ZERO_REGNO, r0);
1966}
1967
1968static void
1969_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1970{
1971 if (i0) {
1972 subi(r0, r1, i0);
1973 SLTU(r0, _ZERO_REGNO, r0);
1974 }
1975 else
1976 SLTU(r0, _ZERO_REGNO, r1);
1977}
1978
1979static jit_word_t
1980_bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1981{
1982 jit_word_t w;
1983 jit_int32_t reg;
1984
1985 reg = jit_get_reg(jit_class_gpr);
1986 SLT(rn(reg), r0, r1);
1987 w = _jit->pc.w;
1988 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
1989 NOP(1);
1990 jit_unget_reg(reg);
1991
1992 return (w);
1993}
1994
1995static jit_word_t
1996_bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1997{
1998 jit_word_t w;
1999 jit_int32_t reg;
2000
2001 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2002 SLTU(rn(reg), r0, r1);
2003 w = _jit->pc.w;
2004 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2005 NOP(1);
2006 jit_unget_reg(reg);
2007
2008 return (w);
2009}
2010
2011static jit_word_t
2012_blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2013{
2014 jit_word_t w;
2015 jit_word_t d;
2016 jit_int32_t reg;
2017 jit_bool_t zero_p;
2018
2019 if (!(zero_p = i1 == 0))
2020 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2021 if (can_sign_extend_short_p(i1)) {
2022 if (!zero_p)
2023 SLTI(rn(reg), r0, i1);
2024 w = _jit->pc.w;
2025 d = ((i0 - w) >> 2) - 1;
2026 if (!zero_p)
2027 BNE(rn(reg), _ZERO_REGNO, d);
2028 else
2029 BLTZ(r0, d);
2030 NOP(1);
2031 }
2032 else {
2033 movi(rn(reg), i1);
2034 w = bltr(i0, r0, rn(reg));
2035 }
2036 if (!zero_p)
2037 jit_unget_reg(reg);
2038
2039 return (w);
2040}
2041
2042static jit_word_t
2043_blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2044{
2045 jit_word_t w;
2046 jit_int32_t reg;
2047
2048 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2049 if (can_sign_extend_short_p(i1)) {
2050 SLTIU(rn(reg), r0, i1);
2051 w = _jit->pc.w;
2052 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2053 NOP(1);
2054 }
2055 else {
2056 movi(rn(reg), i1);
2057 w = bltr_u(i0, r0, rn(reg));
2058 }
2059 jit_unget_reg(reg);
2060
2061 return (w);
2062}
2063
2064static jit_word_t
2065_bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2066{
2067 jit_word_t w;
2068 jit_int32_t reg;
2069
2070 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2071 SLT(rn(reg), r1, r0);
2072 w = _jit->pc.w;
2073 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2074 NOP(1);
2075 jit_unget_reg(reg);
2076
2077 return (w);
2078}
2079
2080static jit_word_t
2081_bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2082{
2083 jit_word_t w;
2084 jit_int32_t reg;
2085
2086 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2087 SLTU(rn(reg), r1, r0);
2088 w = _jit->pc.w;
2089 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2090 NOP(1);
2091 jit_unget_reg(reg);
2092
2093 return (w);
2094}
2095
2096static jit_word_t
2097_blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2098{
2099 jit_word_t w;
2100 jit_int32_t reg;
2101
2102 if (i1 == 0) {
2103 w = _jit->pc.w;
2104 BLEZ(r0, ((i0 - w) >> 2) - 1);
2105 NOP(1);
2106 }
2107 else {
2108 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2109 movi(rn(reg), i1);
2110 w = bler(i0, r0, rn(reg));
2111 jit_unget_reg(reg);
2112 }
2113
2114 return (w);
2115}
2116
2117static jit_word_t
2118_blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2119{
2120 jit_word_t w;
2121 jit_int32_t reg;
2122
2123 if (i1 == 0) {
2124 w = _jit->pc.w;
2125 BEQ(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2126 NOP(1);
2127 }
2128 else {
2129 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2130 movi(rn(reg), i1);
2131 w = bler_u(i0, r0, rn(reg));
2132 jit_unget_reg(reg);
2133 }
2134
2135 return (w);
2136}
2137
2138static jit_word_t
2139_beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2140{
2141 jit_word_t w;
2142
2143 w = _jit->pc.w;
2144 BEQ(r0, r1, ((i0 - w) >> 2) - 1);
2145 NOP(1);
2146
2147 return (w);
2148}
2149
2150static jit_word_t
2151_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2152{
2153 jit_word_t w;
2154 jit_int32_t reg;
2155
2156 if (i1 == 0) {
2157 w = _jit->pc.w;
2158 BEQ(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2159 NOP(1);
2160 }
2161 else {
2162 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2163 movi(rn(reg), i1);
2164 w = beqr(i0, r0, rn(reg));
2165 jit_unget_reg(reg);
2166 }
2167
2168 return (w);
2169}
2170
2171static jit_word_t
2172_bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2173{
2174 jit_word_t w;
2175 jit_int32_t reg;
2176
2177 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2178 SLT(rn(reg), r0, r1);
2179 w = _jit->pc.w;
2180 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2181 NOP(1);
2182 jit_unget_reg(reg);
2183
2184 return (w);
2185}
2186
2187static jit_word_t
2188_bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2189{
2190 jit_word_t w;
2191 jit_int32_t reg;
2192
2193 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2194 SLTU(rn(reg), r0, r1);
2195 w = _jit->pc.w;
2196 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2197 NOP(1);
2198 jit_unget_reg(reg);
2199
2200 return (w);
2201}
2202
2203static jit_word_t
2204_bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2205{
2206 jit_word_t w;
2207 jit_word_t d;
2208 jit_int32_t reg;
2209 jit_bool_t zero_p;
2210
2211 if (!(zero_p = i1 == 0))
2212 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2213 if (can_sign_extend_short_p(i1)) {
2214 if (!zero_p)
2215 SLTI(rn(reg), r0, i1);
2216 w = _jit->pc.w;
2217 d = ((i0 - w) >> 2) - 1;
2218 if (!zero_p)
2219 BEQ(rn(reg), _ZERO_REGNO, d);
2220 else
2221 BGEZ(r0, d);
2222 NOP(1);
2223 }
2224 else {
2225 movi(rn(reg), i1);
2226 w = bger(i0, r0, rn(reg));
2227 }
2228 if (!zero_p)
2229 jit_unget_reg(reg);
2230
2231 return (w);
2232}
2233
2234static jit_word_t
2235_bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2236{
2237 jit_word_t w;
2238 jit_int32_t reg;
2239
2240 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2241 if (can_sign_extend_short_p(i1)) {
2242 SLTIU(rn(reg), r0, i1);
2243 w = _jit->pc.w;
2244 BEQ(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2245 NOP(1);
2246 }
2247 else {
2248 movi(rn(reg), i1);
2249 w = bger_u(i0, r0, rn(reg));
2250 }
2251 jit_unget_reg(reg);
2252
2253 return (w);
2254}
2255
2256static jit_word_t
2257_bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2258{
2259 jit_word_t w;
2260 jit_int32_t reg;
2261
2262 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2263 SLT(rn(reg), r1, r0);
2264 w = _jit->pc.w;
2265 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2266 NOP(1);
2267 jit_unget_reg(reg);
2268
2269 return (w);
2270}
2271
2272static jit_word_t
2273_bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2274{
2275 jit_word_t w;
2276 jit_int32_t reg;
2277
2278 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2279 SLTU(rn(reg), r1, r0);
2280 w = _jit->pc.w;
2281 BNE(rn(reg), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2282 NOP(1);
2283 jit_unget_reg(reg);
2284
2285 return (w);
2286}
2287
2288static jit_word_t
2289_bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2290{
2291 jit_word_t w;
2292 jit_int32_t reg;
2293
2294 if (i1 == 0) {
2295 w = _jit->pc.w;
2296 BGTZ(r0, ((i0 - w) >> 2) - 1);
2297 NOP(1);
2298 }
2299 else {
2300 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2301 movi(rn(reg), i1);
2302 w = bgtr(i0, r0, rn(reg));
2303 jit_unget_reg(reg);
2304 }
2305
2306 return (w);
2307}
2308
2309static jit_word_t
2310_bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2311{
2312 jit_word_t w;
2313 jit_int32_t reg;
2314
2315 if (i1 == 0) {
2316 w = _jit->pc.w;
2317 BNE(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2318 NOP(1);
2319 }
2320 else {
2321 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2322 movi(rn(reg), i1);
2323 w = bgtr_u(i0, r0, rn(reg));
2324 jit_unget_reg(reg);
2325 }
2326
2327 return (w);
2328}
2329
2330static jit_word_t
2331_bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2332{
2333 jit_word_t w;
2334
2335 w = _jit->pc.w;
2336 BNE(r0, r1, ((i0 - w) >> 2) - 1);
2337 NOP(1);
2338
2339 return (w);
2340}
2341
2342static jit_word_t
2343_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2344{
2345 jit_word_t w;
2346 jit_int32_t reg;
2347
2348 if (i1 == 0) {
2349 w = _jit->pc.w;
2350 BNE(r0, _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2351 NOP(1);
2352 }
2353 else {
2354 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2355 movi(rn(reg), i1);
2356 w = bner(i0, r0, rn(reg));
2357 jit_unget_reg(reg);
2358 }
2359
2360 return (w);
2361}
2362
2363static void
2364_jmpr(jit_state_t *_jit, jit_int32_t r0)
2365{
2366 JR(r0);
2367 NOP(1);
2368}
2369
2370static jit_word_t
2371_jmpi(jit_state_t *_jit, jit_word_t i0)
2372{
2373 jit_word_t w;
2374 jit_int32_t reg;
2375
2376 w = _jit->pc.w;
2377 if (((w + sizeof(jit_int32_t)) & 0xf0000000) == (i0 & 0xf0000000)) {
2378 J((i0 & ~0xf0000000) >> 2);
2379 NOP(1);
2380 }
2381 else {
2382 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2383 movi_p(rn(reg), i0);
2384 jmpr(rn(reg));
2385 jit_unget_reg(reg);
2386 }
2387
2388 return (w);
2389}
2390
2391static jit_word_t
2392_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2393{
2394 jit_word_t w;
2395 jit_int32_t t0;
2396 jit_int32_t t1;
2397 jit_int32_t t2;
2398
2399 /* t1 = r0 + r1; overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
2400 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2401 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2402 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2403 SLT(rn(t0), r1, _ZERO_REGNO); /* t0 = r1 < 0 */
2404 addr(rn(t1), r0, r1); /* t1 = r0 + r1 */
2405 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2406 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2407 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
2408 w = _jit->pc.w;
2409 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2410 /* delay slot */
2411 addr(r0, r0, r1);
2412 jit_unget_reg(t2);
2413 jit_unget_reg(t1);
2414 jit_unget_reg(t0);
2415
2416 return (w);
2417}
2418
2419static jit_word_t
2420_boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2421{
2422 jit_word_t w;
2423 jit_int32_t t0;
2424 jit_int32_t t1;
2425 jit_int32_t t2;
2426
2427 if (can_sign_extend_short_p(i1)) {
2428 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2429 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2430 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2431 SLTI(rn(t0), _ZERO_REGNO, i1);
2432 addiu(rn(t1), r0, i1);
2433 SLT(rn(t2), r0, rn(t1));
2434 SLT(rn(t1), rn(t1), r0);
2435 MOVZ(rn(t1), rn(t2), rn(t0));
2436 w = _jit->pc.w;
2437 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2438 /* delay slot */
2439 addiu(r0, r0, i1);
2440 jit_unget_reg(t2);
2441 jit_unget_reg(t1);
2442 jit_unget_reg(t0);
2443 }
2444 else {
2445 t0 = jit_get_reg(jit_class_gpr);
2446 movi(rn(t0), i1);
2447 w = boaddr(i0, r0, rn(t0));
2448 jit_unget_reg(t0);
2449 }
2450 return (w);
2451}
2452
2453static jit_word_t
2454_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2455{
2456 jit_word_t w;
2457 jit_int32_t t0;
2458 jit_int32_t t1;
2459
2460 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2461 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2462 addr(rn(t0), r0, r1);
2463 SLTU(rn(t1), rn(t0), r0);
2464 w = _jit->pc.w;
2465 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2466 /* delay slot */
2467 movr(r0, rn(t0));
2468 jit_unget_reg(t1);
2469 jit_unget_reg(t0);
2470 return (w);
2471}
2472
2473static jit_word_t
2474_boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2475{
2476 jit_word_t w;
2477 jit_int32_t t0;
2478 jit_int32_t t1;
2479
2480 if (can_sign_extend_short_p(i0)) {
2481 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2482 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2483 addiu(rn(t0), r0, i1);
2484 SLTU(rn(t1), rn(t0), r0);
2485 w = _jit->pc.w;
2486 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2487 /* delay slot */
2488 movr(r0, rn(t0));
2489 jit_unget_reg(t1);
2490 jit_unget_reg(t0);
2491 }
2492 else {
2493 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2494 movi(rn(t0), i1);
2495 w = boaddr_u(i0, r0, rn(t0));
2496 jit_unget_reg(t0);
2497 }
2498 return (w);
2499}
2500
2501static jit_word_t
2502_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2503{
2504 jit_word_t w;
2505 jit_int32_t t0;
2506 jit_int32_t t1;
2507 jit_int32_t t2;
2508
2509 /* t1 = r0 + r1; overflow = r1 < 0 ? r0 < t1 : t1 < r0 */
2510 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2511 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2512 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2513 SLT(rn(t0), r1, _ZERO_REGNO); /* t0 = r1 < 0 */
2514 addr(rn(t1), r0, r1); /* t1 = r0 + r1 */
2515 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2516 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2517 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
2518 w = _jit->pc.w;
2519 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2520 /* delay slot */
2521 addr(r0, r0, r1);
2522 jit_unget_reg(t2);
2523 jit_unget_reg(t1);
2524 jit_unget_reg(t0);
2525
2526 return (w);
2527}
2528
2529static jit_word_t
2530_bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2531{
2532 jit_word_t w;
2533 jit_int32_t t0;
2534 jit_int32_t t1;
2535 jit_int32_t t2;
2536
2537 if (can_sign_extend_short_p(i1)) {
2538 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2539 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2540 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2541 SLTI(rn(t0), _ZERO_REGNO, i1);
2542 addiu(rn(t1), r0, i1);
2543 SLT(rn(t2), r0, rn(t1));
2544 SLT(rn(t1), rn(t1), r0);
2545 MOVZ(rn(t1), rn(t2), rn(t0));
2546 w = _jit->pc.w;
2547 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2548 /* delay slot */
2549 addiu(r0, r0, i1);
2550 jit_unget_reg(t2);
2551 jit_unget_reg(t1);
2552 jit_unget_reg(t0);
2553 }
2554 else {
2555 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2556 movi(rn(t0), i1);
2557 w = bxaddr(i0, r0, rn(t0));
2558 jit_unget_reg(t0);
2559 }
2560 return (w);
2561}
2562
2563static jit_word_t
2564_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2565{
2566 jit_word_t w;
2567 jit_int32_t t0;
2568 jit_int32_t t1;
2569
2570 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2571 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2572 addr(rn(t0), r0, r1);
2573 SLTU(rn(t1), rn(t0), r0);
2574 w = _jit->pc.w;
2575 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2576 /* delay slot */
2577 movr(r0, rn(t0));
2578 jit_unget_reg(t1);
2579 jit_unget_reg(t0);
2580 return (w);
2581}
2582
2583static jit_word_t
2584_bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2585{
2586 jit_word_t w;
2587 jit_int32_t t0;
2588 jit_int32_t t1;
2589
2590 if (can_sign_extend_short_p(i0)) {
2591 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2592 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2593 addiu(rn(t0), r0, i1);
2594 SLTU(rn(t1), rn(t0), r0);
2595 w = _jit->pc.w;
2596 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2597 /* delay slot */
2598 movr(r0, rn(t0));
2599 jit_unget_reg(t1);
2600 jit_unget_reg(t0);
2601 }
2602 else {
2603 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2604 movi(rn(t0), i1);
2605 w = bxaddr_u(i0, r0, rn(t0));
2606 jit_unget_reg(t0);
2607 }
2608 return (w);
2609}
2610
2611static jit_word_t
2612_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2613{
2614 jit_word_t w;
2615 jit_int32_t t0;
2616 jit_int32_t t1;
2617 jit_int32_t t2;
2618
2619 /* t1 = r0 - r1; overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
2620 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2621 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2622 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2623 SLT(rn(t0), _ZERO_REGNO, r1); /* t0 = 0 < r1 */
2624 subr(rn(t1), r0, r1); /* t1 = r0 - r1 */
2625 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2626 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2627 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (r0 == 0) t1 = t2 */
2628 w = _jit->pc.w;
2629 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2630 /* delay slot */
2631 subr(r0, r0, r1);
2632 jit_unget_reg(t2);
2633 jit_unget_reg(t1);
2634 jit_unget_reg(t0);
2635
2636 return (w);
2637}
2638
2639static jit_word_t
2640_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2641{
2642 jit_word_t w;
2643 jit_int32_t t0;
2644 jit_int32_t t1;
2645 jit_int32_t t2;
2646
2647 if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
2648 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2649 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2650 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2651 SLTI(rn(t0), _ZERO_REGNO, i1);
2652 addiu(rn(t1), r0, -i1);
2653 SLT(rn(t2), rn(t1), r0);
2654 SLT(rn(t1), r0, rn(t1));
2655 MOVZ(rn(t1), rn(t2), rn(t0));
2656 w = _jit->pc.w;
2657 BNE(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2658 /* delay slot */
2659 addiu(r0, r0, -i1);
2660 jit_unget_reg(t2);
2661 jit_unget_reg(t1);
2662 jit_unget_reg(t0);
2663 }
2664 else {
2665 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2666 movi(rn(t0), i1);
2667 w = bosubr(i0, r0, rn(t0));
2668 jit_unget_reg(t0);
2669 }
2670 return (w);
2671}
2672
2673static jit_word_t
2674_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2675{
2676 jit_word_t w;
2677 jit_int32_t t0;
2678 jit_int32_t t1;
2679
2680 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2681 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2682 subr(rn(t0), r0, r1);
2683 SLTU(rn(t1), r0, rn(t0));
2684 w = _jit->pc.w;
2685 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2686 /* delay slot */
2687 movr(r0, rn(t0));
2688 jit_unget_reg(t1);
2689 jit_unget_reg(t0);
2690 return (w);
2691}
2692
2693static jit_word_t
2694_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2695{
2696 jit_word_t w;
2697 jit_int32_t t0;
2698 jit_int32_t t1;
2699
2700 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
2701 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2702 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2703 addiu(rn(t0), r0, -i1);
2704 SLTU(rn(t1), r0, rn(t0));
2705 w = _jit->pc.w;
2706 BNE(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2707 /* delay slot */
2708 movr(r0, rn(t0));
2709 jit_unget_reg(t1);
2710 jit_unget_reg(t0);
2711 }
2712 else {
2713 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2714 movi(rn(t0), i1);
2715 w = bosubr_u(i0, r0, rn(t0));
2716 jit_unget_reg(t0);
2717 }
2718 return (w);
2719}
2720
2721static jit_word_t
2722_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2723{
2724 jit_word_t w;
2725 jit_int32_t t0;
2726 jit_int32_t t1;
2727 jit_int32_t t2;
2728
2729 /* t1 = r0 - r1; overflow = 0 < r1 ? r0 < t1 : t1 < r0 */
2730 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2731 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2732 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2733 SLT(rn(t0), _ZERO_REGNO, r1); /* t0 = 0 < r1 */
2734 subr(rn(t1), r0, r1); /* t1 = r0 - r1 */
2735 SLT(rn(t2), rn(t1), r0); /* t2 = t1 < r0 */
2736 SLT(rn(t1), r0, rn(t1)); /* t1 = r0 < t1 */
2737 MOVZ(rn(t1), rn(t2), rn(t0)); /* if (t0 == 0) t1 = t2 */
2738 w = _jit->pc.w;
2739 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2740 /* delay slot */
2741 subr(r0, r0, r1);
2742 jit_unget_reg(t2);
2743 jit_unget_reg(t1);
2744 jit_unget_reg(t0);
2745
2746 return (w);
2747}
2748
2749static jit_word_t
2750_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2751{
2752 jit_word_t w;
2753 jit_int32_t t0;
2754 jit_int32_t t1;
2755 jit_int32_t t2;
2756
2757 if (can_sign_extend_short_p(i1) && (i1 & 0xffff) != 0x8000) {
2758 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2759 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2760 t2 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2761 SLTI(rn(t0), _ZERO_REGNO, i1);
2762 addiu(rn(t1), r0, -i1);
2763 SLT(rn(t2), rn(t1), r0);
2764 SLT(rn(t1), r0, rn(t1));
2765 MOVZ(rn(t1), rn(t2), rn(t0));
2766 w = _jit->pc.w;
2767 BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
2768 /* delay slot */
2769 addiu(r0, r0, -i1);
2770 jit_unget_reg(t2);
2771 jit_unget_reg(t1);
2772 jit_unget_reg(t0);
2773 }
2774 else {
2775 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2776 movi(rn(t0), i1);
2777 w = bxsubr(i0, r0, rn(t0));
2778 jit_unget_reg(t0);
2779 }
2780 return (w);
2781}
2782
2783static jit_word_t
2784_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2785{
2786 jit_word_t w;
2787 jit_int32_t t0;
2788 jit_int32_t t1;
2789
2790 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2791 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2792 subr(rn(t0), r0, r1);
2793 SLTU(rn(t1), r0, rn(t0));
2794 w = _jit->pc.w;
2795 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2796 /* delay slot */
2797 movr(r0, rn(t0));
2798 jit_unget_reg(t1);
2799 jit_unget_reg(t0);
2800 return (w);
2801}
2802
2803static jit_word_t
2804_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2805{
2806 jit_word_t w;
2807 jit_int32_t t0;
2808 jit_int32_t t1;
2809
2810 if (can_sign_extend_short_p(i0) && (i0 & 0xffff) != 0x8000) {
2811 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2812 t1 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2813 addiu(rn(t0), r0, -i1);
2814 SLTU(rn(t1), r0, rn(t0));
2815 w = _jit->pc.w;
2816 BEQ(_ZERO_REGNO, rn(t1), ((i0 - w) >> 2) - 1);
2817 /* delay slot */
2818 movr(r0, rn(t0));
2819 jit_unget_reg(t1);
2820 jit_unget_reg(t0);
2821 }
2822 else {
2823 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2824 movi(rn(t0), i1);
2825 w = bxsubr_u(i0, r0, rn(t0));
2826 jit_unget_reg(t0);
2827 }
2828 return (w);
2829}
2830
2831static jit_word_t
2832_bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2833{
2834 jit_word_t w;
2835 jit_int32_t t0;
2836 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2837 AND(rn(t0), r0, r1);
2838 w = _jit->pc.w;
2839 BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2840 NOP(1);
2841 jit_unget_reg(t0);
2842 return (w);
2843}
2844
2845static jit_word_t
2846_bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2847{
2848 jit_word_t w;
2849 jit_int32_t t0;
2850 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2851 if (can_zero_extend_short_p(i1)) {
2852 ANDI(rn(t0), r0, i1);
2853 w = _jit->pc.w;
2854 BNE(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2855 NOP(1);
2856 }
2857 else {
2858 movi(rn(t0), i1);
2859 w = bmsr(i0, r0, rn(t0));
2860 }
2861 jit_unget_reg(t0);
2862 return (w);
2863}
2864
2865static jit_word_t
2866_bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2867{
2868 jit_word_t w;
2869 jit_int32_t t0;
2870 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2871 AND(rn(t0), r0, r1);
2872 w = _jit->pc.w;
2873 BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2874 NOP(1);
2875 jit_unget_reg(t0);
2876 return (w);
2877}
2878
2879static jit_word_t
2880_bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2881{
2882 jit_word_t w;
2883 jit_int32_t t0;
2884 t0 = jit_get_reg(jit_class_gpr|jit_class_nospill);
2885 if (can_zero_extend_short_p(i1)) {
2886 ANDI(rn(t0), r0, i1);
2887 w = _jit->pc.w;
2888 BEQ(_ZERO_REGNO, rn(t0), ((i0 - w) >> 2) - 1);
2889 NOP(1);
2890 }
2891 else {
2892 movi(rn(t0), i1);
2893 w = bmcr(i0, r0, rn(t0));
2894 }
2895 jit_unget_reg(t0);
2896 return (w);
2897}
2898
2899static void
2900_callr(jit_state_t *_jit, jit_int32_t r0)
2901{
519a9ea1 2902 JALR(r0);
4a71579b
PC		 2903 if (r0 != _T9_REGNO)
2904 movr(_T9_REGNO, r0);
519a9ea1
PC		 2905 else
2906 NOP(1);
4a71579b
PC		 2907}
2908
2909static void
2910_calli(jit_state_t *_jit, jit_word_t i0)
2911{
2912 movi(_T9_REGNO, i0);
2913 JALR(_T9_REGNO);
2914 NOP(1);
2915}
2916
2917static jit_word_t
2918_calli_p(jit_state_t *_jit, jit_word_t i0)
2919{
2920 jit_word_t word;
2921
2922 word = _jit->pc.w;
2923 movi_p(_T9_REGNO, i0);
2924 JALR(_T9_REGNO);
2925 NOP(1);
2926
2927 return (word);
2928}
2929
2930static jit_int32_t fregs[] = {
2931 _F30, _F28, _F26, _F24, _F22, _F20,
2932#if !NEW_ABI
2933 _F18, _F16,
2934#endif
2935};
2936
2937static jit_int32_t iregs[] = {
2938 _S7, _S6, _S5, _S4, _S3, _S2, _S1, _S0,
2939};
2940
2941static void
2942_prolog(jit_state_t *_jit, jit_node_t *node)
2943{
2944 jit_int32_t index;
2945 jit_int32_t offset;
2946 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2947 jit_int32_t frame = -_jitc->function->frame;
2948 assert(_jitc->function->self.aoff >= frame);
2949 if (_jitc->function->assume_frame)
2950 return;
2951 _jitc->function->self.aoff = frame;
2952 }
2953 if (_jitc->function->allocar)
2954 _jitc->function->self.aoff &= -8;
2955#if NEW_ABI
2956 _jitc->function->stack = ((_jitc->function->self.alen -
2957 /* align stack at 16 bytes */
2958 _jitc->function->self.aoff) + 15) & -16;
2959#else
2960 _jitc->function->stack = ((/* first 16 bytes must be allocated */
2961 (_jitc->function->self.alen > 16 ?
2962 _jitc->function->self.alen : 16) -
2963 /* align stack at 8 bytes */
2964 _jitc->function->self.aoff) + 7) & -8;
2965#endif
2966 /* callee save registers */
2967#if NEW_ABI
2968 if ((_jitc->function->self.call & jit_call_varargs) &&
2969 jit_arg_reg_p(_jitc->function->vagp))
2970 subi(_SP_REGNO, _SP_REGNO, stack_framesize + 64);
2971 else
2972#endif
2973 subi(_SP_REGNO, _SP_REGNO, stack_framesize);
2974 offset = stack_framesize - (sizeof(jit_word_t) << 1);
2975 for (index = 0; index < jit_size(fregs); index++, offset -= 8) {
2976 if (jit_regset_tstbit(&_jitc->function->regset, fregs[index]))
2977 stxi_d(offset, _SP_REGNO, rn(fregs[index]));
2978 }
2979 for (index = 0; index < jit_size(iregs);
2980 index++, offset -= sizeof(jit_word_t)) {
2981 if (jit_regset_tstbit(&_jitc->function->regset, iregs[index]))
2982 stxi(offset, _SP_REGNO, rn(iregs[index]));
2983 }
2984 assert(offset >= sizeof(jit_word_t));
2985 stxi(offset, _SP_REGNO, _RA_REGNO);
2986 stxi(0, _SP_REGNO, _BP_REGNO);
2987 movr(_BP_REGNO, _SP_REGNO);
2988
2989 /* alloca */
2990 if (_jitc->function->stack)
2991 subi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
2992 if (_jitc->function->allocar) {
2993 index = jit_get_reg(jit_class_gpr);
2994 movi(rn(index), _jitc->function->self.aoff);
2995 stxi_i(_jitc->function->aoffoff, _BP_REGNO, rn(index));
2996 jit_unget_reg(index);
2997 }
2998
2999 if (_jitc->function->self.call & jit_call_varargs) {
3000#if NEW_ABI
3001 index = _jitc->function->vagp;
3002#else
3003 index = (_jitc->function->self.size - stack_framesize) >> STACK_SHIFT;
3004#endif
3005 offset = stack_framesize + index * STACK_SLOT;
3006 for (; jit_arg_reg_p(index); ++index, offset += STACK_SLOT) {
3007#if NEW_ABI
3008 SD(rn(_A0 - index), offset, _BP_REGNO);
3009#else
3010 stxi(offset + WORD_ADJUST, _BP_REGNO, rn(_A0 - index));
3011#endif
3012 }
3013 }
3014}
3015
3016static void
3017_epilog(jit_state_t *_jit, jit_node_t *node)
3018{
3019 jit_int32_t index;
3020 jit_int32_t offset;
3021 if (_jitc->function->assume_frame)
3022 return;
3023 /* callee save registers */
3024 movr(_SP_REGNO, _BP_REGNO);
3025 offset = stack_framesize - (sizeof(jit_word_t) << 1);
3026 for (index = 0; index < jit_size(fregs); index++, offset -= 8) {
3027 if (jit_regset_tstbit(&_jitc->function->regset, fregs[index]))
3028 ldxi_d(rn(fregs[index]), _SP_REGNO, offset);
3029 }
3030 for (index = 0; index < jit_size(iregs);
3031 index++, offset -= sizeof(jit_word_t)) {
3032 if (jit_regset_tstbit(&_jitc->function->regset, iregs[index]))
3033 ldxi(rn(iregs[index]), _SP_REGNO, offset);
3034 }
3035 assert(offset >= sizeof(jit_word_t));
3036 ldxi(_RA_REGNO, _SP_REGNO, offset);
3037 ldxi(_BP_REGNO, _SP_REGNO, 0);
3038 JR(_RA_REGNO);
3039 /* delay slot */
3040#if NEW_ABI
3041 if ((_jitc->function->self.call & jit_call_varargs) &&
3042 jit_arg_reg_p(_jitc->function->vagp))
3043 addi(_SP_REGNO, _SP_REGNO, stack_framesize + 64);
3044 else
3045#endif
3046 addi(_SP_REGNO, _SP_REGNO, stack_framesize);
3047}
3048
3049static void
3050_vastart(jit_state_t *_jit, jit_int32_t r0)
3051{
3052 assert(_jitc->function->self.call & jit_call_varargs);
3053 /* Initialize va_list to the first stack argument. */
3054#if NEW_ABI
3055 if (jit_arg_reg_p(_jitc->function->vagp))
3056 addi(r0, _BP_REGNO, stack_framesize + _jitc->function->vagp *
3057 sizeof(jit_int64_t));
3058 else
3059#endif
3060 addi(r0, _BP_REGNO, _jitc->function->self.size);
3061}
3062
3063static void
3064_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3065{
3066 /* Load argument. */
3067#if WORD_ADJUST
3068 ldxi(r0, r1, WORD_ADJUST);
3069#else
3070 ldr(r0, r1);
3071#endif
3072
3073 /* Update va_list. */
3074 addi(r1, r1, STACK_SLOT);
3075}
3076
3077static void
3078_patch_abs(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3079{
3080 jit_instr_t i;
3081 union {
3082 jit_int32_t *i;
3083 jit_word_t w;
3084 } u;
3085
3086 u.w = instr;
3087#if __WORDSIZE == 32
3088 i.op = u.i[0];
3089 assert(i.hc.b == MIPS_LUI);
3090 i.is.b = label >> 16;
3091 u.i[0] = i.op;
3092 i.op = u.i[1];
3093 assert(i.hc.b == MIPS_ORI);
3094 i.is.b = label;
3095 u.i[1] = i.op;
3096#else
3097 i.op = u.i[0];
3098 assert(i.hc.b == MIPS_LUI);
3099 i.is.b = label >> 48;
3100 u.i[0] = i.op;
3101 i.op = u.i[1];
3102 assert(i.hc.b == MIPS_ORI);
3103 i.is.b = label >> 32;
3104 u.i[1] = i.op;
3105 /* lshi */
3106 i.op = u.i[3];
3107 assert(i.hc.b == MIPS_ORI);
3108 i.is.b = label >> 16;
3109 u.i[3] = i.op;
3110 /* lshi */
3111 i.op = u.i[5];
3112 assert(i.hc.b == MIPS_ORI);
3113 i.is.b = label;
3114 u.i[5] = i.op;
3115#endif
3116}
3117
3118static void
3119_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3120{
3121 jit_instr_t i;
3122 union {
3123 jit_int32_t *i;
3124 jit_word_t w;
3125 } u;
3126
3127 u.w = instr;
3128 i.op = u.i[0];
3129 switch (i.hc.b) {
3130 /* 16 bit immediate opcodes */
3131 case MIPS_REGIMM:
3132 switch (i.rt.b) {
3133 case MIPS_BLTZ: case MIPS_BLTZL:
3134 case MIPS_BLTZAL: case MIPS_BLTZALL:
3135 case MIPS_BGEZ: case MIPS_BGEZAL:
3136 case MIPS_BGEZALL: case MIPS_BGEZL:
3137 case MIPS_TEQI: case MIPS_TGEI:
3138 case MIPS_TGEIU: case MIPS_TLTI:
3139 case MIPS_TLTIU: case MIPS_TNEI:
3140 i.is.b = ((label - instr) >> 2) - 1;
3141 u.i[0] = i.op;
3142 break;
3143 default:
3144 assert(!"unhandled branch opcode");
3145 break;
3146 }
3147 break;
3148
3149 case MIPS_COP1: case MIPS_COP2:
3150 assert(i.rs.b == MIPS_BC);
3151 switch (i.rt.b) {
3152 case MIPS_BCF: case MIPS_BCFL:
3153 case MIPS_BCT: case MIPS_BCTL:
3154 i.is.b = ((label - instr) >> 2) - 1;
3155 u.i[0] = i.op;
3156 break;
3157 default:
3158 assert(!"unhandled branch opcode");
3159 break;
3160 }
3161 break;
3162
3163 case MIPS_BLEZ: case MIPS_BLEZL:
3164 case MIPS_BEQ: case MIPS_BEQL:
3165 case MIPS_BGTZ: case MIPS_BGTZL:
3166 case MIPS_BNE: case MIPS_BNEL:
3167 i.is.b = ((label - instr) >> 2) - 1;
3168 u.i[0] = i.op;
3169 break;
3170
3171 case MIPS_LUI:
3172 patch_abs(instr, label);
3173 break;
3174
3175 case MIPS_J: case MIPS_JAL:
3176 case MIPS_JALX:
3177 assert(((instr + sizeof(jit_int32_t)) & 0xf0000000) ==
3178 (label & 0xf0000000));
3179 i.ii.b = (label & ~0xf0000000) >> 2;
3180 u.i[0] = i.op;
3181 break;
3182
3183 default:
3184 assert(!"unhandled branch opcode");
3185 break;
3186 }
3187}
3188#endif
ARM optimized PCSX fork