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