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