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