notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update lightrec 20220910 (#686)
[pcsx_rearmed.git] / deps / lightning / lib / jit_ppc-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
21# if __WORDSIZE == 32
22# define gpr_save_area 72 /* r14~r31 = 18 * 4 */
23# if _CALL_SYSV
24# define params_offset (sizeof(jit_word_t) << 1)
25# else
26# define params_offset 24
27# endif
28# define can_sign_extend_int_p(im) 1
29# define can_zero_extend_int_p(im) 1
30# define fits_uint32_p(im) 1
31# else
32# define gpr_save_area 144 /* r14~r31 = 18 * 8 */
33# if _CALL_ELF == 2
34# define params_offset 32
35# else
36# define params_offset 48
37# endif
38# define can_sign_extend_int_p(im) \
39 (((im) >= 0 && (long)(im) <= 0x7fffffffL) || \
40 ((im) < 0 && (long)(im) >= -0x80000000L))
41# define can_zero_extend_int_p(im) \
42 ((im) >= 0 && (im) < 0x80000000L)
43# define fits_uint32_p(im) ((im & 0xffffffff00000000L) == 0)
44# endif
45# define fpr_save_area 64
46# define alloca_offset -(gpr_save_area + fpr_save_area)
47# define ii(i) *_jit->pc.ui++ = i
48# if __WORDSIZE == 32
49# define iw(i) *_jit->pc.ui++ = i
50# else
51# define iw(i) *_jit->pc.ul++ = i
52# endif
53# define can_sign_extend_short_p(im) ((im) >= -32768 && (im) <= 32767)
54# define can_zero_extend_short_p(im) ((im) >= 0 && (im) <= 65535)
55# define can_sign_extend_jump_p(im) ((im) >= -33554432 && (im) <= 33554431)
56# define _R0_REGNO 0
57# define _SP_REGNO 1
58# define _R2_REGNO 2
59# define _R11_REGNO 11
60# define _R12_REGNO 12
61# define _FP_REGNO 31
62# if __WORDSIZE == 32
63# define ldr(r0,r1) ldr_i(r0,r1)
64# define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0)
65# define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2)
66# define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
67# define stxr(r0,r1,r2) stxr_i(r0,r1,r2)
68# else
69# define ldr(r0,r1) ldr_l(r0,r1)
70# define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0)
71# define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2)
72# define stxi(i0,r0,r1) stxi_l(i0,r0,r1)
73# define stxr(r0,r1,r2) stxr_l(r0,r1,r2)
74# endif
75# define FXO(o,d,a,b,e,x) _FXO(_jit,o,d,a,b,e,x,0)
76# define FXO_(o,d,a,b,e,x) _FXO(_jit,o,d,a,b,e,x,1)
77static void _FXO(jit_state_t*,int,int,int,int,int,int,int);
78# define FDs(o,d,a,s) _FDs(_jit,o,d,a,s)
79static void _FDs(jit_state_t*,int,int,int,int);
80# define FDu(o,d,a,s) _FDu(_jit,o,d,a,s)
81static void _FDu(jit_state_t*,int,int,int,int);
82# define FX(o,d,a,b,x) _FX(_jit,o,d,a,b,x,0)
83# define FX_(o,d,a,b,x) _FX(_jit,o,d,a,b,x,1)
84static void _FX(jit_state_t*,int,int,int,int,int,int);
85# define FI(o,t,a,k) _FI(_jit,o,t,a,k)
86static void _FI(jit_state_t*,int,int,int,int);
87# define FB(o,bo,bi,t,a,k) _FB(_jit,o,bo,bi,t,a,k)
88static void _FB(jit_state_t*,int,int,int,int,int,int);
89# define FXL(o,bo,bi,x) _FXL(_jit,o,bo,bi,x,0)
90# define FXL_(o,bo,bi,x) _FXL(_jit,o,bo,bi,x,1)
91static void _FXL(jit_state_t*,int,int,int,int,int);
92# define FC(o,d,l,a,b,x) _FC(_jit,o,d,l,a,b,x)
93static void _FC(jit_state_t*,int,int,int,int,int,int);
94# define FCI(o,d,l,a,s) _FCI(_jit,o,d,l,a,s)
95static void _FCI(jit_state_t*,int,int,int,int,int);
96# define FXFX(o,s,x,f) _FXFX(_jit,o,s,x,f)
97static void _FXFX(jit_state_t*,int,int,int,int);
98# define FM(o,s,a,h,b,e,r) _FM(_jit,o,s,a,h,b,e,r)
99static void _FM(jit_state_t*,int,int,int,int,int,int,int);
100# if __WORDSIZE == 64
101# define FMDS(o,s,a,b,e,x) _FMDS(_jit,o,s,a,b,e,x,0)
102# define FMDS_(o,s,a,b,e,x) _FMDS(_jit,o,s,a,b,e,x,1)
103static void _FMDS(jit_state_t*,int,int,int,int,int,int,int);
104# define FMD(o,s,a,h,b,x,i) _FMD(_jit,o,s,a,h,b,x,i,0)
105# define FMD_(o,s,a,h,b,x,i) _FMD(_jit,o,s,a,h,b,x,i,1)
106static void _FMD(jit_state_t*,int,int,int,int,int,int,int,int);
107# define FXS(o,d,a,h,x,i) _FXS(_jit,o,d,a,h,x,i,0)
108# define FXS_(o,d,a,h,x,i) _FXS(_jit,o,d,a,h,x,i,1)
109static void _FXS(jit_state_t*,int,int,int,int,int,int,int);
110# endif
111# define CR_0 0
112# define CR_1 1
113# define CR_2 2
114# define CR_3 3
115# define CR_4 4
116# define CR_5 5
117# define CR_6 6
118# define CR_7 7
119# define CR_LT 0
120# define CR_GT 1
121# define CR_EQ 2
122# define CR_SO 3
123# define CR_UN 3
124# define BCC_F 4
125# define BCC_T 12
126# define ADD(d,a,b) FXO(31,d,a,b,0,266)
127# define ADD_(d,a,b) FXO_(31,d,a,b,0,266)
128# define ADDO(d,a,b) FXO(31,d,a,b,1,266)
129# define ADDO_(d,a,b) FXO_(31,d,a,b,1,266)
130# define ADDC(d,a,b) FXO_(31,d,a,b,0,10)
131# define ADDC_(d,a,b) FXO_(31,d,a,b,0,10)
132# define ADDCO(d,a,b) FXO(31,d,a,b,1,10)
133# define ADDCO_(d,a,b) FXO_(31,d,a,b,1,10)
134# define ADDE(d,a,b) FXO(31,d,a,b,0,138)
135# define ADDE_(d,a,b) FXO_(31,d,a,b,0,138)
136# define ADDEO(d,a,b) FXO(31,d,a,b,1,138)
137# define ADDEO_(d,a,b) FXO_(31,d,a,b,1,138)
138# define ADDI(d,a,s) FDs(14,d,a,s)
139# define ADDIC(d,a,s) FDs(12,d,a,s)
140# define ADDIC_(d,a,s) FDs(13,d,a,s)
141# define ADDIS(d,a,s) FDs(15,d,a,s)
142# define LIS(d,s) ADDIS(d,0,s)
143# define ADDME(d,a) FXO(31,d,a,0,0,234)
144# define ADDME_(d,a) FXO_(31,d,a,0,0,234)
145# define ADDMEO(d,a) FXO(31,d,a,0,1,234)
146# define ADDMEO_(d,a) FXO_(31,d,a,0,1,234)
147# define ADDZE(d,a) FXO(31,d,a,0,0,202)
148# define ADDZE_(d,a) FXO_(31,d,a,0,0,202)
149# define ADDZEO(d,a) FXO(31,d,a,0,1,202)
150# define ADDZEO_(d,a) FXO_(31,d,a,0,1,202)
151# define AND(d,a,b) FX(31,a,d,b,28)
152# define ANDC(d,a,b) FXO(31,a,d,b,0,60)
153# define ANDC_(d,a,b) FXO_(31,a,d,b,0,60)
154# define AND_(d,a,b) FX_(31,a,b,d,28)
155# define ANDI_(d,a,u) FDu(28,a,d,u)
156# define ANDIS_(d,a,u) FDu(29,a,d,u)
157# define B(t) FI(18,t,0,0)
158# define BA(t) FI(18,t,1,0)
159# define BL(t) FI(18,t,0,1)
160# define BLA(t) FI(18,t,1,1)
161# define BC(o,i,t) FB(16,o,i,t,0,0)
162# define BCA(o,i,t) FB(16,o,i,t,1,0)
163# define BCL(o,i,t) FB(16,o,i,t,0,1)
164# define BCLA(o,i,t) FB(16,o,i,t,1,1)
165# define BLT(t) BC(BCC_T,CR_LT,t)
166# define BLE(t) BC(BCC_F,CR_GT,t)
167# define BEQ(t) BC(BCC_T,CR_EQ,t)
168# define BGE(t) BC(BCC_F,CR_LT,t)
169# define BGT(t) BC(BCC_T,CR_GT,t)
170# define BNE(t) BC(BCC_F,CR_EQ,t)
171# define BUN(t) BC(BCC_T,CR_UN,t)
172# define BNU(t) BC(BCC_F,CR_UN,t)
173# define BCCTR(o,i) FXL(19,o,i,528)
174# define BCCTRL(o,i) FXL_(19,o,i,528)
175# define BLTCTR() BCCTR(BCC_T,CR_LT)
176# define BLECTR() BCCTR(BCC_F,CR_GT)
177# define BEQCTR() BCCTR(BCC_T,CR_EQ)
178# define BGECTR() BCCTR(BCC_F,CR_LT)
179# define BGTCTR() BCCTR(BCC_T,CR_GT)
180# define BNECTR() BCCTR(BCC_F,CR_EQ)
181# define BCTR() BCCTR(20,0)
182# define BCTRL() BCCTRL(20,0)
183# define BCLR(o,i) FXL(19,o,i,16)
184# define BCLRL(o,i) FXL_(19,o,i,16)
185# define BLTLR() BCLR(BCC_T,CR_LT)
186# define BLELR() BCLR(BCC_F,CR_GT)
187# define BEQLR() BCLR(BCC_T,CR_EQ)
188# define BGELR() BCLR(BCC_F,CR_LT)
189# define BGTLR() BCLR(BCC_T,CR_GT)
190# define BNELR() BCLR(BCC_F,CR_EQ)
191# define BLR() BCLR(20,0)
192# define BLRL() BCLRL(20,0)
193# define XCMP(cr,l,a,b) FC(31,cr,l,a,b,0)
194# define CMPD(a,b) XCMP(0,1,a,b)
195# define CMPW(a,b) XCMP(0,0,a,b)
196# define XCMPI(cr,l,a,s) FCI(11,cr,l,a,s)
197# define CMPDI(a,s) XCMPI(0,1,a,s)
198# define CMPWI(a,s) XCMPI(0,0,a,s)
199# define XCMPL(cr,l,a,b) FC(31,cr,l,a,b,32)
200# define CMPLD(a,b) XCMPL(0,1,a,b)
201# define CMPLW(a,b) XCMPL(0,0,a,b)
202# define XCMPLI(cr,l,a,u) FCI(10,cr,l,a,u)
203# define CMPLDI(a,s) XCMPLI(0,1,a,s)
204# define CMPLWI(a,s) XCMPLI(0,0,a,s)
205# define CNTLZW(a,s) FX(31,s,a,0,26)
206# define CNTLZW_(a,s) FX_(31,s,a,0,26)
207# define CRAND(d,a,b) FX(19,d,a,b,257)
208# define CRANDC(d,a,b) FX(19,d,a,b,129)
209# define CREQV(d,a,b) FX(19,d,a,b,289)
210# define CRSET(d) CREQV(d,d,d)
211# define CRNAND(d,a,b) FX(19,d,a,b,225)
212# define CRNOR(d,a,b) FX(19,d,a,b,33)
213# define CRNOT(d,a) CRNOR(d,a,a)
214# define CROR(d,a,b) FX(19,d,a,b,449)
215# define CRMOVE(d,a) CROR(d,a,a)
216# define CRORC(d,a,b) FX(19,d,a,b,417)
217# define CRXOR(d,a,b) FX(19,d,a,b,193)
218# define CRCLR(d) CRXOR(d,d,d)
219# define DCBA(a,b) FX(31,0,a,b,758)
220# define DCBF(a,b) FX(31,0,a,b,86)
221# define DCBI(a,b) FX(31,0,a,b,470)
222# define DCBST(a,b) FX(31,0,a,b,54)
223# define DCBT(a,b) FX(31,0,a,b,278)
224# define DCBTST(a,b) FX(31,0,a,b,246)
225# define DCBZ(a,b) FX(31,0,a,b,1014)
226# define DIVW(d,a,b) FXO(31,d,a,b,0,491)
227# define DIVW_(d,a,b) FXO_(31,d,a,b,0,491)
228# define DIVWO(d,a,b) FXO(31,d,a,b,1,491)
229# define DIVWO_(d,a,b) FXO_(31,d,a,b,1,491)
230# define DIVWU(d,a,b) FXO(31,d,a,b,0,459)
231# define DIVWU_(d,a,b) FXO_(31,d,a,b,0,459)
232# define DIVWUO(d,a,b) FXO(31,d,a,b,1,459)
233# define DIVWUO_(d,a,b) FXO_(31,d,a,b,1,459)
234# define DIVD(d,a,b) FXO(31,d,a,b,0,489)
235# define DIVD_(d,a,b) FXO_(31,d,a,b,0,489)
236# define DIVDO(d,a,b) FXO(31,d,a,b,1,489)
237# define DIVDO_(d,a,b) FXO_(31,d,a,b,1,489)
238# define DIVDU(d,a,b) FXO(31,d,a,b,0,457)
239# define DIVDU_(d,a,b) FXO_(31,d,a,b,0,457)
240# define DIVDUO(d,a,b) FXO(31,d,a,b,1,457)
241# define DIVDUO_(d,a,b) FXO_(31,d,a,b,1,457)
242# define ECIWX(d,a,b) FX(31,d,a,b,310)
243# define ECOWX(s,a,b) FX(31,s,a,b,438)
244# define EIEIO() FX(31,0,0,0,854)
245# define EQV(d,a,b) FX(31,a,d,b,284)
246# define EQV_(d,a,b) FX_(31,a,d,b,284)
247# define EXTSB(d,a) FX(31,a,d,0,954)
248# define EXTSB_(d,a) FX_(31,a,d,0,954)
249# define EXTSH(d,a) FX(31,a,d,0,922)
250# define EXTSH_(d,a) FX_(31,a,d,0,922)
251# define EXTSW(d,a) FX(31,a,d,0,986)
252# define EXTSW_(d,a) FX_(31,a,d,0,986)
253# define ICIB(a,b) FX(31,0,a,b,982)
254# define ISYNC() FXL(19,0,0,150)
255# define LBZ(d,a,s) FDs(34,d,a,s)
256# define LBZU(d,a,s) FDs(35,d,a,s)
257# define LBZUX(d,a,b) FX(31,d,a,b,119)
258# define LBZX(d,a,b) FX(31,d,a,b,87)
259# define LHA(d,a,s) FDs(42,d,a,s)
260# define LHAU(d,a,s) FDs(43,d,a,s)
261# define LHAUX(d,a,b) FX(31,d,a,b,375)
262# define LHAX(d,a,b) FX(31,d,a,b,343)
ba3814c1 263# define LHBRX(d,a,b) FX(31,d,a,b,790)
4a71579b
PC		 264# define LHZ(d,a,s) FDs(40,d,a,s)
265# define LHZU(d,a,s) FDs(41,d,a,s)
266# define LHZUX(d,a,b) FX(31,d,a,b,311)
267# define LHZX(d,a,b) FX(31,d,a,b,279)
268# define LA(d,a,s) ADDI(d,a,s)
269# define LI(d,s) ADDI(d,0,s)
270# define LMW(d,a,s) FDs(46,d,a,s)
271# define LSWI(d,a,n) FX(31,d,a,n,597)
272# define LSWX(d,a,b) FX(31,d,a,b,533)
273# define LWARX(d,a,b) FX(31,d,a,b,20)
ba3814c1 274# define LDARX(d,a,b) FX(31,d,a,b,84)
4a71579b
PC		 275# define LWBRX(d,a,b) FX(31,d,a,b,534)
276# define LWA(d,a,s) FDs(58,d,a,s|2)
277# define LWAUX(d,a,b) FX(31,d,a,b,373)
278# define LWAX(d,a,b) FX(31,d,a,b,341)
279# define LWZ(d,a,s) FDs(32,d,a,s)
280# define LWZU(d,a,s) FDs(33,d,a,s)
281# define LWZUX(d,a,b) FX(31,d,a,b,55)
282# define LWZX(d,a,b) FX(31,d,a,b,23)
283# define LD(d,a,s) FDs(58,d,a,s)
284# define LDX(d,a,b) FX(31,d,a,b,21)
285# define MCRF(d,s) FXL(19,d<<2,(s)<<2,0)
286# if DEBUG
287/* In case instruction is emulated, check the kernel can handle it.
288 Will only generate it if DEBUG is enabled.
289"""
290Chapter 6. Optional Facilities and Instructions that are being
291Phased Out of the Architecture
292...
2936.1 Move To Condition Register from XER
294The mcrxr instruction is being phased out of the archi-
295tecture. Its description is included here as an aid to
296constructing operating system code to emulate it.
297
298Move to Condition Register from XER
299X-form
300mcrxr BF
30131 BF // /// /// 512 /
3020 6 9 11 16 21 31
303CR(4xBF:4xBF+3) <- XER(32:35)
304XER(32:35) <- 0b0000
305The contents of XER(32:35) are copied to Condition Reg-
306ister field BF. XER(32:35) are set to zero.
307Special Registers Altered:
308CR field BF XER(32:35)
309
310Programming Note
311Warning: This instruction has been phased out of
312the architecture. Attempting to execute this
313instruction will cause the system illegal instruction
314error handler to be invoked
315"""
316 */
317# define MCRXR(d) FX(31,d<<2,0,0,512)
318# else
319# define MCRXR(cr) _MCRXR(_jit,cr);
320static void _MCRXR(jit_state_t*, jit_int32_t);
321# endif
322# define MFCR(d) FX(31,d,0,0,19)
323# define MFMSR(d) FX(31,d,0,0,83)
324# define MFSPR(d,s) FXFX(31,d,s<<5,339)
325# define MFXER(d) MFSPR(d,1)
326# define MFLR(d) MFSPR(d,8)
327# define MFCTR(d) MFSPR(d,9)
328# define MFSR(d,s) FX(31,d,s,0,595)
329# define MFSRIN(d,b) FX(31,d,0,b,659)
330# define MFTB(d,x,y) FXFX(31,d,(x)|((y)<<5),371)
331# define MFTBL(d) MFTB(d,8,12)
332# define MFTBU(d) MFTB(d,8,13)
333# define MTCRF(c,s) FXFX(31,s,c<<1,144)
334# define MTCR(s) MTCRF(0xff,s)
335# define MTMSR(s) FX(31,s,0,0,146)
336# define MTSPR(d,s) FXFX(31,d,s<<5,467)
337# define MTXER(d) MTSPR(d,1)
338# define MTLR(d) MTSPR(d,8)
339# define MTCTR(d) MTSPR(d,9)
340# define MTSR(r,s) FX(31,s<<1,r,0,210)
341# define MTSRIN(r,b) FX(31,r<<1,0,b,242)
342# define MULLI(d,a,s) FDs(07,d,a,s)
343# define MULHW(d,a,b) FXO(31,d,a,b,0,75)
344# define MULHW_(d,a,b) FXO_(31,d,a,b,0,75)
345# define MULHWU(d,a,b) FXO(31,d,a,b,0,11)
346# define MULHWU_(d,a,b) FXO_(31,d,a,b,0,11)
347# define MULLW(d,a,b) FXO(31,d,a,b,0,235)
348# define MULLW_(d,a,b) FXO_(31,d,a,b,0,235)
349# define MULLWO(d,a,b) FXO(31,d,a,b,1,235)
350# define MULLWO_(d,a,b) FXO_(31,d,a,b,1,235)
351# define MULHD(d,a,b) FXO(31,d,a,b,0,73)
352# define MULHD_(d,a,b) FXO_(31,d,a,b,0,73)
353# define MULHDU(d,a,b) FXO(31,d,a,b,0,9)
354# define MULHDU_(d,a,b) FXO_(31,d,a,b,0,9)
355# define MULLD(d,a,b) FXO(31,d,a,b,0,233)
356# define MULLD_(d,a,b) FXO_(31,d,a,b,0,233)
357# define MULLDO(d,a,b) FXO(31,d,a,b,1,233)
358# define MULLDO_(d,a,b) FXO_(31,d,a,b,1,233)
359# define NAND(d,a,b) FX(31,a,d,b,476)
360# define NAND_(d,a,b) FX_(31,a,d,b,476)
361# define NEG(d,a) FXO(31,d,a,0,0,104)
362# define NEG_(d,a) FXO_(31,d,a,0,0,104)
363# define NEGO(d,a) FXO(31,d,a,0,1,104)
364# define NEGO_(d,a) FXO_(31,d,a,0,1,104)
365# define NOR(d,a,b) FX(31,a,d,b,124)
366# define NOR_(d,a,b) FX_(31,a,d,b,124)
367# define NOT(d,s) NOR(d,s,s)
368# define OR(d,a,b) FX(31,a,d,b,444)
369# define OR_(d,a,b) FX_(31,a,d,b,444)
370# define MR(d,a) OR(d,a,a)
371# define ORC(d,a,b) FX(31,a,d,b,412)
372# define ORC_(d,a,b) FX_(31,a,d,b,412)
373# define ORI(d,a,u) FDu(24,a,d,u)
374# define NOP() ORI(0,0,0)
375# define ORIS(d,a,u) FDu(25,a,d,u)
376# define RFI() FXL(19,0,0,50)
377# define RLWIMI(d,s,h,b,e) FM(20,s,d,h,b,e,0)
378# define RLWIMI_(d,s,h,b,e) FM(20,s,d,h,b,e,1)
379# define INSLWI(a,s,n,b) RLWIMI(a,s,32-b,b,b+n-1)
380# define INSRWI(a,s,n,b) RLWIMI(a,s,32-(b+n),b,(b+n)-1)
381# define RLWINM(a,s,h,b,e) FM(21,s,a,h,b,e,0)
382# define RLWINM_(a,s,h,b,e) FM(21,s,a,h,b,e,1)
383# define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,n-1)
384# define EXTRWI(a,s,n,b) RLWINM(a,s,b+n,32-n,31)
385# define ROTLWI(a,s,n) RLWINM(a,s,n,0,31)
386# define ROTRWI(a,s,n) RLWINM(a,s,32-n,0,31)
387# define SLWI(a,s,n) RLWINM(a,s,n,0,31-n)
388# define SRWI(a,s,n) RLWINM(a,s,32-n,n,31)
389# define CLRLWI(a,s,n) RLWINM(a,s,0,n,31)
390# define CLRRWI(a,s,n) RLWINM(a,s,0,0,31-n)
391# define CLRLSWI(a,s,b,n) RLWINM(a,s,n,b-n,31-n)
392# define RLWNM(a,s,b,m,e) FM(23,s,a,b,m,e,0)
393# define RLWNM_(a,s,b,m,e) FM(23,s,a,b,m,e,1)
394# define ROTLW(a,s,b) RLWNM(a,s,b,0,31)
395# define SC() FDu(17,0,0,2)
396# define SLW(a,s,b) FX(31,s,a,b,24)
397# define SLW_(a,s,b) FX_(31,s,a,b,24)
398# define SRAW(a,s,b) FX(31,s,a,b,792)
399# define SRAW_(a,s,b) FX_(31,s,a,b,792)
400# define SRAWI(a,s,h) FX(31,s,a,h,824)
401# define SRAWI_(a,s,h) FX_(31,s,a,h,824)
402# define SRW(a,s,b) FX(31,s,a,b,536)
403# define SRW_(a,s,b) FX_(31,s,a,b,536)
404# if __WORDSIZE == 64
405# define RLDICL(a,s,h,b) FMD(30,s,a,h&~32,b,0,h>>5)
406# define RLDICL_(a,s,h,b) FMD_(30,s,a,h&~32,b,0,h>>5)
407# define EXTRDI(x,y,n,b) RLDICL(x,y,(b+n),(64-n))
408# define SRDI(x,y,n) RLDICL(x,y,(64-n),n)
409# define CLRLDI(x,y,n) RLDICL(x,y,0,n)
410# define RLDICR(a,s,h,e) FMD(30,s,a,h&~32,e,1,h>>5)
411# define RLDICR_(a,s,h,e) FMD_(30,s,a,h&~32,e,1,h>>5)
412# define EXTRLI(x,y,n,b) RLDICR(x,y,b,(n-1))
413# define SLDI(x,y,n) RLDICR(x,y,n,(63-n))
414# define CLRRDI(x,y,n) RLDICR(x,y,0,(63-n))
415# define RLDIC(a,s,h,b) FMD(30,s,a,h&~32,b,2,h>>5)
416# define RLDIC_(a,s,h,b) FMD_(30,s,a,h&~32,b,2,h>>5)
417# define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,(b-n))
418# define RLDCL(a,s,h,b) FMDS(30,s,a,h,b,8)
419# define RLDCL_(a,s,h,b) FMDS_(30,s,a,h,b,8)
420# define ROTLD(x,y,z) RLDCL(x,y,z,0)
421# define RLDCR(a,s,b,e) FMDS(30,s,a,b,e,0)
422# define RLDCR_(a,s,b,e) FMDS_(30,s,a,b,e,0)
423# define RLDIMI(a,s,h,b) FMD(30,s,a,h&~32,b,3,h>>5)
424# define RLDIMI_(a,s,h,b) FMD_(30,s,a,h&~32,b,3,h>>5)
425# define INSRDI(x,y,n,b) RLDIMI(x,y,(64-(b+n)),b)
426# define SLD(a,s,b) FX(31,s,a,b,27)
427# define SLD_(a,s,b) FX_(31,s,a,b,27)
428# define SRD(a,s,b) FX(31,s,a,b,539)
429# define SRD_(a,s,b) FX_(31,s,a,b,539)
430# define SRADI(a,s,h) FXS(31,s,a,h&~32,413,h>>5)
431# define SRADI_(a,s,h) FXS_(31,s,a,h&~32,413,h>>5)
432# define SRAD(a,s,b) FX(31,s,a,b,794)
433# define SRAD_(a,s,b) FX_(31,s,a,b,794)
434# endif
435# define STB(s,a,d) FDs(38,s,a,d)
436# define STBU(s,a,d) FDs(39,s,a,d)
437# define STBUX(s,a,b) FX(31,s,a,b,247)
438# define STBX(s,a,b) FX(31,s,a,b,215)
439# define STH(s,a,d) FDs(44,s,a,d)
440# define STHBRX(s,a,b) FX(31,s,a,b,918)
441# define STHU(s,a,d) FDs(45,s,a,d)
442# define STHUX(s,a,b) FX(31,s,a,b,439)
443# define STHX(s,a,b) FX(31,s,a,b,407)
444# define STMW(s,a,d) FDs(47,s,a,d)
445# define STWSI(s,a,nb) FX(31,s,a,nb,725)
446# define STSWX(s,a,b) FX(31,s,a,b,661)
447# define STW(s,a,d) FDs(36,s,a,d)
448# define STWBRX(s,a,b) FX(31,s,a,b,662)
449# define STWCX_(s,a,b) FX_(31,s,a,b,150)
ba3814c1 450# define STDCX_(s,a,b) FX_(31,s,a,b,214)
4a71579b
PC		 451# define STWU(s,a,d) FDs(37,s,a,d)
452# define STWUX(s,a,b) FX(31,s,a,b,183)
453# define STWX(s,a,b) FX(31,s,a,b,151)
454# define STD(s,a,d) FDs(62,s,a,d)
455# define STDX(s,a,b) FX(31,s,a,b,149)
456# define STDU(s,a,d) FDs(62,s,a,d|1)
457# define STDUX(s,a,b) FX(31,s,a,b,181)
458# define SUBF(d,a,b) FXO(31,d,a,b,0,40)
459# define SUBF_(d,a,b) FXO_(31,d,a,b,0,40)
460# define SUBFO(d,a,b) FXO(31,d,a,b,1,40)
461# define SUBFO_(d,a,b) FXO_(31,d,a,b,1,40)
462# define SUB(d,a,b) SUBF(d,b,a)
463# define SUB_(d,a,b) SUBF_(d,b,a)
464# define SUBO(d,a,b) SUBFO(d,b,a)
465# define SUBO_(d,a,b) SUBFO_(d,b,a)
466# define SUBI(d,a,s) ADDI(d,a,-s)
467# define SUBIS(d,a,s) ADDIS(d,a,-s)
468# define SUBFC(d,a,b) FXO(31,d,a,b,0,8)
469# define SUBFC_(d,a,b) FXO_(31,d,a,b,0,8)
470# define SUBFCO(d,a,b) FXO(31,d,a,b,1,8)
471# define SUBFCO_(d,a,b) FXO_(31,d,a,b,1,8)
472# define SUBC(d,a,b) SUBFC(d,b,a)
473# define SUBIC(d,a,s) ADDIC(d,a,-s)
474# define SUBIC_(d,a,s) ADDIC_(d,a,-s)
475# define SUBFE(d,a,b) FXO(31,d,a,b,0,136)
476# define SUBFE_(d,a,b) FXO_(31,d,a,b,0,136)
477# define SUBFEO(d,a,b) FXO(31,d,a,b,1,136)
478# define SUBFEO_(d,a,b) FXO_(31,d,a,b,1,136)
479# define SUBE(d,a,b) SUBFE(d,b,a)
480# define SUBFIC(d,a,s) FDs(8,d,a,s)
481# define SUBFME(d,a) FXO(31,d,a,0,0,232)
482# define SUBFME_(d,a) FXO_(31,d,a,0,0,232)
483# define SUBFMEO(d,a) FXO(31,d,a,0,1,232)
484# define SUBFMEO_(d,a) FXO_(31,d,a,0,1,232)
485# define SUBFZE(d,a) FXO(31,d,a,0,0,200)
486# define SUBFZE_(d,a) FXO_(31,d,a,0,0,200)
487# define SUBFZEO(d,a) FXO(31,d,a,0,1,200)
488# define SUBFZEO_(d,a) FXO_(31,d,a,0,1,200)
489# define SYNC() FX(31,0,0,0,598)
490# define TLBIA() FX(31,0,0,0,370)
491# define TLBIE(b) FX(31,0,0,b,306)
492# define TLBSYNC() FX(31,0,0,0,566)
493# define TW(t,a,b) FX(31,t,a,b,4)
494# define TWEQ(a,b) FX(31,4,a,b,4)
495# define TWLGE(a,b) FX(31,5,a,b,4)
496# define TRAP() FX(31,31,0,0,4)
497# define TWI(t,a,s) FDs(3,t,a,s)
498# define TWGTI(a,s) TWI(8,a,s)
499# define TWLLEI(a,s) TWI(6,a,s)
500# define XOR(d,a,b) FX(31,a,d,b,316)
501# define XOR_(d,a,b) FX_(31,a,d,b,316)
502# define XORI(s,a,u) FDu(26,a,s,u)
503# define XORIS(s,a,u) FDu(27,a,s,u)
504# define nop(c) _nop(_jit,c)
505static void _nop(jit_state_t*,jit_int32_t);
506# define movr(r0,r1) _movr(_jit,r0,r1)
507static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
508# define movi(r0,i0) _movi(_jit,r0,i0)
509static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
e0659411
PC		 510# define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
511static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
512# define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
513static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
4a71579b
PC		 514# define movi_p(r0,i0) _movi_p(_jit,r0,i0)
515static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
ba3814c1
PC		 516# define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
517static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
518 jit_int32_t,jit_int32_t,jit_word_t);
519#define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
520#define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
4a71579b
PC		 521# define negr(r0,r1) NEG(r0,r1)
522# define comr(r0,r1) NOT(r0,r1)
523# define extr_c(r0,r1) EXTSB(r0,r1)
524# define extr_uc(r0,r1) ANDI_(r0,r1,0xff)
525# define extr_s(r0,r1) EXTSH(r0,r1)
526# define extr_us(r0,r1) ANDI_(r0,r1,0xffff)
527# if __WORDSIZE == 64
528# define extr_i(r0,r1) EXTSW(r0,r1)
529# define extr_ui(r0,r1) CLRLDI(r0,r1,32)
530# endif
ba3814c1
PC		 531# define bswapr_us_lh(r0,r1,no_flag) _bswapr_us(_jit,r0,r1,no_flag)
532# define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1,0)
533static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
534# define bswapr_ui_lw(r0,r1,no_flag) _bswapr_ui(_jit,r0,r1,no_flag)
535# define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1,0)
536static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
40a44dcb
PC		 537# if __WORDSIZE == 64
538# define bswapr_ul(r0,r1) generic_bswapr_ul(_jit,r0,r1)
4a71579b
PC		 539# endif
540# define addr(r0,r1,r2) ADD(r0,r1,r2)
541# define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
542static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
543# define addcr(r0,r1,r2) ADDC(r0,r1,r2)
544# define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
545static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
546# define addxr(r0,r1,r2) ADDE(r0,r1,r2)
547# define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
548static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
549# define subr(r0,r1,r2) SUB(r0,r1,r2)
550# define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
551static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
552# define subcr(r0,r1,r2) SUBC(r0,r1,r2)
553# define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
554static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
555# define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
556# define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
557static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
558# define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
559static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
560# if __WORDSIZE == 32
561# define mulr(r0,r1,r2) MULLW(r0,r1,r2)
562# define mullr(r0,r1,r2) MULLW(r0,r1,r2)
563# define mulhr(r0,r1,r2) MULHW(r0,r1,r2)
564# define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2)
565# else
566# define mulr(r0,r1,r2) MULLD(r0,r1,r2)
567# define mullr(r0,r1,r2) MULLD(r0,r1,r2)
568# define mulhr(r0,r1,r2) MULHD(r0,r1,r2)
569# define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2)
570# endif
571# define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
572static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
573# define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
574# define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
575# define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
576static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
577 jit_int32_t,jit_int32_t,jit_bool_t);
578# define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
579# define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
580# define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
581static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
582 jit_int32_t,jit_word_t,jit_bool_t);
583# if __WORDSIZE == 32
584# define divr(r0,r1,r2) DIVW(r0,r1,r2)
585# else
586# define divr(r0,r1,r2) DIVD(r0,r1,r2)
587# endif
588# define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
589static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
590# if __WORDSIZE == 32
591# define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
592# else
593# define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
594# endif
595# define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
596static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
597# define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
598# define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
599# define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
600static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
601 jit_int32_t,jit_int32_t,jit_bool_t);
602# define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
603# define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
604# define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
605static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
606 jit_int32_t,jit_word_t,jit_bool_t);
607# define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
608static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
609# define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
610static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
611# define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
612static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
613# define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
614static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
615# define andr(r0,r1,r2) AND(r0,r1,r2)
616# define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
617static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
618# define orr(r0,r1,r2) OR(r0,r1,r2)
619# define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
620static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
621# define xorr(r0,r1,r2) XOR(r0,r1,r2)
622# define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
623static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
624# if __WORDSIZE == 32
625# define lshr(r0,r1,r2) SLW(r0,r1,r2)
626# else
627# define lshr(r0,r1,r2) SLD(r0,r1,r2)
628# endif
629# define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
630static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
631# if __WORDSIZE == 32
632# define rshr(r0,r1,r2) SRAW(r0,r1,r2)
633# else
634# define rshr(r0,r1,r2) SRAD(r0,r1,r2)
635# endif
636# define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
637static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
638# if __WORDSIZE == 32
639# define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
640# else
641# define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
642# endif
643# define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
644static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
645# define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
646static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
647# define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
648static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
649# define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
650static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
651# define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
652static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
653# define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
654static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
655# define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
656static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
657# define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
658static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
659# define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
660static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
661# define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
662static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
663# define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
664static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
665# define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
666static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
667# define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
668static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
669# define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
670static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
671# define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
672static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
673# define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
674static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
675# define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
676static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
677# define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
678static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
679# define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
680static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
681# define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
682static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
683# define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
684static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
685#define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
686static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
687#define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
688static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
689#define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
690static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
691#define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
692static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
693#define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
694static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
695#define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
696static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
697#define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
698static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
699#define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
700static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
701#define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
702static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
703#define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
704static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
705#define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
706static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
707#define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
708static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
709#define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
710static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
711#define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
712static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
713#define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
714static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
715#define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
716static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
717#define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
718static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
719#define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
720static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
721#define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
722static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
723#define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
724static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
725#define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
726static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
727#define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
728static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
729#define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
730static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
731#define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
732static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
733#define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
734static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
735#define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
736static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
737#define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
738static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
739#define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
740static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
741#define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
742static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
743#define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
744static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
745#define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
746static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
747#define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
748static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
749#define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
750static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
751#define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
752static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
753#define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
754static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
755#define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
756static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
757#define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
758static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
759#define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
760static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
761#define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
762static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
763#define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
764static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
765# define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
766static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
767# define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
768static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
769# define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
770static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
771# define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
772static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
773# define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
774# define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
775static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
776# define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
777static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
778# define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
779static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
780# define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
781# define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
782static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
783# define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
784static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
785# define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
786static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
787# define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
788# define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
789static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
790# define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
791static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
792# define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
793static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
794# if __WORDSIZE == 32
795# define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
796# else
797# define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
798# endif
799# define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
800static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
801# define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
802static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
803# define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
804static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
805# if __WORDSIZE == 64
806# define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
807# define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
808static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
809# define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
810static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
811# define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
812static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
813# define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
814# define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
815static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
816# define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
817static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
818# define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
819static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
820# endif
821# define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
822# define sti_c(i0,r0) _sti_c(_jit,i0,r0)
823static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
824# define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
825static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
826# define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
827static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
828# define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
829# define sti_s(i0,r0) _sti_s(_jit,i0,r0)
830static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
831# define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
832static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
833# define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
834static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
835# define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
836# define sti_i(i0,r0) _sti_i(_jit,i0,r0)
837static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
838# define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
839static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
840# define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
841static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
842# if __WORDSIZE == 64
843# define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
844# define sti_l(i0,r0) _sti_l(_jit,i0,r0)
845static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
846# define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
847static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
848# define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
849static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
850# endif
851# define jmpr(r0) _jmpr(_jit,r0)
852static void _jmpr(jit_state_t*,jit_int32_t);
853# define jmpi(i0) _jmpi(_jit,i0)
854static jit_word_t _jmpi(jit_state_t*,jit_word_t);
855# define jmpi_p(i0) _jmpi_p(_jit,i0)
856static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
857# if _CALL_SYSV
858# define callr(r0,i0) _callr(_jit,r0,i0)
859static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
860# define calli(i0,i1) _calli(_jit,i0,i1)
861static void _calli(jit_state_t*,jit_word_t,jit_int32_t);
862# define calli_p(i0,i1) _calli_p(_jit,i0,i1)
863static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
864# else
865# define callr(r0) _callr(_jit,r0)
866static void _callr(jit_state_t*,jit_int32_t);
867# define calli(i0) _calli(_jit,i0)
868static void _calli(jit_state_t*,jit_word_t);
869# define calli_p(i0) _calli_p(_jit,i0)
870static jit_word_t _calli_p(jit_state_t*,jit_word_t);
871#endif
872# define prolog(node) _prolog(_jit, node)
873static void _prolog(jit_state_t*, jit_node_t*);
874# define epilog(node) _epilog(_jit, node)
875static void _epilog(jit_state_t*, jit_node_t*);
876# define vastart(r0) _vastart(_jit, r0)
877static void _vastart(jit_state_t*, jit_int32_t);
878# define vaarg(r0, r1) _vaarg(_jit, r0, r1)
879static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
880# define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
881static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
882# define patch_at(i,l) _patch_at(_jit,i,l)
883static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
884#endif
885
886#if CODE
887# define _u16(v) ((v) & 0xffff)
888# define _u26(v) ((v) & 0x3ffffff)
889static void
890_FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
891{
892 assert(!(o & ~((1 << 6) - 1)));
893 assert(!(d & ~((1 << 5) - 1)));
894 assert(!(a & ~((1 << 5) - 1)));
895 assert(!(b & ~((1 << 5) - 1)));
896 assert(!(e & ~((1 << 1) - 1)));
897 assert(!(x & ~((1 << 9) - 1)));
898 assert(!(r & ~((1 << 1) - 1)));
899 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
900}
901
902static void
903_FDs(jit_state_t *_jit, int o, int d, int a, int s)
904{
905 assert(!(o & ~((1 << 6) - 1)));
906 assert(!(d & ~((1 << 5) - 1)));
907 assert(!(a & ~((1 << 5) - 1)));
908 assert(can_sign_extend_short_p(s));
909 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
910}
911
912static void
913_FDu(jit_state_t *_jit, int o, int d, int a, int s)
914{
915 assert(!(o & ~((1 << 6) - 1)));
916 assert(!(d & ~((1 << 5) - 1)));
917 assert(!(a & ~((1 << 5) - 1)));
918 assert(can_zero_extend_short_p(s));
919 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
920}
921
922static void
923_FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
924{
925 assert(!(o & ~((1 << 6) - 1)));
926 assert(!(s & ~((1 << 5) - 1)));
927 assert(!(a & ~((1 << 5) - 1)));
928 assert(!(b & ~((1 << 5) - 1)));
929 assert(!(x & ~((1 << 10) - 1)));
930 assert(!(r & ~((1 << 1) - 1)));
931 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
932}
933
934static void
935_FI(jit_state_t *_jit, int o, int t, int a, int k)
936{
937 assert(!(o & ~(( 1 << 6) - 1)));
938 assert(!(t & 3) && can_sign_extend_jump_p(t));
939 assert(!(a & ~(( 1 << 1) - 1)));
940 assert(!(k & ~(( 1 << 1) - 1)));
941 ii((o<<26)|_u26(t)|(a<<1)|k);
942}
943
944static void
945_FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
946{
947 assert(!( o & ~((1 << 6) - 1)));
948 assert(!(bo & ~((1 << 5) - 1)));
949 assert(!(bi & ~((1 << 5) - 1)));
950 assert(!(t & 3) && can_sign_extend_short_p(t));
951 assert(!(a & ~(( 1 << 1) - 1)));
952 assert(!(k & ~(( 1 << 1) - 1)));
953 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
954}
955
956static void
957_FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
958{
959 assert(!( o & ~((1 << 6) - 1)));
960 assert(!(bo & ~((1 << 5) - 1)));
961 assert(!(bi & ~((1 << 5) - 1)));
962 assert(!(x & ~(( 1 << 10) - 1)));
963 assert(!(k & ~(( 1 << 1) - 1)));
964 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
965}
966
967static void
968_FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
969{
970 assert(!(o & ~((1 << 6) - 1)));
971 assert(!(d & ~((1 << 3) - 1)));
972 assert(!(l & ~((1 << 1) - 1)));
973 assert(!(a & ~((1 << 5) - 1)));
974 assert(!(b & ~((1 << 5) - 1)));
975 assert(!(x & ~((1 << 10) - 1)));
976 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
977}
978
979static void
980_FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
981{
982 assert(!(o & ~((1 << 6) - 1)));
983 assert(!(d & ~((1 << 3) - 1)));
984 assert(!(l & ~((1 << 1) - 1)));
985 assert(!(a & ~((1 << 5) - 1)));
986 if (o == 11) assert(can_sign_extend_short_p(s));
987 else if (o == 10) assert(can_zero_extend_short_p(s));
988#if DEBUG
989 else abort();
990#endif
991 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
992}
993
994static void
995_FXFX(jit_state_t *_jit, int o, int d, int x, int f)
996{
997 assert(!(o & ~((1 << 6) - 1)));
998 assert(!(d & ~((1 << 5) - 1)));
999 assert(!(x & ~((1 << 10) - 1)));
1000 assert(!(f & ~((1 << 10) - 1)));
1001 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1002}
1003
1004static void
1005_FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
1006{
1007 assert(!(o & ~((1 << 6) - 1)));
1008 assert(!(s & ~((1 << 5) - 1)));
1009 assert(!(a & ~((1 << 5) - 1)));
1010 assert(!(h & ~((1 << 5) - 1)));
1011 assert(!(b & ~((1 << 5) - 1)));
1012 assert(!(e & ~((1 << 5) - 1)));
1013 assert(!(r & ~((1 << 1) - 1)));
1014 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1015}
1016
1017# if __WORDSIZE == 64
1018static void
1019_FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1020{
1021 assert(!(o & ~((1 << 6) - 1)));
1022 assert(!(s & ~((1 << 5) - 1)));
1023 assert(!(a & ~((1 << 5) - 1)));
1024 assert(!(b & ~((1 << 5) - 1)));
1025 assert(!(e & ~((1 << 6) - 1)));
1026 assert(!(x & ~((1 << 4) - 1)));
1027 assert(!(r & ~((1 << 1) - 1)));
1028 e = (e >> 5) | ((e << 1) & 63);
1029 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1030}
1031
1032static void
1033_FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1034{
1035 assert(!(o & ~((1 << 6) - 1)));
1036 assert(!(s & ~((1 << 5) - 1)));
1037 assert(!(a & ~((1 << 5) - 1)));
1038 assert(!(h & ~((1 << 5) - 1)));
1039 assert(!(e & ~((1 << 6) - 1)));
1040 assert(!(x & ~((1 << 3) - 1)));
1041 assert(!(i & ~((1 << 1) - 1)));
1042 assert(!(r & ~((1 << 1) - 1)));
1043 e = (e >> 5) | ((e << 1) & 63);
1044 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1045}
1046
1047static void
1048_FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1049{
1050 assert(!(o & ~((1 << 6) - 1)));
1051 assert(!(s & ~((1 << 5) - 1)));
1052 assert(!(a & ~((1 << 5) - 1)));
1053 assert(!(h & ~((1 << 5) - 1)));
1054 assert(!(x & ~((1 << 9) - 1)));
1055 assert(!(i & ~((1 << 1) - 1)));
1056 assert(!(r & ~((1 << 1) - 1)));
1057 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1058}
1059#endif
1060
1061#if !DEBUG
1062/*
1063 * Use the sequence commented at
1064 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1065 */
1066static void
1067_MCRXR(jit_state_t *_jit, jit_int32_t cr)
1068{
1069 jit_int32_t reg;
1070 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1071 MFXER(rn(reg));
1072 MTCRF(128, rn(reg));
1073 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1074 MTXER(rn(reg));
1075 jit_unget_reg(reg);
1076}
1077#endif
1078
1079static void
1080_nop(jit_state_t *_jit, jit_int32_t i0)
1081{
1082 for (; i0 > 0; i0 -= 4)
1083 NOP();
1084 assert(i0 == 0);
1085}
1086
1087static void
1088_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1089{
1090 if (r0 != r1)
1091 MR(r0, r1);
1092}
1093
1094static void
1095_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1096{
1097 if (can_sign_extend_short_p(i0))
1098 LI(r0, i0);
1099 else {
1100 if (can_sign_extend_int_p(i0))
1101 LIS(r0, (jit_int16_t)(i0 >> 16));
1102 else if (can_zero_extend_int_p(i0)) {
1103 if (i0 & 0xffff0000) {
1104 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1105 SLWI(r0, r0, 16);
1106 }
1107 }
1108# if __WORDSIZE == 64
1109 else {
1110 movi(r0, (jit_uint32_t)(i0 >> 32));
1111 if (i0 & 0xffff0000) {
1112 SLDI(r0, r0, 16);
1113 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1114 SLDI(r0, r0, 16);
1115 }
1116 else
1117 SLDI(r0, r0, 32);
1118 }
1119# endif
1120 if (i0 & 0xffff)
1121 ORI(r0, r0, (jit_uint16_t)i0);
1122 }
1123}
1124
e0659411
PC		 1125static void
1126_movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1127{
1128 CMPWI(r2, 0);
1129 BEQ(8);
1130 MR(r0, r1);
1131}
1132
1133static void
1134_movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1135{
1136 CMPWI(r2, 0);
1137 BNE(8);
1138 MR(r0, r1);
1139}
1140
4a71579b
PC		 1141static jit_word_t
1142_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1143{
1144 jit_word_t word = _jit->pc.w;
1145# if __WORDSIZE == 32
1146 LIS(r0, (jit_int16_t)(i0 >> 16));
1147 ORI(r0, r0, (jit_uint16_t)i0);
1148# else
1149 LIS(r0, (jit_int16_t)(i0 >> 48));
1150 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1151 SLDI(r0, r0, 16);
1152 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1153 SLDI(r0, r0, 16);
1154 ORI(r0, r0, (jit_uint16_t)i0);
1155# endif
1156 return (word);
1157}
1158
4a71579b 1159static void
ba3814c1
PC		 1160_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1161 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
4a71579b 1162{
ba3814c1
PC		 1163 jit_int32_t r1_reg, iscasi;
1164 jit_word_t retry, done, jump0, jump1;
1165 if ((iscasi = (r1 == _NOREG))) {
1166 r1_reg = jit_get_reg(jit_class_gpr);
1167 r1 = rn(r1_reg);
1168 movi(r1, i0);
1169 }
1170 SYNC();
1171 /* retry: */
1172 retry = _jit->pc.w;
1173# if __WORDSIZE == 32
1174 LWARX(r0, _R0_REGNO, r1);
1175# else
1176 LDARX(r0, _R0_REGNO, r1);
1177# endif
1178 jump0 = bner(_jit->pc.w, r0, r2); /* bne done r0 r2 */
1179# if __WORDSIZE == 32
1180 STWCX_(r3, _R0_REGNO, r1);
1181# else
1182 STDCX_(r3, _R0_REGNO, r1);
1183# endif
1184 jump1 = bnei(_jit->pc.w, r0, 0); /* bne retry r0 0 */
1185 /* done: */
1186 done = _jit->pc.w;
1187 ISYNC();
1188 MFCR(r0);
1189 patch_at(jump0, done);
1190 patch_at(jump1, retry);
1191 if (iscasi)
1192 jit_unget_reg(r1_reg);
1193}
1194
1195static void
1196_bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1197{
1198 jit_int32_t reg, addr_reg;
1199
1200 /* Convert load followed by bswap to a single instruction */
1201 /* FIXME r0 and r1 do not need to be the same, only must check if
1202 * r1 was loaded in previous instruction */
1203 if (no_flag && r0 == r1) {
1204 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00022e | r0 << 21)) {
1205 /* Convert LHZX to LHBRX */
1206 _jit->pc.ui--;
1207 LHBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1208 return;
1209 }
1210
1211 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0xa0000000 | r0 << 21)) {
1212 /* Convert LHZ to LHBRX */
1213 _jit->pc.ui--;
1214 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1215
1216 reg = jit_get_reg(jit_class_gpr);
1217 LI(rn(reg), (short)*_jit->pc.ui);
1218 LHBRX(r0, rn(reg), addr_reg);
1219 jit_unget_reg(reg);
1220 return;
1221 }
1222 }
1223
40a44dcb
PC		 1224 if (r0 == r1) {
1225 RLWIMI(r0, r0, 16, 8, 15);
1226 RLWINM(r0, r0, 24, 16, 31);
1227 } else {
1228 RLWINM(r0, r1, 8, 16, 23);
1229 RLWIMI(r0, r1, 24, 24, 31);
1230 }
4a71579b
PC		 1231}
1232
1233static void
ba3814c1 1234_bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
4a71579b 1235{
ba3814c1
PC		 1236 jit_int32_t reg, addr_reg;
1237
1238 /* Convert load followed by bswap to a single instruction */
1239 /* FIXME r0 and r1 do not need to be the same, only must check if
1240 * r1 was loaded in previous instruction */
1241 if (no_flag && r0 == r1) {
1242 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00002e | r0 << 21)) {
1243 /* Convert LWZX to LWBRX */
1244 _jit->pc.ui--;
1245 LWBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1246 return;
1247 }
1248
1249 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0x80000000 | r0 << 21)) {
1250 /* Convert LWZ to LWBRX */
1251 _jit->pc.ui--;
1252 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1253
1254 reg = jit_get_reg(jit_class_gpr);
1255 LI(rn(reg), (short)*_jit->pc.ui);
1256 LWBRX(r0, rn(reg), addr_reg);
1257 jit_unget_reg(reg);
1258 return;
1259 }
1260 }
1261
4a71579b
PC		 1262 reg = jit_get_reg(jit_class_gpr);
1263 ROTLWI(rn(reg), r1, 8);
1264 RLWIMI(rn(reg), r1, 24, 0, 7);
1265 RLWIMI(rn(reg), r1, 24, 16, 23);
519a9ea1 1266# if __WORDSIZE == 64
4a71579b 1267 CLRLDI(r0, rn(reg), 32);
519a9ea1
PC		 1268# else
1269 MR(r0,rn(reg));
1270# endif
4a71579b
PC		 1271 jit_unget_reg(reg);
1272}
1273
4a71579b
PC		 1274static void
1275_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1276{
1277 jit_int32_t reg;
1278 if (can_sign_extend_short_p(i0))
1279 ADDI(r0, r1, i0);
1280 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1281 ADDIS(r0, r1, i0 >> 16);
1282 else {
1283 reg = jit_get_reg(jit_class_gpr);
1284 movi(rn(reg), i0);
1285 ADD(r0, r1, rn(reg));
1286 jit_unget_reg(reg);
1287 }
1288}
1289
1290static void
1291_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1292{
1293 jit_int32_t reg;
1294 if (can_sign_extend_short_p(i0))
1295 ADDIC(r0, r1, i0);
1296 else {
1297 reg = jit_get_reg(jit_class_gpr);
1298 movi(rn(reg), i0);
1299 ADDC(r0, r1, rn(reg));
1300 jit_unget_reg(reg);
1301 }
1302}
1303
1304static void
1305_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1306{
1307 jit_int32_t reg;
1308 reg = jit_get_reg(jit_class_gpr);
1309 movi(rn(reg), i0);
1310 ADDE(r0, r1, rn(reg));
1311 jit_unget_reg(reg);
1312}
1313
1314static void
1315_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1316{
1317 jit_int32_t reg;
1318 jit_word_t ni0 = -i0;
1319 if (can_sign_extend_short_p(ni0))
1320 ADDI(r0, r1, ni0);
1321 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1322 ADDIS(r0, r1, ni0 >> 16);
1323 else {
1324 reg = jit_get_reg(jit_class_gpr);
1325 movi(rn(reg), i0);
1326 SUB(r0, r1, rn(reg));
1327 jit_unget_reg(reg);
1328 }
1329}
1330
1331static void
1332_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1333{
1334 jit_int32_t reg;
1335 reg = jit_get_reg(jit_class_gpr);
1336 movi(rn(reg), i0);
1337 SUBC(r0, r1, rn(reg));
1338 jit_unget_reg(reg);
1339}
1340
1341static void
1342_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1343{
1344 jit_int32_t reg;
1345 reg = jit_get_reg(jit_class_gpr);
1346 movi(rn(reg), i0);
1347 SUBE(r0, r1, rn(reg));
1348 jit_unget_reg(reg);
1349}
1350
1351static void
1352_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1353{
1354 subi(r0, r1, i0);
1355 negr(r0, r0);
1356}
1357
1358static void
1359_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1360{
1361 jit_int32_t reg;
1362 if (can_sign_extend_short_p(i0))
1363 MULLI(r0, r1, i0);
1364 else {
1365 reg = jit_get_reg(jit_class_gpr);
1366 movi(rn(reg), i0);
1367 mulr(r0, r1, rn(reg));
1368 jit_unget_reg(reg);
1369 }
1370}
1371
1372static void
1373_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1374 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1375{
1376 jit_int32_t reg;
1377 if (r0 == r2 || r0 == r3) {
1378 reg = jit_get_reg(jit_class_gpr);
1379 mullr(rn(reg), r2, r3);
1380 }
1381 else
1382 mullr(r0, r2, r3);
1383 if (sign)
1384 mulhr(r1, r2, r3);
1385 else
1386 mulhr_u(r1, r2, r3);
1387 if (r0 == r2 || r0 == r3) {
1388 movr(r0, rn(reg));
1389 jit_unget_reg(reg);
1390 }
1391}
1392
1393static void
1394_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1395 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1396{
1397 jit_int32_t reg;
1398 reg = jit_get_reg(jit_class_gpr);
1399 movi(rn(reg), i0);
1400 iqmulr(r0, r1, r2, rn(reg), sign);
1401 jit_unget_reg(reg);
1402}
1403
1404static void
1405_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1406{
1407 jit_int32_t reg;
1408 reg = jit_get_reg(jit_class_gpr);
1409 movi(rn(reg), i0);
1410 divr(r0, r1, rn(reg));
1411 jit_unget_reg(reg);
1412}
1413
1414static void
1415_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1416{
1417 jit_int32_t reg;
1418 reg = jit_get_reg(jit_class_gpr);
1419 movi(rn(reg), i0);
1420 divr_u(r0, r1, rn(reg));
1421 jit_unget_reg(reg);
1422}
1423
1424static void
1425_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1426 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1427{
1428 jit_int32_t sv0, rg0;
1429 jit_int32_t sv1, rg1;
1430
1431 if (r0 == r2 || r0 == r3) {
1432 sv0 = jit_get_reg(jit_class_gpr);
1433 rg0 = rn(sv0);
1434 }
1435 else
1436 rg0 = r0;
1437 if (r1 == r2 || r1 == r3) {
1438 sv1 = jit_get_reg(jit_class_gpr);
1439 rg1 = rn(sv1);
1440 }
1441 else
1442 rg1 = r1;
1443
1444 if (sign)
1445 divr(rg0, r2, r3);
1446 else
1447 divr_u(rg0, r2, r3);
1448 mulr(rg1, r3, rg0);
1449 subr(rg1, r2, rg1);
1450 if (rg0 != r0) {
1451 movr(r0, rg0);
1452 jit_unget_reg(sv0);
1453 }
1454 if (rg1 != r1) {
1455 movr(r1, rg1);
1456 jit_unget_reg(sv1);
1457 }
1458}
1459
1460static void
1461_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1462 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1463{
1464 jit_int32_t reg;
1465 reg = jit_get_reg(jit_class_gpr);
1466 movi(rn(reg), i0);
1467 iqdivr(r0, r1, r2, rn(reg), sign);
1468 jit_unget_reg(reg);
1469}
1470
1471static void
1472_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1473{
1474 jit_int32_t reg;
1475 if (r0 == r1 || r0 == r2) {
1476 reg = jit_get_reg(jit_class_gpr);
1477 divr(rn(reg), r1, r2);
1478 mulr(rn(reg), r2, rn(reg));
1479 subr(r0, r1, rn(reg));
1480 jit_unget_reg(reg);
1481 }
1482 else {
1483 divr(r0, r1, r2);
1484 mulr(r0, r2, r0);
1485 subr(r0, r1, r0);
1486 }
1487}
1488
1489static void
1490_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1491{
1492 jit_int32_t reg;
1493 reg = jit_get_reg(jit_class_gpr);
1494 movi(rn(reg), i0);
1495 remr(r0, r1, rn(reg));
1496 jit_unget_reg(reg);
1497}
1498
1499static void
1500_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1501{
1502 jit_int32_t reg;
1503 if (r0 == r1 || r0 == r2) {
1504 reg = jit_get_reg(jit_class_gpr);
1505 divr_u(rn(reg), r1, r2);
1506 mulr(rn(reg), r2, rn(reg));
1507 subr(r0, r1, rn(reg));
1508 jit_unget_reg(reg);
1509 }
1510 else {
1511 divr_u(r0, r1, r2);
1512 mulr(r0, r2, r0);
1513 subr(r0, r1, r0);
1514 }
1515}
1516
1517static void
1518_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1519{
1520 jit_int32_t reg;
1521 reg = jit_get_reg(jit_class_gpr);
1522 movi(rn(reg), i0);
1523 remr_u(r0, r1, rn(reg));
1524 jit_unget_reg(reg);
1525}
1526
ba3814c1
PC		 1527# define is_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
1528
4a71579b
PC		 1529static void
1530_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1531{
ba3814c1 1532 jit_int32_t reg, offt;
4a71579b
PC		 1533 if (can_zero_extend_short_p(i0))
1534 ANDI_(r0, r1, i0);
1535 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1536 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
ba3814c1
PC		 1537 else if (__WORDSIZE == 32 && is_mask(i0)) {
1538 offt = __builtin_ctzl(i0);
1539 RLWINM(r0, r1, 0, 32 - offt - __builtin_popcountl(i0), 31 - offt);
1540 } else if (__WORDSIZE == 32 && is_mask(~i0)) {
1541 offt = __builtin_ctzl(~i0);
1542 RLWINM(r0, r1, 0, 32 - offt, 31 - offt - __builtin_popcountl(~i0));
1543 } else {
4a71579b
PC		 1544 reg = jit_get_reg(jit_class_gpr);
1545 movi(rn(reg), i0);
1546 AND(r0, r1, rn(reg));
1547 jit_unget_reg(reg);
1548 }
1549}
1550
1551static void
1552_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1553{
1554 jit_int32_t reg;
1555 if (can_zero_extend_short_p(i0))
1556 ORI(r0, r1, i0);
1557 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1558 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1559 else {
1560 reg = jit_get_reg(jit_class_gpr);
1561 movi(rn(reg), i0);
1562 OR(r0, r1, rn(reg));
1563 jit_unget_reg(reg);
1564 }
1565}
1566
1567static void
1568_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1569{
1570 jit_int32_t reg;
1571 if (can_zero_extend_short_p(i0))
1572 XORI(r0, r1, i0);
1573 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1574 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1575 else {
1576 reg = jit_get_reg(jit_class_gpr);
1577 movi(rn(reg), i0);
1578 XOR(r0, r1, rn(reg));
1579 jit_unget_reg(reg);
1580 }
1581}
1582
1583static void
1584_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1585{
1586 if (i0 == 0)
1587 movr(r0, r1);
1588 else {
1589# if __WORDSIZE == 32
1590 SLWI(r0, r1, i0);
1591# else
1592 SLDI(r0, r1, i0);
1593# endif
1594 }
1595}
1596
1597static void
1598_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1599{
1600 if (i0 == 0)
1601 movr(r0, r1);
1602 else {
1603# if __WORDSIZE == 32
1604 SRAWI(r0, r1, i0);
1605# else
1606 SRADI(r0, r1, i0);
1607# endif
1608 }
1609}
1610
1611static void
1612_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1613{
1614 if (i0 == 0)
1615 movr(r0, r1);
1616 else {
1617# if __WORDSIZE == 32
1618 SRWI(r0, r1, i0);
1619# else
1620 SRDI(r0, r1, i0);
1621# endif
1622 }
1623}
1624
1625static void
1626_ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1627{
1628 CMPW(r1, r2);
1629 MFCR(r0);
1630 EXTRWI(r0, r0, 1, CR_LT);
1631}
1632
1633static void
1634_lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1635{
1636 jit_int32_t reg;
1637 if (can_sign_extend_short_p(i0))
1638 CMPWI(r1, i0);
1639 else {
1640 reg = jit_get_reg(jit_class_gpr);
1641 movi(rn(reg), i0);
1642 CMPW(r1, rn(reg));
1643 jit_unget_reg(reg);
1644 }
1645 MFCR(r0);
1646 EXTRWI(r0, r0, 1, CR_LT);
1647}
1648
1649static void
1650_ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1651{
1652 CMPLW(r1, r2);
1653 MFCR(r0);
1654 EXTRWI(r0, r0, 1, CR_LT);
1655}
1656
1657static void
1658_lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1659{
1660 jit_int32_t reg;
1661 if (can_zero_extend_short_p(i0))
1662 CMPLWI(r1, i0);
1663 else {
1664 reg = jit_get_reg(jit_class_gpr);
1665 movi(rn(reg), i0);
1666 CMPLW(r1, rn(reg));
1667 jit_unget_reg(reg);
1668 }
1669 MFCR(r0);
1670 EXTRWI(r0, r0, 1, CR_LT);
1671}
1672
1673static void
1674_ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1675{
1676 CMPW(r1, r2);
1677 CRNOT(CR_GT, CR_GT);
1678 MFCR(r0);
1679 EXTRWI(r0, r0, 1, CR_GT);
1680}
1681
1682static void
1683_lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1684{
1685 jit_int32_t reg;
1686 if (can_sign_extend_short_p(i0))
1687 CMPWI(r1, i0);
1688 else {
1689 reg = jit_get_reg(jit_class_gpr);
1690 movi(rn(reg), i0);
1691 CMPW(r1, rn(reg));
1692 jit_unget_reg(reg);
1693 }
1694 CRNOT(CR_GT, CR_GT);
1695 MFCR(r0);
1696 EXTRWI(r0, r0, 1, CR_GT);
1697}
1698
1699static void
1700_ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1701{
1702 CMPLW(r1, r2);
1703 CRNOT(CR_GT, CR_GT);
1704 MFCR(r0);
1705 EXTRWI(r0, r0, 1, CR_GT);
1706}
1707
1708static void
1709_lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1710{
1711 jit_int32_t reg;
1712 if (can_zero_extend_short_p(i0))
1713 CMPLWI(r1, i0);
1714 else {
1715 reg = jit_get_reg(jit_class_gpr);
1716 movi(rn(reg), i0);
1717 CMPLW(r1, rn(reg));
1718 jit_unget_reg(reg);
1719 }
1720 CRNOT(CR_GT, CR_GT);
1721 MFCR(r0);
1722 EXTRWI(r0, r0, 1, CR_GT);
1723}
1724
1725static void
1726_eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1727{
1728 CMPW(r1, r2);
1729 MFCR(r0);
1730 EXTRWI(r0, r0, 1, CR_EQ);
1731}
1732
1733static void
1734_eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1735{
1736 jit_int32_t reg;
1737 if (can_sign_extend_short_p(i0))
1738 CMPWI(r1, i0);
1739 else if (can_zero_extend_short_p(i0))
1740 CMPLWI(r1, i0);
1741 else {
1742 reg = jit_get_reg(jit_class_gpr);
1743 movi(rn(reg), i0);
1744 CMPW(r1, rn(reg));
1745 jit_unget_reg(reg);
1746 }
1747 MFCR(r0);
1748 EXTRWI(r0, r0, 1, CR_EQ);
1749}
1750
1751static void
1752_ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1753{
1754 CMPW(r1, r2);
1755 CRNOT(CR_LT, CR_LT);
1756 MFCR(r0);
1757 EXTRWI(r0, r0, 1, CR_LT);
1758}
1759
1760static void
1761_gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1762{
1763 jit_int32_t reg;
1764 if (can_sign_extend_short_p(i0))
1765 CMPWI(r1, i0);
1766 else {
1767 reg = jit_get_reg(jit_class_gpr);
1768 movi(rn(reg), i0);
1769 CMPW(r1, rn(reg));
1770 jit_unget_reg(reg);
1771 }
1772 CRNOT(CR_LT, CR_LT);
1773 MFCR(r0);
1774 EXTRWI(r0, r0, 1, CR_LT);
1775}
1776
1777static void
1778_ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1779{
1780 CMPLW(r1, r2);
1781 CRNOT(CR_LT, CR_LT);
1782 MFCR(r0);
1783 EXTRWI(r0, r0, 1, CR_LT);
1784}
1785
1786static void
1787_gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1788{
1789 jit_int32_t reg;
1790 if (can_zero_extend_short_p(i0))
1791 CMPLWI(r1, i0);
1792 else {
1793 reg = jit_get_reg(jit_class_gpr);
1794 movi(rn(reg), i0);
1795 CMPLW(r1, rn(reg));
1796 jit_unget_reg(reg);
1797 }
1798 CRNOT(CR_LT, CR_LT);
1799 MFCR(r0);
1800 EXTRWI(r0, r0, 1, CR_LT);
1801}
1802
1803static void
1804_gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1805{
1806 CMPW(r1, r2);
1807 MFCR(r0);
1808 EXTRWI(r0, r0, 1, CR_GT);
1809}
1810
1811static void
1812_gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1813{
1814 jit_int32_t reg;
1815 if (can_sign_extend_short_p(i0))
1816 CMPWI(r1, i0);
1817 else {
1818 reg = jit_get_reg(jit_class_gpr);
1819 movi(rn(reg), i0);
1820 CMPW(r1, rn(reg));
1821 jit_unget_reg(reg);
1822 }
1823 MFCR(r0);
1824 EXTRWI(r0, r0, 1, CR_GT);
1825}
1826
1827static void
1828_gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1829{
1830 CMPLW(r1, r2);
1831 MFCR(r0);
1832 EXTRWI(r0, r0, 1, CR_GT);
1833}
1834
1835static void
1836_gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1837{
1838 jit_int32_t reg;
1839 if (can_zero_extend_short_p(i0))
1840 CMPLWI(r1, i0);
1841 else {
1842 reg = jit_get_reg(jit_class_gpr);
1843 movi(rn(reg), i0);
1844 CMPLW(r1, rn(reg));
1845 jit_unget_reg(reg);
1846 }
1847 MFCR(r0);
1848 EXTRWI(r0, r0, 1, CR_GT);
1849}
1850
1851static void
1852_ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1853{
1854 CMPW(r1, r2);
1855 CRNOT(CR_EQ, CR_EQ);
1856 MFCR(r0);
1857 EXTRWI(r0, r0, 1, CR_EQ);
1858}
1859
1860static void
1861_nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1862{
1863 jit_int32_t reg;
1864 if (can_sign_extend_short_p(i0))
1865 CMPWI(r1, i0);
1866 else if (can_zero_extend_short_p(i0))
1867 CMPLWI(r1, i0);
1868 else {
1869 reg = jit_get_reg(jit_class_gpr);
1870 movi(rn(reg), i0);
1871 CMPW(r1, rn(reg));
1872 jit_unget_reg(reg);
1873 }
1874 CRNOT(CR_EQ, CR_EQ);
1875 MFCR(r0);
1876 EXTRWI(r0, r0, 1, CR_EQ);
1877}
1878
1879static jit_word_t
1880_bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1881{
1882 jit_word_t d, w;
1883 CMPW(r0, r1);
1884 w = _jit->pc.w;
1885 d = (i0 - w) & ~3;
1886 BLT(d);
1887 return (w);
1888}
1889
1890static jit_word_t
1891_blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1892{
1893 jit_int32_t reg;
1894 jit_word_t d, w;
1895 if (can_sign_extend_short_p(i1))
1896 CMPWI(r0, i1);
1897 else {
1898 reg = jit_get_reg(jit_class_gpr);
1899 movi(rn(reg), i1);
1900 CMPW(r0, rn(reg));
1901 jit_unget_reg(reg);
1902 }
1903 w = _jit->pc.w;
1904 d = (i0 - w) & ~3;
1905 BLT(d);
1906 return (w);
1907}
1908
1909static jit_word_t
1910_bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1911{
1912 jit_word_t d, w;
1913 CMPLW(r0, r1);
1914 w = _jit->pc.w;
1915 d = (i0 - w) & ~3;
1916 BLT(d);
1917 return (w);
1918}
1919
1920static jit_word_t
1921_blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1922{
1923 jit_int32_t reg;
1924 jit_word_t d, w;
1925 if (can_zero_extend_short_p(i1))
1926 CMPLWI(r0, i1);
1927 else {
1928 reg = jit_get_reg(jit_class_gpr);
1929 movi(rn(reg), i1);
1930 CMPLW(r0, rn(reg));
1931 jit_unget_reg(reg);
1932 }
1933 w = _jit->pc.w;
1934 d = (i0 - w) & ~3;
1935 BLT(d);
1936 return (w);
1937}
1938
1939static jit_word_t
1940_bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1941{
1942 jit_word_t d, w;
1943 CMPW(r0, r1);
1944 w = _jit->pc.w;
1945 d = (i0 - w) & ~3;
1946 BLE(d);
1947 return (w);
1948}
1949
1950static jit_word_t
1951_blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1952{
1953 jit_int32_t reg;
1954 jit_word_t d, w;
1955 if (can_sign_extend_short_p(i1))
1956 CMPWI(r0, i1);
1957 else {
1958 reg = jit_get_reg(jit_class_gpr);
1959 movi(rn(reg), i1);
1960 CMPW(r0, rn(reg));
1961 jit_unget_reg(reg);
1962 }
1963 w = _jit->pc.w;
1964 d = (i0 - w) & ~3;
1965 BLE(d);
1966 return (w);
1967}
1968
1969static jit_word_t
1970_bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1971{
1972 jit_word_t d, w;
1973 CMPLW(r0, r1);
1974 w = _jit->pc.w;
1975 d = (i0 - w) & ~3;
1976 BLE(d);
1977 return (w);
1978}
1979
1980static jit_word_t
1981_blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1982{
1983 jit_int32_t reg;
1984 jit_word_t d, w;
1985 if (can_zero_extend_short_p(i1))
1986 CMPLWI(r0, i1);
1987 else {
1988 reg = jit_get_reg(jit_class_gpr);
1989 movi(rn(reg), i1);
1990 CMPLW(r0, rn(reg));
1991 jit_unget_reg(reg);
1992 }
1993 w = _jit->pc.w;
1994 d = (i0 - w) & ~3;
1995 BLE(d);
1996 return (w);
1997}
1998
1999static jit_word_t
2000_beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2001{
2002 jit_word_t d, w;
2003 CMPW(r0, r1);
2004 w = _jit->pc.w;
2005 d = (i0 - w) & ~3;
2006 BEQ(d);
2007 return (w);
2008}
2009
2010static jit_word_t
2011_beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2012{
2013 jit_int32_t reg;
2014 jit_word_t d, w;
2015 if (can_sign_extend_short_p(i1))
2016 CMPWI(r0, i1);
2017 else if (can_zero_extend_short_p(i1))
2018 CMPLWI(r0, i1);
2019 else {
2020 reg = jit_get_reg(jit_class_gpr);
2021 movi(rn(reg), i1);
2022 CMPW(r0, rn(reg));
2023 jit_unget_reg(reg);
2024 }
2025 w = _jit->pc.w;
2026 d = (i0 - w) & ~3;
2027 BEQ(d);
2028 return (w);
2029}
2030
2031static jit_word_t
2032_bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2033{
2034 jit_word_t d, w;
2035 CMPW(r0, r1);
2036 w = _jit->pc.w;
2037 d = (i0 - w) & ~3;
2038 BGE(d);
2039 return (w);
2040}
2041
2042static jit_word_t
2043_bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2044{
2045 jit_int32_t reg;
2046 jit_word_t d, w;
2047 if (can_sign_extend_short_p(i1))
2048 CMPWI(r0, i1);
2049 else {
2050 reg = jit_get_reg(jit_class_gpr);
2051 movi(rn(reg), i1);
2052 CMPW(r0, rn(reg));
2053 jit_unget_reg(reg);
2054 }
2055 w = _jit->pc.w;
2056 d = (i0 - w) & ~3;
2057 BGE(d);
2058 return (w);
2059}
2060
2061static jit_word_t
2062_bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2063{
2064 jit_word_t d, w;
2065 CMPLW(r0, r1);
2066 w = _jit->pc.w;
2067 d = (i0 - w) & ~3;
2068 BGE(d);
2069 return (w);
2070}
2071
2072static jit_word_t
2073_bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2074{
2075 jit_int32_t reg;
2076 jit_word_t d, w;
2077 if (can_zero_extend_short_p(i1))
2078 CMPLWI(r0, i1);
2079 else {
2080 reg = jit_get_reg(jit_class_gpr);
2081 movi(rn(reg), i1);
2082 CMPLW(r0, rn(reg));
2083 jit_unget_reg(reg);
2084 }
2085 w = _jit->pc.w;
2086 d = (i0 - w) & ~3;
2087 BGE(d);
2088 return (w);
2089}
2090
2091static jit_word_t
2092_bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2093{
2094 jit_word_t d, w;
2095 CMPW(r0, r1);
2096 w = _jit->pc.w;
2097 d = (i0 - w) & ~3;
2098 BGT(d);
2099 return (w);
2100}
2101
2102static jit_word_t
2103_bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2104{
2105 jit_int32_t reg;
2106 jit_word_t d, w;
2107 if (can_sign_extend_short_p(i1))
2108 CMPWI(r0, i1);
2109 else {
2110 reg = jit_get_reg(jit_class_gpr);
2111 movi(rn(reg), i1);
2112 CMPW(r0, rn(reg));
2113 jit_unget_reg(reg);
2114 }
2115 w = _jit->pc.w;
2116 d = (i0 - w) & ~3;
2117 BGT(d);
2118 return (w);
2119}
2120
2121static jit_word_t
2122_bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2123{
2124 jit_word_t d, w;
2125 CMPLW(r0, r1);
2126 w = _jit->pc.w;
2127 d = (i0 - w) & ~3;
2128 BGT(d);
2129 return (w);
2130}
2131
2132static jit_word_t
2133_bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2134{
2135 jit_int32_t reg;
2136 jit_word_t d, w;
2137 if (can_zero_extend_short_p(i1))
2138 CMPLWI(r0, i1);
2139 else {
2140 reg = jit_get_reg(jit_class_gpr);
2141 movi(rn(reg), i1);
2142 CMPLW(r0, rn(reg));
2143 jit_unget_reg(reg);
2144 }
2145 w = _jit->pc.w;
2146 d = (i0 - w) & ~3;
2147 BGT(d);
2148 return (w);
2149}
2150
2151static jit_word_t
2152_bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2153{
2154 jit_word_t d, w;
2155 CMPW(r0, r1);
2156 w = _jit->pc.w;
2157 d = (i0 - w) & ~3;
2158 BNE(d);
2159 return (w);
2160}
2161
2162static jit_word_t
2163_bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2164{
2165 jit_int32_t reg;
2166 jit_word_t d, w;
2167 if (can_sign_extend_short_p(i1))
2168 CMPWI(r0, i1);
2169 else if (can_zero_extend_short_p(i1))
2170 CMPLWI(r0, i1);
2171 else {
2172 reg = jit_get_reg(jit_class_gpr);
2173 movi(rn(reg), i1);
2174 CMPW(r0, rn(reg));
2175 jit_unget_reg(reg);
2176 }
2177 w = _jit->pc.w;
2178 d = (i0 - w) & ~3;
2179 BNE(d);
2180 return (w);
2181}
2182
2183static jit_word_t
2184_bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2185{
2186 jit_word_t w;
2187 jit_int32_t reg;
2188 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2189 andr(rn(reg), r0, r1);
2190 w = bnei(i0, rn(reg), 0);
2191 jit_unget_reg(reg);
2192 return (w);
2193}
2194
2195static jit_word_t
2196_bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2197{
2198 jit_word_t w;
2199 jit_int32_t reg;
2200 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2201 andi(rn(reg), r0, i1);
2202 w = bnei(i0, rn(reg), 0);
2203 jit_unget_reg(reg);
2204 return (w);
2205}
2206
2207static jit_word_t
2208_bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2209{
2210 jit_word_t w;
2211 jit_int32_t reg;
2212 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2213 andr(rn(reg), r0, r1);
2214 w = beqi(i0, rn(reg), 0);
2215 jit_unget_reg(reg);
2216 return (w);
2217}
2218
2219static jit_word_t
2220_bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2221{
2222 jit_word_t w;
2223 jit_int32_t reg;
2224 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2225 andi(rn(reg), r0, i1);
2226 w = beqi(i0, rn(reg), 0);
2227 jit_unget_reg(reg);
2228 return (w);
2229}
2230
2231static jit_word_t
2232_boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2233{
2234 jit_word_t d, w;
2235 ADDO(r0, r0, r1);
2236 MCRXR(CR_0);
2237 w = _jit->pc.w;
2238 d = (i0 - w) & ~3;
2239 BGT(d); /* GT = bit 1 of XER = OV */
2240 return (w);
2241}
2242
2243static jit_word_t
2244_boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2245{
2246 jit_word_t w;
2247 jit_int32_t reg;
2248 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2249 movi(rn(reg), i1);
2250 w = boaddr(i0, r0, rn(reg));
2251 jit_unget_reg(reg);
2252 return (w);
2253}
2254
2255static jit_word_t
2256_bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2257{
2258 jit_word_t d, w;
2259 ADDO(r0, r0, r1);
2260 MCRXR(CR_0);
2261 w = _jit->pc.w;
2262 d = (i0 - w) & ~3;
2263 BLE(d);
2264 return (w);
2265}
2266
2267static jit_word_t
2268_bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2269{
2270 jit_word_t w;
2271 jit_int32_t reg;
2272 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2273 movi(rn(reg), i1);
2274 w = bxaddr(i0, r0, rn(reg));
2275 jit_unget_reg(reg);
2276 return (w);
2277}
2278
2279static jit_word_t
2280_bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2281{
2282 jit_word_t d, w;
2283 SUBO(r0, r0, r1);
2284 MCRXR(CR_0);
2285 w = _jit->pc.w;
2286 d = (i0 - w) & ~3;
2287 BGT(d);
2288 return (w);
2289}
2290
2291static jit_word_t
2292_bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2293{
2294 jit_word_t w;
2295 jit_int32_t reg;
2296 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2297 movi(rn(reg), i1);
2298 w = bosubr(i0, r0, rn(reg));
2299 jit_unget_reg(reg);
2300 return (w);
2301}
2302
2303static jit_word_t
2304_bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2305{
2306 jit_word_t d, w;
2307 SUBO(r0, r0, r1);
2308 MCRXR(CR_0);
2309 w = _jit->pc.w;
2310 d = (i0 - w) & ~3;
2311 BLE(d);
2312 return (w);
2313}
2314
2315static jit_word_t
2316_bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2317{
2318 jit_word_t w;
2319 jit_int32_t reg;
2320 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2321 movi(rn(reg), i1);
2322 w = bxsubr(i0, r0, rn(reg));
2323 jit_unget_reg(reg);
2324 return (w);
2325}
2326
2327static jit_word_t
2328_boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2329{
2330 jit_word_t d, w;
2331 ADDC(r0, r0, r1);
2332 MCRXR(CR_0);
2333 w = _jit->pc.w;
2334 d = (i0 - w) & ~3;
2335 BEQ(d); /* EQ = bit 2 of XER = CA */
2336 return (w);
2337}
2338
2339static jit_word_t
2340_boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2341{
2342 jit_int32_t reg;
2343 jit_word_t d, w;
2344 if (can_sign_extend_short_p(i1)) {
2345 ADDIC(r0, r0, i1);
2346 MCRXR(CR_0);
2347 w = _jit->pc.w;
2348 d = (i0 - w) & ~3;
2349 BEQ(d);
2350 return (w);
2351 }
2352 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2353 movi(rn(reg), i1);
2354 w = boaddr_u(i0, r0, rn(reg));
2355 jit_unget_reg(reg);
2356 return (w);
2357}
2358
2359static jit_word_t
2360_bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2361{
2362 jit_word_t d, w;
2363 ADDC(r0, r0, r1);
2364 MCRXR(CR_0);
2365 w = _jit->pc.w;
2366 d = (i0 - w) & ~3;
2367 BNE(d);
2368 return (w);
2369}
2370
2371static jit_word_t
2372_bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2373{
2374 jit_int32_t reg;
2375 jit_word_t d, w;
2376 if (can_sign_extend_short_p(i1)) {
2377 ADDIC(r0, r0, i1);
2378 MCRXR(CR_0);
2379 w = _jit->pc.w;
2380 d = (i0 - w) & ~3;
2381 BNE(d);
2382 return (w);
2383 }
2384 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2385 movi(rn(reg), i1);
2386 w = bxaddr_u(i0, r0, rn(reg));
2387 jit_unget_reg(reg);
2388 return (w);
2389}
2390
2391static jit_word_t
2392_bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2393{
2394 jit_word_t d, w;
2395 SUBC(r0, r0, r1);
2396 MCRXR(CR_0);
2397 w = _jit->pc.w;
2398 d = (i0 - w) & ~3;
2399 BNE(d); /* PPC uses "carry" not "borrow" */
2400 return (w);
2401}
2402
2403static jit_word_t
2404_bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2405{
2406 jit_word_t w;
2407 jit_int32_t reg;
2408 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2409 movi(rn(reg), i1);
2410 w = bosubr_u(i0, r0, rn(reg));
2411 jit_unget_reg(reg);
2412 return (w);
2413}
2414
2415static jit_word_t
2416_bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2417{
2418 jit_word_t d, w;
2419 SUBC(r0, r0, r1);
2420 MCRXR(CR_0);
2421 w = _jit->pc.w;
2422 d = (i0 - w) & ~3;
2423 BEQ(d);
2424 return (w);
2425}
2426
2427static jit_word_t
2428_bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2429{
2430 jit_word_t w;
2431 jit_int32_t reg;
2432 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2433 movi(rn(reg), i1);
2434 w = bxsubr_u(i0, r0, rn(reg));
2435 jit_unget_reg(reg);
2436 return (w);
2437}
2438
2439static void
2440_ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2441{
2442 ldr_uc(r0, r1);
2443 extr_c(r0, r0);
2444}
2445
2446static void
2447_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2448{
2449 ldi_uc(r0, i0);
2450 extr_c(r0, r0);
2451}
2452
2453static void
2454_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2455{
2456 ldxr_uc(r0, r1, r2);
2457 extr_c(r0, r0);
2458}
2459
2460static void
2461_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2462{
2463 ldxi_uc(r0, r1, i0);
2464 extr_c(r0, r0);
2465}
2466
2467static void
2468_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2469{
2470 jit_bool_t inv;
2471 jit_int32_t reg;
2472 jit_word_t lo, hi;
2473 if (can_sign_extend_short_p(i0))
2474 LBZ(r0, _R0_REGNO, i0);
2475 else if (can_sign_extend_int_p(i0)) {
2476 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2477 lo = (jit_int16_t)(i0 - (hi << 16));
2478 reg = jit_get_reg(jit_class_gpr);
2479 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2480 LIS(rn(reg), hi);
2481 LBZ(r0, rn(reg), lo);
2482 jit_unget_reg(reg);
2483 if (inv) jit_unget_reg(_R0);
2484 }
2485 else {
2486 reg = jit_get_reg(jit_class_gpr);
2487 movi(rn(reg), i0);
2488 ldr_uc(r0, rn(reg));
2489 jit_unget_reg(reg);
2490 }
2491}
2492
2493static void
2494_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2495{
2496 jit_int32_t reg;
2497 if (r1 == _R0_REGNO) {
2498 if (r2 != _R0_REGNO)
2499 LBZX(r0, r2, r1);
2500 else {
2501 reg = jit_get_reg(jit_class_gpr);
2502 movr(rn(reg), r1);
2503 LBZX(r0, rn(reg), r2);
2504 jit_unget_reg(reg);
2505 }
2506 }
2507 else
2508 LBZX(r0, r1, r2);
2509}
2510
2511static void
2512_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2513{
2514 jit_int32_t reg;
2515 if (i0 == 0)
2516 ldr_uc(r0, r1);
2517 else if (can_sign_extend_short_p(i0)) {
2518 if (r1 == _R0_REGNO) {
2519 reg = jit_get_reg(jit_class_gpr);
2520 movr(rn(reg), r1);
2521 LBZ(r0, rn(reg), i0);
2522 jit_unget_reg(reg);
2523 }
2524 else
2525 LBZ(r0, r1, i0);
2526 }
2527 else {
2528 reg = jit_get_reg(jit_class_gpr);
2529 movi(rn(reg), i0);
2530 ldxr_uc(r0, r1, rn(reg));
2531 jit_unget_reg(reg);
2532 }
2533}
2534
2535static void
2536_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2537{
2538 jit_bool_t inv;
2539 jit_int32_t reg;
2540 jit_word_t lo, hi;
2541 if (can_sign_extend_short_p(i0))
2542 LHA(r0, _R0_REGNO, i0);
2543 else if (can_sign_extend_int_p(i0)) {
2544 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2545 lo = (jit_int16_t)(i0 - (hi << 16));
2546 reg = jit_get_reg(jit_class_gpr);
2547 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2548 LIS(rn(reg), hi);
2549 LHA(r0, rn(reg), lo);
2550 jit_unget_reg(reg);
2551 if (inv) jit_unget_reg(_R0);
2552 }
2553 else {
2554 reg = jit_get_reg(jit_class_gpr);
2555 movi(rn(reg), i0);
2556 ldr_s(r0, rn(reg));
2557 jit_unget_reg(reg);
2558 }
2559}
2560
2561static void
2562_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2563{
2564 jit_int32_t reg;
2565 if (r1 == _R0_REGNO) {
2566 if (r2 != _R0_REGNO)
2567 LHAX(r0, r2, r1);
2568 else {
2569 reg = jit_get_reg(jit_class_gpr);
2570 movr(rn(reg), r1);
2571 LHAX(r0, rn(reg), r2);
2572 jit_unget_reg(reg);
2573 }
2574 }
2575 else
2576 LHAX(r0, r1, r2);
2577}
2578
2579static void
2580_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2581{
2582 jit_int32_t reg;
2583 if (i0 == 0)
2584 ldr_s(r0, r1);
2585 else if (can_sign_extend_short_p(i0)) {
2586 if (r1 == _R0_REGNO) {
2587 reg = jit_get_reg(jit_class_gpr);
2588 movr(rn(reg), r1);
2589 LHA(r0, rn(reg), i0);
2590 jit_unget_reg(reg);
2591 }
2592 else
2593 LHA(r0, r1, i0);
2594 }
2595 else {
2596 reg = jit_get_reg(jit_class_gpr);
2597 movi(rn(reg), i0);
2598 ldxr_s(r0, r1, rn(reg));
2599 jit_unget_reg(reg);
2600 }
2601}
2602
2603static void
2604_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2605{
2606 jit_bool_t inv;
2607 jit_int32_t reg;
2608 jit_word_t lo, hi;
2609 if (can_sign_extend_short_p(i0))
2610 LHZ(r0, _R0_REGNO, i0);
2611 else if (can_sign_extend_int_p(i0)) {
2612 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2613 lo = (jit_int16_t)(i0 - (hi << 16));
2614 reg = jit_get_reg(jit_class_gpr);
2615 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2616 LIS(rn(reg), hi);
2617 LHZ(r0, rn(reg), lo);
2618 jit_unget_reg(reg);
2619 if (inv) jit_unget_reg(_R0);
2620 }
2621 else {
2622 reg = jit_get_reg(jit_class_gpr);
2623 movi(rn(reg), i0);
2624 ldr_us(r0, rn(reg));
2625 jit_unget_reg(reg);
2626 }
2627}
2628
2629static void
2630_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2631{
2632 jit_int32_t reg;
2633 if (r1 == _R0_REGNO) {
2634 if (r2 != _R0_REGNO)
2635 LHZX(r0, r2, r1);
2636 else {
2637 reg = jit_get_reg(jit_class_gpr);
2638 movr(rn(reg), r1);
2639 LHZX(r0, rn(reg), r2);
2640 jit_unget_reg(reg);
2641 }
2642 }
2643 else
2644 LHZX(r0, r1, r2);
2645}
2646
2647static void
2648_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2649{
2650 jit_int32_t reg;
2651 if (i0 == 0)
2652 ldr_us(r0, r1);
2653 else if (can_sign_extend_short_p(i0)) {
2654 if (r1 == _R0_REGNO) {
2655 reg = jit_get_reg(jit_class_gpr);
2656 movr(rn(reg), r1);
2657 LHZ(r0, rn(reg), i0);
2658 jit_unget_reg(reg);
2659 }
2660 else
2661 LHZ(r0, r1, i0);
2662 }
2663 else {
2664 reg = jit_get_reg(jit_class_gpr);
2665 movi(rn(reg), i0);
2666 ldxr_us(r0, r1, rn(reg));
2667 jit_unget_reg(reg);
2668 }
2669}
2670
2671# if __WORDSIZE == 32
2672static void
2673_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2674{
2675 jit_bool_t inv;
2676 jit_int32_t reg;
2677 jit_word_t lo, hi;
2678 if (can_sign_extend_short_p(i0))
2679 LWZ(r0, _R0_REGNO, i0);
2680 else if (can_sign_extend_int_p(i0)) {
2681 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2682 lo = (jit_int16_t)(i0 - (hi << 16));
2683 reg = jit_get_reg(jit_class_gpr);
2684 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2685 LIS(rn(reg), hi);
2686 LWZ(r0, rn(reg), lo);
2687 jit_unget_reg(reg);
2688 if (inv) jit_unget_reg(_R0);
2689 }
2690 else {
2691 reg = jit_get_reg(jit_class_gpr);
2692 movi(rn(reg), i0);
2693 ldr_i(r0, rn(reg));
2694 jit_unget_reg(reg);
2695 }
2696}
2697
2698static void
2699_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2700{
2701 jit_int32_t reg;
2702 if (r1 == _R0_REGNO) {
2703 if (r2 != _R0_REGNO)
2704 LWZX(r0, r2, r1);
2705 else {
2706 reg = jit_get_reg(jit_class_gpr);
2707 movr(rn(reg), r1);
2708 LWZX(r0, rn(reg), r2);
2709 jit_unget_reg(reg);
2710 }
2711 }
2712 else
2713 LWZX(r0, r1, r2);
2714}
2715
2716static void
2717_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2718{
2719 jit_int32_t reg;
2720 if (i0 == 0)
2721 ldr_i(r0, r1);
2722 else if (can_sign_extend_short_p(i0)) {
2723 if (r1 == _R0_REGNO) {
2724 reg = jit_get_reg(jit_class_gpr);
2725 movr(rn(reg), r1);
2726 LWZ(r0, rn(reg), i0);
2727 jit_unget_reg(reg);
2728 }
2729 else
2730 LWZ(r0, r1, i0);
2731 }
2732 else {
2733 reg = jit_get_reg(jit_class_gpr);
2734 movi(rn(reg), i0);
2735 ldxr_i(r0, r1, rn(reg));
2736 jit_unget_reg(reg);
2737 }
2738}
2739
2740# else
2741static void
2742_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2743{
2744 jit_bool_t inv;
2745 jit_int32_t reg;
2746 jit_word_t lo, hi;
2747 if (can_sign_extend_short_p(i0))
2748 LWA(r0, _R0_REGNO, i0);
2749 else if (can_sign_extend_int_p(i0)) {
2750 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2751 lo = (jit_int16_t)(i0 - (hi << 16));
2752 reg = jit_get_reg(jit_class_gpr);
2753 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2754 LIS(rn(reg), hi);
2755 LWA(r0, rn(reg), lo);
2756 jit_unget_reg(reg);
2757 if (inv) jit_unget_reg(_R0);
2758 }
2759 else {
2760 reg = jit_get_reg(jit_class_gpr);
2761 movi(rn(reg), i0);
2762 ldr_i(r0, rn(reg));
2763 jit_unget_reg(reg);
2764 }
2765}
2766
2767static void
2768_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2769{
2770 jit_int32_t reg;
2771 if (r1 == _R0_REGNO) {
2772 if (r2 != _R0_REGNO)
2773 LWZX(r0, r2, r1);
2774 else {
2775 reg = jit_get_reg(jit_class_gpr);
2776 movr(rn(reg), r1);
2777 LWAX(r0, rn(reg), r2);
2778 jit_unget_reg(reg);
2779 }
2780 }
2781 else
2782 LWZX(r0, r1, r2);
2783}
2784
2785static void
2786_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2787{
2788 jit_int32_t reg;
2789 if (i0 == 0)
2790 ldr_i(r0, r1);
2791 else if (can_sign_extend_short_p(i0)) {
2792 if (r1 == _R0_REGNO) {
2793 reg = jit_get_reg(jit_class_gpr);
2794 movr(rn(reg), r1);
2795 LWA(r0, rn(reg), i0);
2796 jit_unget_reg(reg);
2797 }
2798 else
2799 LWA(r0, r1, i0);
2800 }
2801 else {
2802 reg = jit_get_reg(jit_class_gpr);
2803 movi(rn(reg), i0);
2804 ldxr_i(r0, r1, rn(reg));
2805 jit_unget_reg(reg);
2806 }
2807}
2808
2809static void
2810_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2811{
2812 jit_bool_t inv;
2813 jit_int32_t reg;
2814 jit_word_t lo, hi;
2815 if (can_sign_extend_short_p(i0))
2816 LWZ(r0, _R0_REGNO, i0);
2817 else if (can_sign_extend_int_p(i0)) {
2818 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2819 lo = (jit_int16_t)(i0 - (hi << 16));
2820 reg = jit_get_reg(jit_class_gpr);
2821 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2822 LIS(rn(reg), hi);
2823 LWZ(r0, rn(reg), lo);
2824 jit_unget_reg(reg);
2825 if (inv) jit_unget_reg(_R0);
2826 }
2827 else {
2828 reg = jit_get_reg(jit_class_gpr);
2829 movi(rn(reg), i0);
2830 ldr_ui(r0, rn(reg));
2831 jit_unget_reg(reg);
2832 }
2833}
2834
2835static void
2836_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2837{
2838 jit_int32_t reg;
2839 if (r1 == _R0_REGNO) {
2840 if (r2 != _R0_REGNO)
2841 LWZX(r0, r2, r1);
2842 else {
2843 reg = jit_get_reg(jit_class_gpr);
2844 movr(rn(reg), r1);
2845 LWZX(r0, rn(reg), r2);
2846 jit_unget_reg(reg);
2847 }
2848 }
2849 else
2850 LWZX(r0, r1, r2);
2851}
2852
2853static void
2854_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2855{
2856 jit_int32_t reg;
2857 if (i0 == 0)
2858 ldr_i(r0, r1);
2859 else if (can_sign_extend_short_p(i0)) {
2860 if (r1 == _R0_REGNO) {
2861 reg = jit_get_reg(jit_class_gpr);
2862 movr(rn(reg), r1);
2863 LWZ(r0, rn(reg), i0);
2864 jit_unget_reg(reg);
2865 }
2866 else
2867 LWZ(r0, r1, i0);
2868 }
2869 else {
2870 reg = jit_get_reg(jit_class_gpr);
2871 movi(rn(reg), i0);
2872 ldxr_ui(r0, r1, rn(reg));
2873 jit_unget_reg(reg);
2874 }
2875}
2876
2877static void
2878_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2879{
2880 jit_bool_t inv;
2881 jit_int32_t reg;
2882 jit_word_t lo, hi;
2883 if (can_sign_extend_short_p(i0))
2884 LD(r0, _R0_REGNO, i0);
2885 else if (can_sign_extend_int_p(i0)) {
2886 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2887 lo = (jit_int16_t)(i0 - (hi << 16));
2888 reg = jit_get_reg(jit_class_gpr);
2889 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2890 LIS(rn(reg), hi);
2891 LD(r0, rn(reg), lo);
2892 jit_unget_reg(reg);
2893 if (inv) jit_unget_reg(_R0);
2894 }
2895 else {
2896 reg = jit_get_reg(jit_class_gpr);
2897 movi(rn(reg), i0);
2898 ldr_l(r0, rn(reg));
2899 jit_unget_reg(reg);
2900 }
2901}
2902
2903static void
2904_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2905{
2906 jit_int32_t reg;
2907 if (r1 == _R0_REGNO) {
2908 if (r2 != _R0_REGNO)
2909 LDX(r0, r2, r1);
2910 else {
2911 reg = jit_get_reg(jit_class_gpr);
2912 movr(rn(reg), r1);
2913 LDX(r0, rn(reg), r2);
2914 jit_unget_reg(reg);
2915 }
2916 }
2917 else
2918 LDX(r0, r1, r2);
2919}
2920
2921static void
2922_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2923{
2924 jit_int32_t reg;
2925 if (i0 == 0)
2926 ldr_l(r0, r1);
2927 else if (can_sign_extend_short_p(i0)) {
2928 if (r1 == _R0_REGNO) {
2929 reg = jit_get_reg(jit_class_gpr);
2930 movr(rn(reg), r1);
2931 LD(r0, rn(reg), i0);
2932 jit_unget_reg(reg);
2933 }
2934 else
2935 LD(r0, r1, i0);
2936 }
2937 else {
2938 reg = jit_get_reg(jit_class_gpr);
2939 movi(rn(reg), i0);
2940 ldxr_l(r0, r1, rn(reg));
2941 jit_unget_reg(reg);
2942 }
2943}
2944# endif
2945
2946static void
2947_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2948{
2949 jit_bool_t inv;
2950 jit_int32_t reg;
2951 jit_word_t lo, hi;
2952 if (can_sign_extend_short_p(i0))
2953 STB(r0, _R0_REGNO, i0);
2954 else if (can_sign_extend_int_p(i0)) {
2955 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2956 lo = (jit_int16_t)(i0 - (hi << 16));
2957 reg = jit_get_reg(jit_class_gpr);
2958 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2959 LIS(rn(reg), hi);
2960 STB(r0, rn(reg), lo);
2961 jit_unget_reg(reg);
2962 if (inv) jit_unget_reg(_R0);
2963 }
2964 else {
2965 reg = jit_get_reg(jit_class_gpr);
2966 movi(rn(reg), i0);
2967 str_c(rn(reg), r0);
2968 jit_unget_reg(reg);
2969 }
2970}
2971
2972static void
2973_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2974{
2975 jit_int32_t reg;
2976 if (r0 == _R0_REGNO) {
2977 if (r1 != _R0_REGNO)
2978 STBX(r2, r1, r0);
2979 else {
2980 reg = jit_get_reg(jit_class_gpr);
2981 movr(rn(reg), r0);
2982 STBX(r2, rn(reg), r1);
2983 jit_unget_reg(reg);
2984 }
2985 }
2986 else
2987 STBX(r2, r0, r1);
2988}
2989
2990static void
2991_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2992{
2993 jit_int32_t reg;
2994 if (i0 == 0)
2995 str_c(r0, r1);
2996 else if (can_sign_extend_short_p(i0)) {
2997 if (r0 == _R0_REGNO) {
2998 reg = jit_get_reg(jit_class_gpr);
2999 movr(rn(reg), i0);
3000 STB(r1, rn(reg), i0);
3001 jit_unget_reg(reg);
3002 }
3003 else
3004 STB(r1, r0, i0);
3005 }
3006 else {
3007 reg = jit_get_reg(jit_class_gpr);
3008 movi(rn(reg), i0);
3009 stxr_c(rn(reg), r0, r1);
3010 jit_unget_reg(reg);
3011 }
3012}
3013
3014static void
3015_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3016{
3017 jit_bool_t inv;
3018 jit_int32_t reg;
3019 jit_word_t lo, hi;
3020 if (can_sign_extend_short_p(i0))
3021 STH(r0, _R0_REGNO, i0);
3022 else if (can_sign_extend_int_p(i0)) {
3023 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3024 lo = (jit_int16_t)(i0 - (hi << 16));
3025 reg = jit_get_reg(jit_class_gpr);
3026 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3027 LIS(rn(reg), hi);
3028 STH(r0, rn(reg), lo);
3029 jit_unget_reg(reg);
3030 if (inv) jit_unget_reg(_R0);
3031 }
3032 else {
3033 reg = jit_get_reg(jit_class_gpr);
3034 movi(rn(reg), i0);
3035 str_s(rn(reg), r0);
3036 jit_unget_reg(reg);
3037 }
3038}
3039
3040static void
3041_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3042{
3043 jit_int32_t reg;
3044 if (r0 == _R0_REGNO) {
3045 if (r1 != _R0_REGNO)
3046 STHX(r2, r1, r0);
3047 else {
3048 reg = jit_get_reg(jit_class_gpr);
3049 movr(rn(reg), r0);
3050 STHX(r2, rn(reg), r1);
3051 jit_unget_reg(reg);
3052 }
3053 }
3054 else
3055 STHX(r2, r0, r1);
3056}
3057
3058static void
3059_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3060{
3061 jit_int32_t reg;
3062 if (i0 == 0)
3063 str_s(r0, r1);
3064 else if (can_sign_extend_short_p(i0)) {
3065 if (r0 == _R0_REGNO) {
3066 reg = jit_get_reg(jit_class_gpr);
3067 movr(rn(reg), i0);
3068 STH(r1, rn(reg), i0);
3069 jit_unget_reg(reg);
3070 }
3071 else
3072 STH(r1, r0, i0);
3073 }
3074 else {
3075 reg = jit_get_reg(jit_class_gpr);
3076 movi(rn(reg), i0);
3077 stxr_s(rn(reg), r0, r1);
3078 jit_unget_reg(reg);
3079 }
3080}
3081
3082static void
3083_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3084{
3085 jit_bool_t inv;
3086 jit_int32_t reg;
3087 jit_word_t lo, hi;
3088 if (can_sign_extend_short_p(i0))
3089 STW(r0, _R0_REGNO, i0);
3090 else if (can_sign_extend_int_p(i0)) {
3091 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3092 lo = (jit_int16_t)(i0 - (hi << 16));
3093 reg = jit_get_reg(jit_class_gpr);
3094 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3095 LIS(rn(reg), hi);
3096 STW(r0, rn(reg), lo);
3097 jit_unget_reg(reg);
3098 if (inv) jit_unget_reg(_R0);
3099 }
3100 else {
3101 reg = jit_get_reg(jit_class_gpr);
3102 movi(rn(reg), i0);
3103 str_i(rn(reg), r0);
3104 jit_unget_reg(reg);
3105 }
3106}
3107
3108static void
3109_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3110{
3111 jit_int32_t reg;
3112 if (r0 == _R0_REGNO) {
3113 if (r1 != _R0_REGNO)
3114 STWX(r2, r1, r0);
3115 else {
3116 reg = jit_get_reg(jit_class_gpr);
3117 movr(rn(reg), r0);
3118 STWX(r2, rn(reg), r1);
3119 jit_unget_reg(reg);
3120 }
3121 }
3122 else
3123 STWX(r2, r0, r1);
3124}
3125
3126static void
3127_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3128{
3129 jit_int32_t reg;
3130 if (i0 == 0)
3131 str_i(r0, r1);
3132 else if (can_sign_extend_short_p(i0)) {
3133 if (r0 == _R0_REGNO) {
3134 reg = jit_get_reg(jit_class_gpr);
3135 movr(rn(reg), i0);
3136 STW(r1, rn(reg), i0);
3137 jit_unget_reg(reg);
3138 }
3139 else
3140 STW(r1, r0, i0);
3141 }
3142 else {
3143 reg = jit_get_reg(jit_class_gpr);
3144 movi(rn(reg), i0);
3145 stxr_i(rn(reg), r0, r1);
3146 jit_unget_reg(reg);
3147 }
3148}
3149
3150# if __WORDSIZE == 64
3151static void
3152_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3153{
3154 jit_bool_t inv;
3155 jit_int32_t reg;
3156 jit_word_t lo, hi;
3157 if (can_sign_extend_short_p(i0))
3158 STD(r0, _R0_REGNO, i0);
3159 else if (can_sign_extend_int_p(i0)) {
3160 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3161 lo = (jit_int16_t)(i0 - (hi << 16));
3162 reg = jit_get_reg(jit_class_gpr);
3163 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3164 LIS(rn(reg), hi);
3165 STD(r0, rn(reg), lo);
3166 jit_unget_reg(reg);
3167 if (inv) jit_unget_reg(_R0);
3168 }
3169 else {
3170 reg = jit_get_reg(jit_class_gpr);
3171 movi(rn(reg), i0);
3172 str_l(rn(reg), r0);
3173 jit_unget_reg(reg);
3174 }
3175}
3176
3177static void
3178_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3179{
3180 jit_int32_t reg;
3181 if (r0 == _R0_REGNO) {
3182 if (r1 != _R0_REGNO)
3183 STDX(r2, r1, r0);
3184 else {
3185 reg = jit_get_reg(jit_class_gpr);
3186 movr(rn(reg), r0);
3187 STDX(r2, rn(reg), r1);
3188 jit_unget_reg(reg);
3189 }
3190 }
3191 else
3192 STDX(r2, r0, r1);
3193}
3194
3195static void
3196_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3197{
3198 jit_int32_t reg;
3199 if (i0 == 0)
3200 str_l(r0, r1);
3201 else if (can_sign_extend_short_p(i0)) {
3202 if (r0 == _R0_REGNO) {
3203 reg = jit_get_reg(jit_class_gpr);
3204 movr(rn(reg), i0);
3205 STD(r1, rn(reg), i0);
3206 jit_unget_reg(reg);
3207 }
3208 else
3209 STD(r1, r0, i0);
3210 }
3211 else {
3212 reg = jit_get_reg(jit_class_gpr);
3213 movi(rn(reg), i0);
3214 stxr_l(rn(reg), r0, r1);
3215 jit_unget_reg(reg);
3216 }
3217}
3218# endif
3219
3220static void
3221_jmpr(jit_state_t *_jit, jit_int32_t r0)
3222{
3223#if 0
3224 MTLR(r0);
3225 BLR();
3226#else
3227 MTCTR(r0);
3228 BCTR();
3229#endif
3230}
3231
3232/* pc relative jump */
3233static jit_word_t
3234_jmpi(jit_state_t *_jit, jit_word_t i0)
3235{
3236 jit_int32_t reg;
3237 jit_word_t w, d;
3238 w = _jit->pc.w;
3239 d = (i0 - w) & ~3;
3240 if (can_sign_extend_jump_p(d))
3241 B(d);
3242 else {
3243 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3244 w = movi_p(rn(reg), i0);
3245 jmpr(rn(reg));
3246 jit_unget_reg(reg);
3247 }
3248 return (w);
3249}
3250
3251/* absolute jump */
3252static jit_word_t
3253_jmpi_p(jit_state_t *_jit, jit_word_t i0)
3254{
3255 jit_word_t w;
3256 jit_int32_t reg;
3257 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3258 w = movi_p(rn(reg), i0);
3259 jmpr(rn(reg));
3260 jit_unget_reg(reg);
3261 return (w);
3262}
3263
3264static void
3265_callr(jit_state_t *_jit, jit_int32_t r0
3266# if _CALL_SYSV
3267 , jit_int32_t varargs
3268# endif
3269 )
3270{
3271# if _CALL_AIXDESC
3272 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3273 /* FIXME Pretend to not know about r11? */
3274 if (r0 == _R0_REGNO) {
3275 movr(_R11_REGNO, _R0_REGNO);
3276 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3277 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3278 }
3279 else {
3280 ldxi(_R2_REGNO, r0, sizeof(void*));
3281 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3282 }
3283 ldr(r0, r0);
3284# else
3285# if _CALL_SYSV
3286 /* Tell double arguments were passed in registers. */
3287 if (varargs)
3288 CREQV(6, 6, 6);
3289# endif
3290 movr(_R12_REGNO, r0);
3291# endif
3292
3293 MTCTR(r0);
3294 BCTRL();
3295
3296# if _CALL_AIXDESC
3297 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3298# endif
3299}
3300
3301/* assume fixed address or reachable address */
3302static void
3303_calli(jit_state_t *_jit, jit_word_t i0
3304# if _CALL_SYSV
3305 , jit_int32_t varargs
3306# endif
3307 )
3308{
3309# if _CALL_SYSV
3310 jit_word_t d;
ba3814c1
PC		 3311 d = (i0 - _jit->pc.w - !!varargs * 4) & ~3;
3312 if (can_sign_extend_jump_p(d)) {
3313 /* Tell double arguments were passed in registers. */
3314 if (varargs)
3315 CREQV(6, 6, 6);
3316 BL(d);
3317 } else
4a71579b
PC		 3318# endif
3319 {
3320 movi(_R12_REGNO, i0);
3321 callr(_R12_REGNO
3322# if _CALL_SYSV
3323 , varargs
3324# endif
3325 );
3326 }
3327}
3328
3329/* absolute jump */
3330static jit_word_t
3331_calli_p(jit_state_t *_jit, jit_word_t i0
3332# if _CALL_SYSV
3333 , jit_int32_t varargs
3334# endif
3335 )
3336{
3337 jit_word_t w;
3338 w = movi_p(_R12_REGNO, i0);
3339 callr(_R12_REGNO
3340# if _CALL_SYSV
3341 , varargs
3342# endif
3343 );
3344 return (w);
3345}
3346
3347/* order is not guaranteed to be sequential */
3348static jit_int32_t save[] = {
3349 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3350 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3351};
3352
3353static void
3354_prolog(jit_state_t *_jit, jit_node_t *node)
3355{
3356 unsigned long regno;
3357 jit_word_t offset;
3358
3359 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3360 jit_int32_t frame = -_jitc->function->frame;
3361 assert(_jitc->function->self.aoff >= frame);
3362 if (_jitc->function->assume_frame)
3363 return;
3364 _jitc->function->self.aoff = frame;
3365 }
3366 if (_jitc->function->allocar) {
3367 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3368 _jitc->function->self.aoff &= -16;
3369 }
3370 _jitc->function->stack = ((_jitc->function->self.alen +
3371 _jitc->function->self.size -
3372 _jitc->function->self.aoff) + 15) & -16;
3373
3374 /* return address */
3375 MFLR(_R0_REGNO);
3376
3377 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3378 * alloca < %r31-80 */
3379
3380#if _CALL_SYSV
3381 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3382#else
3383 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3384#endif
3385 offset = -gpr_save_area;
3386 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3387 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3388 stxi(offset, _SP_REGNO, rn(save[regno]));
3389 }
3390 for (offset = 0; offset < 8; offset++) {
3391 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3392 stxi_d(-(gpr_save_area + 8 + offset * 8),
3393 _SP_REGNO, rn(_F14 + offset));
3394 }
3395
3396 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3397
3398 movr(_FP_REGNO, _SP_REGNO);
3399#if __WORDSIZE == 32
3400 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3401#else
3402 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3403#endif
3404
3405 if (_jitc->function->allocar) {
3406 regno = jit_get_reg(jit_class_gpr);
3407 movi(rn(regno), _jitc->function->self.aoff);
3408 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3409 jit_unget_reg(regno);
3410 }
3411
3412#if !_CALL_SYSV
3413 if (_jitc->function->self.call & jit_call_varargs) {
3414 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3415 stxi(params_offset + regno * sizeof(jit_word_t),
3416 _FP_REGNO, rn(JIT_RA0 - regno));
3417 }
3418#else
3419 if (_jitc->function->self.call & jit_call_varargs) {
3420 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3421 stxi(_jitc->function->vaoff + first_gp_offset +
3422 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3423 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3424 stxi_d(_jitc->function->vaoff + first_fp_offset +
3425 regno * va_fp_increment, _FP_REGNO,
3426 rn(JIT_FA0 - regno));
3427 }
3428#endif
3429}
3430
3431static void
3432_epilog(jit_state_t *_jit, jit_node_t *node)
3433{
3434 unsigned long regno;
3435 jit_word_t offset;
3436
3437 if (_jitc->function->assume_frame)
3438 return;
3439 if (_jitc->function->allocar)
3440 ldr(_SP_REGNO, _SP_REGNO);
3441 else
3442 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3443#if _CALL_SYSV
3444 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3445#else
3446 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3447#endif
3448 offset = -gpr_save_area;
3449 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3450 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3451 ldxi(rn(save[regno]), _SP_REGNO, offset);
3452 }
3453 for (offset = 0; offset < 8; offset++) {
3454 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3455 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3456 -(gpr_save_area + 8 + offset * 8));
3457 }
3458
3459 MTLR(_R0_REGNO);
3460 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3461
3462 BLR();
3463}
3464
3465static void
3466_vastart(jit_state_t *_jit, jit_int32_t r0)
3467{
3468#if !_CALL_SYSV
3469 assert(_jitc->function->self.call & jit_call_varargs);
3470 /* Initialize stack pointer to the first stack argument. */
3471 addi(r0, _FP_REGNO, _jitc->function->self.size);
3472#else
3473 jit_int32_t reg;
3474 assert(_jitc->function->self.call & jit_call_varargs);
3475
3476 /* Return jit_va_list_t in the register argument */
3477 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3478 reg = jit_get_reg(jit_class_gpr);
3479
3480 /* Initialize the gp counter. */
3481 movi(rn(reg), _jitc->function->vagp);
3482 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3483
3484 /* Initialize the fp counter. */
3485 movi(rn(reg), _jitc->function->vafp);
3486 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3487
3488 /* Initialize overflow pointer to the first stack argument. */
3489 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3490 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3491
3492 /* Initialize register save area pointer. */
3493 addi(rn(reg), r0, first_gp_offset);
3494 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3495
3496 jit_unget_reg(reg);
3497#endif
3498}
3499
3500static void
3501_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3502{
3503#if !_CALL_SYSV
3504 assert(_jitc->function->self.call & jit_call_varargs);
3505 /* Load argument. */
3506 ldr(r0, r1);
3507 /* Update va_list. */
3508 addi(r1, r1, sizeof(jit_word_t));
3509#else
3510 jit_int32_t rg0;
3511 jit_int32_t rg1;
3512 jit_word_t ge_code;
3513 jit_word_t lt_code;
3514
3515 assert(_jitc->function->self.call & jit_call_varargs);
3516
3517 rg0 = jit_get_reg(jit_class_gpr);
3518 rg1 = jit_get_reg(jit_class_gpr);
3519
3520 /* Load the gp offset in save area in the first temporary. */
3521 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3522
3523 /* Jump over if there are no remaining arguments in the save area. */
3524 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3525
3526 /* Update the gp counter. */
3527 addi(rn(rg1), rn(rg0), 1);
3528 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3529
3530 /* Load the save area pointer in the second temporary. */
3531 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3532
3533 /* Load the vararg argument in the first argument. */
3534 lshi(rn(rg0), rn(rg0), va_gp_shift);
3535 ldxr(r0, rn(rg1), rn(rg0));
3536
3537 /* Will only need one temporary register below. */
3538 jit_unget_reg(rg1);
3539
3540 /* Jump over overflow code. */
3541 lt_code = _jit->pc.w;
3542 B(0);
3543
3544 /* Where to land if argument is in overflow area. */
3545 patch_at(ge_code, _jit->pc.w);
3546
3547 /* Load overflow pointer. */
3548 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3549
3550 /* Load argument. */
3551 ldr(r0, rn(rg0));
3552
3553 /* Update overflow pointer. */
3554 addi(rn(rg0), rn(rg0), va_gp_increment);
3555 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3556
3557 /* Where to land if argument is in save area. */
3558 patch_at(lt_code, _jit->pc.w);
3559
3560 jit_unget_reg(rg0);
3561#endif
3562}
3563
3564static void
3565_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3566{
3567#if !_CALL_SYSV
3568 assert(_jitc->function->self.call & jit_call_varargs);
3569 /* Load argument. */
3570 ldr_d(r0, r1);
3571 /* Update va_list. */
3572 addi(r1, r1, sizeof(jit_float64_t));
3573#else
3574 jit_int32_t rg0;
3575 jit_int32_t rg1;
3576 jit_word_t ge_code;
3577 jit_word_t lt_code;
3578
3579 assert(_jitc->function->self.call & jit_call_varargs);
3580
3581 rg0 = jit_get_reg(jit_class_gpr);
3582 rg1 = jit_get_reg(jit_class_gpr);
3583
3584 /* Load the fp offset in save area in the first temporary. */
3585 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3586
3587 /* Jump over if there are no remaining arguments in the save area. */
3588 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3589
3590 /* Update the fp counter. */
3591 addi(rn(rg1), rn(rg0), 1);
3592 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3593
3594 /* Load the save area pointer in the second temporary. */
3595 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3596
3597 /* Load the vararg argument in the first argument. */
3598 lshi(rn(rg0), rn(rg0), 3);
3599 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3600 offsetof(jit_va_list_t, first_gp_argument));
3601 ldxr_d(r0, rn(rg1), rn(rg0));
3602
3603 /* Jump over overflow code. */
3604 lt_code = _jit->pc.w;
3605 B(0);
3606
3607 /* Where to land if argument is in overflow area. */
3608 patch_at(ge_code, _jit->pc.w);
3609
3610 /* Load overflow pointer. */
3611 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3612
3613# if __WORDSIZE == 32
3614 /* Align if required. */
3615 andi(rn(rg1), rn(rg0), 7);
3616 addr(rn(rg0), rn(rg0), rn(rg1));
3617# endif
3618
3619 /* Load argument. */
3620 ldr_d(r0, rn(rg0));
3621
3622 /* Update overflow pointer. */
3623 addi(rn(rg0), rn(rg0), va_fp_increment);
3624 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3625
3626 /* Where to land if argument is in save area. */
3627 patch_at(lt_code, _jit->pc.w);
3628
3629 jit_unget_reg(rg0);
3630 jit_unget_reg(rg1);
3631#endif
3632}
3633
3634static void
3635_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3636{
3637 jit_word_t d;
3638 union {
3639 jit_int32_t *i;
3640 jit_word_t w;
3641 } u;
3642 u.w = instr;
3643 switch ((u.i[0] & 0xfc000000) >> 26) {
3644 case 16: /* BCx */
3645 d = label - instr;
3646 assert(!(d & 3));
3647 if (!can_sign_extend_short_p(d)) {
3648 /* use absolute address */
3649 assert(can_sign_extend_short_p(label));
3650 d |= 2;
3651 }
3652 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3653 break;
3654 case 18: /* Bx */
3655#if _CALL_AIXDESC
3656 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3657 /* zero is used for toc and env, so, quick check
3658 * if this is a "jmpi main" like initial jit
3659 * instruction */
3660 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3661 for (d = 0; d < _jitc->prolog.offset; d++) {
3662 /* not so pretty, but hides powerpc
3663 * specific abi intrinsics and/or
3664 * implementation from user */
3665 if (_jitc->prolog.ptr[d] == label) {
3666 label += sizeof(void*) * 3;
3667 break;
3668 }
3669 }
3670 }
3671 }
3672#endif
3673 d = label - instr;
3674 assert(!(d & 3));
3675 if (!can_sign_extend_jump_p(d)) {
3676 /* use absolute address */
3677 assert(can_sign_extend_jump_p(label));
3678 d |= 2;
3679 }
3680 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3681 break;
3682 case 15: /* LI */
3683#if __WORDSIZE == 32
3684# define MTCTR_OFF 2
3685# define BCTR_OFF 3
3686#else
3687# define MTCTR_OFF 6
3688# define BCTR_OFF 7
3689#endif
3690#if _CALL_AIXDESC
3691 /* movi reg label; jmpr reg */
3692 if (_jitc->jump &&
3693#if 0
3694 /* check for MLTR(reg) */
3695 (u.i[MTCTR_OFF] >> 26) == 31 &&
3696 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3697 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3698 /* check for BLR */
3699 u.i[BCTR_OFF] == 0x4e800020) {
3700#else
3701 /* check for MTCTR(reg) */
3702 (u.i[MTCTR_OFF] >> 26) == 31 &&
3703 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3704 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3705 /* check for BCTR */
3706 u.i[BCTR_OFF] == 0x4e800420) {
3707#endif
3708 /* zero is used for toc and env, so, quick check
3709 * if this is a "jmpi main" like initial jit
3710 * instruction */
3711 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3712 for (d = 0; d < _jitc->prolog.offset; d++) {
3713 /* not so pretty, but hides powerpc
3714 * specific abi intrinsics and/or
3715 * implementation from user */
3716 if (_jitc->prolog.ptr[d] == label) {
3717 label += sizeof(void*) * 3;
3718 break;
3719 }
3720 }
3721 }
3722 }
3723#endif
3724#undef BCTR_OFF
3725#undef MTCTR_OFF
3726#if __WORDSIZE == 32
3727 assert(!(u.i[0] & 0x1f0000));
3728 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3729 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3730 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3731 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3732#else
3733 assert(!(u.i[0] & 0x1f0000));
3734 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3735 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3736 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3737 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3738 /* not fully validating SLDI */
3739 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3740 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3741 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3742 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3743 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3744 /* not fully validating SLDI */
3745 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3746 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3747 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3748 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3749 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3750#endif
3751 break;
3752 default:
3753 assert(!"unhandled branch opcode");
3754 }
3755}
3756#endif
ARM optimized PCSX fork