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