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