2 * Copyright (C) 2012-2022 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
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)
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.
17 * Paulo Cesar Pereira de Andrade
22 # define gpr_save_area 72 /* r14~r31 = 18 * 4 */
24 # define params_offset (sizeof(jit_word_t) << 1)
26 # define params_offset 24
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
32 # define gpr_save_area 144 /* r14~r31 = 18 * 8 */
34 # define params_offset 32
36 # define params_offset 48
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)
45 # define fpr_save_area 64
46 # define alloca_offset -(gpr_save_area + fpr_save_area)
47 # define ii(i) *_jit->pc.ui++ = i
49 # define iw(i) *_jit->pc.ui++ = i
51 # define iw(i) *_jit->pc.ul++ = i
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)
59 # define _R11_REGNO 11
60 # define _R12_REGNO 12
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)
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)
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)
77 static 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)
79 static void _FDs(jit_state_t*,int,int,int,int);
80 # define FDu(o,d,a,s) _FDu(_jit,o,d,a,s)
81 static 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)
84 static void _FX(jit_state_t*,int,int,int,int,int,int);
85 # define FI(o,t,a,k) _FI(_jit,o,t,a,k)
86 static 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)
88 static 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)
91 static 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)
93 static 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)
95 static void _FCI(jit_state_t*,int,int,int,int,int);
96 # define FXFX(o,s,x,f) _FXFX(_jit,o,s,x,f)
97 static 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)
99 static 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)
103 static 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)
106 static 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)
109 static void _FXS(jit_state_t*,int,int,int,int,int,int,int);
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 LHBRX(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 LDARX(d,a,b) FX(31,d,a,b,84)
275 # define LWBRX(d,a,b) FX(31,d,a,b,534)
276 # define LWA(d,a,s) FDs(58,d,a,s|2)
277 # define LWAUX(d,a,b) FX(31,d,a,b,373)
278 # define LWAX(d,a,b) FX(31,d,a,b,341)
279 # define LWZ(d,a,s) FDs(32,d,a,s)
280 # define LWZU(d,a,s) FDs(33,d,a,s)
281 # define LWZUX(d,a,b) FX(31,d,a,b,55)
282 # define LWZX(d,a,b) FX(31,d,a,b,23)
283 # define LD(d,a,s) FDs(58,d,a,s)
284 # define LDX(d,a,b) FX(31,d,a,b,21)
285 # define MCRF(d,s) FXL(19,d<<2,(s)<<2,0)
287 /* In case instruction is emulated, check the kernel can handle it.
288 Will only generate it if DEBUG is enabled.
290 Chapter 6. Optional Facilities and Instructions that are being
291 Phased Out of the Architecture
293 6.1 Move To Condition Register from XER
294 The mcrxr instruction is being phased out of the archi-
295 tecture. Its description is included here as an aid to
296 constructing operating system code to emulate it.
298 Move to Condition Register from XER
301 31 BF // /// /// 512 /
303 CR(4xBF:4xBF+3) <- XER(32:35)
305 The contents of XER(32:35) are copied to Condition Reg-
306 ister field BF. XER(32:35) are set to zero.
307 Special Registers Altered:
308 CR field BF XER(32:35)
311 Warning: This instruction has been phased out of
312 the architecture. Attempting to execute this
313 instruction will cause the system illegal instruction
314 error handler to be invoked
317 # define MCRXR(d) FX(31,d<<2,0,0,512)
319 # define MCRXR(cr) _MCRXR(_jit,cr);
320 static void _MCRXR(jit_state_t*, jit_int32_t);
322 # define MFCR(d) FX(31,d,0,0,19)
323 # define MFMSR(d) FX(31,d,0,0,83)
324 # define MFSPR(d,s) FXFX(31,d,s<<5,339)
325 # define MFXER(d) MFSPR(d,1)
326 # define MFLR(d) MFSPR(d,8)
327 # define MFCTR(d) MFSPR(d,9)
328 # define MFSR(d,s) FX(31,d,s,0,595)
329 # define MFSRIN(d,b) FX(31,d,0,b,659)
330 # define MFTB(d,x,y) FXFX(31,d,(x)|((y)<<5),371)
331 # define MFTBL(d) MFTB(d,8,12)
332 # define MFTBU(d) MFTB(d,8,13)
333 # define MTCRF(c,s) FXFX(31,s,c<<1,144)
334 # define MTCR(s) MTCRF(0xff,s)
335 # define MTMSR(s) FX(31,s,0,0,146)
336 # define MTSPR(d,s) FXFX(31,d,s<<5,467)
337 # define MTXER(d) MTSPR(d,1)
338 # define MTLR(d) MTSPR(d,8)
339 # define MTCTR(d) MTSPR(d,9)
340 # define MTSR(r,s) FX(31,s<<1,r,0,210)
341 # define MTSRIN(r,b) FX(31,r<<1,0,b,242)
342 # define MULLI(d,a,s) FDs(07,d,a,s)
343 # define MULHW(d,a,b) FXO(31,d,a,b,0,75)
344 # define MULHW_(d,a,b) FXO_(31,d,a,b,0,75)
345 # define MULHWU(d,a,b) FXO(31,d,a,b,0,11)
346 # define MULHWU_(d,a,b) FXO_(31,d,a,b,0,11)
347 # define MULLW(d,a,b) FXO(31,d,a,b,0,235)
348 # define MULLW_(d,a,b) FXO_(31,d,a,b,0,235)
349 # define MULLWO(d,a,b) FXO(31,d,a,b,1,235)
350 # define MULLWO_(d,a,b) FXO_(31,d,a,b,1,235)
351 # define MULHD(d,a,b) FXO(31,d,a,b,0,73)
352 # define MULHD_(d,a,b) FXO_(31,d,a,b,0,73)
353 # define MULHDU(d,a,b) FXO(31,d,a,b,0,9)
354 # define MULHDU_(d,a,b) FXO_(31,d,a,b,0,9)
355 # define MULLD(d,a,b) FXO(31,d,a,b,0,233)
356 # define MULLD_(d,a,b) FXO_(31,d,a,b,0,233)
357 # define MULLDO(d,a,b) FXO(31,d,a,b,1,233)
358 # define MULLDO_(d,a,b) FXO_(31,d,a,b,1,233)
359 # define NAND(d,a,b) FX(31,a,d,b,476)
360 # define NAND_(d,a,b) FX_(31,a,d,b,476)
361 # define NEG(d,a) FXO(31,d,a,0,0,104)
362 # define NEG_(d,a) FXO_(31,d,a,0,0,104)
363 # define NEGO(d,a) FXO(31,d,a,0,1,104)
364 # define NEGO_(d,a) FXO_(31,d,a,0,1,104)
365 # define NOR(d,a,b) FX(31,a,d,b,124)
366 # define NOR_(d,a,b) FX_(31,a,d,b,124)
367 # define NOT(d,s) NOR(d,s,s)
368 # define OR(d,a,b) FX(31,a,d,b,444)
369 # define OR_(d,a,b) FX_(31,a,d,b,444)
370 # define MR(d,a) OR(d,a,a)
371 # define ORC(d,a,b) FX(31,a,d,b,412)
372 # define ORC_(d,a,b) FX_(31,a,d,b,412)
373 # define ORI(d,a,u) FDu(24,a,d,u)
374 # define NOP() ORI(0,0,0)
375 # define ORIS(d,a,u) FDu(25,a,d,u)
376 # define RFI() FXL(19,0,0,50)
377 # define RLWIMI(d,s,h,b,e) FM(20,s,d,h,b,e,0)
378 # define RLWIMI_(d,s,h,b,e) FM(20,s,d,h,b,e,1)
379 # define INSLWI(a,s,n,b) RLWIMI(a,s,32-b,b,b+n-1)
380 # define INSRWI(a,s,n,b) RLWIMI(a,s,32-(b+n),b,(b+n)-1)
381 # define RLWINM(a,s,h,b,e) FM(21,s,a,h,b,e,0)
382 # define RLWINM_(a,s,h,b,e) FM(21,s,a,h,b,e,1)
383 # define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,n-1)
384 # define EXTRWI(a,s,n,b) RLWINM(a,s,b+n,32-n,31)
385 # define ROTLWI(a,s,n) RLWINM(a,s,n,0,31)
386 # define ROTRWI(a,s,n) RLWINM(a,s,32-n,0,31)
387 # define SLWI(a,s,n) RLWINM(a,s,n,0,31-n)
388 # define SRWI(a,s,n) RLWINM(a,s,32-n,n,31)
389 # define CLRLWI(a,s,n) RLWINM(a,s,0,n,31)
390 # define CLRRWI(a,s,n) RLWINM(a,s,0,0,31-n)
391 # define CLRLSWI(a,s,b,n) RLWINM(a,s,n,b-n,31-n)
392 # define RLWNM(a,s,b,m,e) FM(23,s,a,b,m,e,0)
393 # define RLWNM_(a,s,b,m,e) FM(23,s,a,b,m,e,1)
394 # define ROTLW(a,s,b) RLWNM(a,s,b,0,31)
395 # define SC() FDu(17,0,0,2)
396 # define SLW(a,s,b) FX(31,s,a,b,24)
397 # define SLW_(a,s,b) FX_(31,s,a,b,24)
398 # define SRAW(a,s,b) FX(31,s,a,b,792)
399 # define SRAW_(a,s,b) FX_(31,s,a,b,792)
400 # define SRAWI(a,s,h) FX(31,s,a,h,824)
401 # define SRAWI_(a,s,h) FX_(31,s,a,h,824)
402 # define SRW(a,s,b) FX(31,s,a,b,536)
403 # define SRW_(a,s,b) FX_(31,s,a,b,536)
404 # if __WORDSIZE == 64
405 # define RLDICL(a,s,h,b) FMD(30,s,a,h&~32,b,0,h>>5)
406 # define RLDICL_(a,s,h,b) FMD_(30,s,a,h&~32,b,0,h>>5)
407 # define EXTRDI(x,y,n,b) RLDICL(x,y,(b+n),(64-n))
408 # define SRDI(x,y,n) RLDICL(x,y,(64-n),n)
409 # define CLRLDI(x,y,n) RLDICL(x,y,0,n)
410 # define RLDICR(a,s,h,e) FMD(30,s,a,h&~32,e,1,h>>5)
411 # define RLDICR_(a,s,h,e) FMD_(30,s,a,h&~32,e,1,h>>5)
412 # define EXTRLI(x,y,n,b) RLDICR(x,y,b,(n-1))
413 # define SLDI(x,y,n) RLDICR(x,y,n,(63-n))
414 # define CLRRDI(x,y,n) RLDICR(x,y,0,(63-n))
415 # define RLDIC(a,s,h,b) FMD(30,s,a,h&~32,b,2,h>>5)
416 # define RLDIC_(a,s,h,b) FMD_(30,s,a,h&~32,b,2,h>>5)
417 # define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,(b-n))
418 # define RLDCL(a,s,h,b) FMDS(30,s,a,h,b,8)
419 # define RLDCL_(a,s,h,b) FMDS_(30,s,a,h,b,8)
420 # define ROTLD(x,y,z) RLDCL(x,y,z,0)
421 # define RLDCR(a,s,b,e) FMDS(30,s,a,b,e,0)
422 # define RLDCR_(a,s,b,e) FMDS_(30,s,a,b,e,0)
423 # define RLDIMI(a,s,h,b) FMD(30,s,a,h&~32,b,3,h>>5)
424 # define RLDIMI_(a,s,h,b) FMD_(30,s,a,h&~32,b,3,h>>5)
425 # define INSRDI(x,y,n,b) RLDIMI(x,y,(64-(b+n)),b)
426 # define SLD(a,s,b) FX(31,s,a,b,27)
427 # define SLD_(a,s,b) FX_(31,s,a,b,27)
428 # define SRD(a,s,b) FX(31,s,a,b,539)
429 # define SRD_(a,s,b) FX_(31,s,a,b,539)
430 # define SRADI(a,s,h) FXS(31,s,a,h&~32,413,h>>5)
431 # define SRADI_(a,s,h) FXS_(31,s,a,h&~32,413,h>>5)
432 # define SRAD(a,s,b) FX(31,s,a,b,794)
433 # define SRAD_(a,s,b) FX_(31,s,a,b,794)
435 # define STB(s,a,d) FDs(38,s,a,d)
436 # define STBU(s,a,d) FDs(39,s,a,d)
437 # define STBUX(s,a,b) FX(31,s,a,b,247)
438 # define STBX(s,a,b) FX(31,s,a,b,215)
439 # define STH(s,a,d) FDs(44,s,a,d)
440 # define STHBRX(s,a,b) FX(31,s,a,b,918)
441 # define STHU(s,a,d) FDs(45,s,a,d)
442 # define STHUX(s,a,b) FX(31,s,a,b,439)
443 # define STHX(s,a,b) FX(31,s,a,b,407)
444 # define STMW(s,a,d) FDs(47,s,a,d)
445 # define STWSI(s,a,nb) FX(31,s,a,nb,725)
446 # define STSWX(s,a,b) FX(31,s,a,b,661)
447 # define STW(s,a,d) FDs(36,s,a,d)
448 # define STWBRX(s,a,b) FX(31,s,a,b,662)
449 # define STWCX_(s,a,b) FX_(31,s,a,b,150)
450 # define STDCX_(s,a,b) FX_(31,s,a,b,214)
451 # define STWU(s,a,d) FDs(37,s,a,d)
452 # define STWUX(s,a,b) FX(31,s,a,b,183)
453 # define STWX(s,a,b) FX(31,s,a,b,151)
454 # define STD(s,a,d) FDs(62,s,a,d)
455 # define STDX(s,a,b) FX(31,s,a,b,149)
456 # define STDU(s,a,d) FDs(62,s,a,d|1)
457 # define STDUX(s,a,b) FX(31,s,a,b,181)
458 # define SUBF(d,a,b) FXO(31,d,a,b,0,40)
459 # define SUBF_(d,a,b) FXO_(31,d,a,b,0,40)
460 # define SUBFO(d,a,b) FXO(31,d,a,b,1,40)
461 # define SUBFO_(d,a,b) FXO_(31,d,a,b,1,40)
462 # define SUB(d,a,b) SUBF(d,b,a)
463 # define SUB_(d,a,b) SUBF_(d,b,a)
464 # define SUBO(d,a,b) SUBFO(d,b,a)
465 # define SUBO_(d,a,b) SUBFO_(d,b,a)
466 # define SUBI(d,a,s) ADDI(d,a,-s)
467 # define SUBIS(d,a,s) ADDIS(d,a,-s)
468 # define SUBFC(d,a,b) FXO(31,d,a,b,0,8)
469 # define SUBFC_(d,a,b) FXO_(31,d,a,b,0,8)
470 # define SUBFCO(d,a,b) FXO(31,d,a,b,1,8)
471 # define SUBFCO_(d,a,b) FXO_(31,d,a,b,1,8)
472 # define SUBC(d,a,b) SUBFC(d,b,a)
473 # define SUBIC(d,a,s) ADDIC(d,a,-s)
474 # define SUBIC_(d,a,s) ADDIC_(d,a,-s)
475 # define SUBFE(d,a,b) FXO(31,d,a,b,0,136)
476 # define SUBFE_(d,a,b) FXO_(31,d,a,b,0,136)
477 # define SUBFEO(d,a,b) FXO(31,d,a,b,1,136)
478 # define SUBFEO_(d,a,b) FXO_(31,d,a,b,1,136)
479 # define SUBE(d,a,b) SUBFE(d,b,a)
480 # define SUBFIC(d,a,s) FDs(8,d,a,s)
481 # define SUBFME(d,a) FXO(31,d,a,0,0,232)
482 # define SUBFME_(d,a) FXO_(31,d,a,0,0,232)
483 # define SUBFMEO(d,a) FXO(31,d,a,0,1,232)
484 # define SUBFMEO_(d,a) FXO_(31,d,a,0,1,232)
485 # define SUBFZE(d,a) FXO(31,d,a,0,0,200)
486 # define SUBFZE_(d,a) FXO_(31,d,a,0,0,200)
487 # define SUBFZEO(d,a) FXO(31,d,a,0,1,200)
488 # define SUBFZEO_(d,a) FXO_(31,d,a,0,1,200)
489 # define SYNC() FX(31,0,0,0,598)
490 # define TLBIA() FX(31,0,0,0,370)
491 # define TLBIE(b) FX(31,0,0,b,306)
492 # define TLBSYNC() FX(31,0,0,0,566)
493 # define TW(t,a,b) FX(31,t,a,b,4)
494 # define TWEQ(a,b) FX(31,4,a,b,4)
495 # define TWLGE(a,b) FX(31,5,a,b,4)
496 # define TRAP() FX(31,31,0,0,4)
497 # define TWI(t,a,s) FDs(3,t,a,s)
498 # define TWGTI(a,s) TWI(8,a,s)
499 # define TWLLEI(a,s) TWI(6,a,s)
500 # define XOR(d,a,b) FX(31,a,d,b,316)
501 # define XOR_(d,a,b) FX_(31,a,d,b,316)
502 # define XORI(s,a,u) FDu(26,a,s,u)
503 # define XORIS(s,a,u) FDu(27,a,s,u)
504 # define nop(c) _nop(_jit,c)
505 static void _nop(jit_state_t*,jit_int32_t);
506 # define movr(r0,r1) _movr(_jit,r0,r1)
507 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
508 # define movi(r0,i0) _movi(_jit,r0,i0)
509 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
510 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
511 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
512 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
513 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
514 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
515 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
516 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
517 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
518 jit_int32_t,jit_int32_t,jit_word_t);
519 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
520 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
521 # define negr(r0,r1) NEG(r0,r1)
522 # define comr(r0,r1) NOT(r0,r1)
523 # define extr_c(r0,r1) EXTSB(r0,r1)
524 # define extr_uc(r0,r1) ANDI_(r0,r1,0xff)
525 # define extr_s(r0,r1) EXTSH(r0,r1)
526 # define extr_us(r0,r1) ANDI_(r0,r1,0xffff)
527 # if __WORDSIZE == 64
528 # define extr_i(r0,r1) EXTSW(r0,r1)
529 # define extr_ui(r0,r1) CLRLDI(r0,r1,32)
531 # define bswapr_us_lh(r0,r1,no_flag) _bswapr_us(_jit,r0,r1,no_flag)
532 # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1,0)
533 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
534 # define bswapr_ui_lw(r0,r1,no_flag) _bswapr_ui(_jit,r0,r1,no_flag)
535 # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1,0)
536 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
537 # if __WORDSIZE == 64
538 # define bswapr_ul(r0,r1) generic_bswapr_ul(_jit,r0,r1)
540 # define addr(r0,r1,r2) ADD(r0,r1,r2)
541 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
542 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
543 # define addcr(r0,r1,r2) ADDC(r0,r1,r2)
544 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
545 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
546 # define addxr(r0,r1,r2) ADDE(r0,r1,r2)
547 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
548 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
549 # define subr(r0,r1,r2) SUB(r0,r1,r2)
550 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
551 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
552 # define subcr(r0,r1,r2) SUBC(r0,r1,r2)
553 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
554 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
555 # define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
556 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
557 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
558 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
559 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
560 # if __WORDSIZE == 32
561 # define mulr(r0,r1,r2) MULLW(r0,r1,r2)
562 # define mullr(r0,r1,r2) MULLW(r0,r1,r2)
563 # define mulhr(r0,r1,r2) MULHW(r0,r1,r2)
564 # define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2)
566 # define mulr(r0,r1,r2) MULLD(r0,r1,r2)
567 # define mullr(r0,r1,r2) MULLD(r0,r1,r2)
568 # define mulhr(r0,r1,r2) MULHD(r0,r1,r2)
569 # define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2)
571 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
572 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
573 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
574 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
575 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
576 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
577 jit_int32_t,jit_int32_t,jit_bool_t);
578 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
579 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
580 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
581 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
582 jit_int32_t,jit_word_t,jit_bool_t);
583 # if __WORDSIZE == 32
584 # define divr(r0,r1,r2) DIVW(r0,r1,r2)
586 # define divr(r0,r1,r2) DIVD(r0,r1,r2)
588 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
589 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
590 # if __WORDSIZE == 32
591 # define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
593 # define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
595 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
596 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
597 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
598 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
599 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
600 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
601 jit_int32_t,jit_int32_t,jit_bool_t);
602 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
603 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
604 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
605 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
606 jit_int32_t,jit_word_t,jit_bool_t);
607 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
608 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
609 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
610 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
611 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
612 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
613 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
614 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
615 # define andr(r0,r1,r2) AND(r0,r1,r2)
616 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
617 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
618 # define orr(r0,r1,r2) OR(r0,r1,r2)
619 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
620 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
621 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
622 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
623 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
624 # if __WORDSIZE == 32
625 # define lshr(r0,r1,r2) SLW(r0,r1,r2)
627 # define lshr(r0,r1,r2) SLD(r0,r1,r2)
629 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
630 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
631 # if __WORDSIZE == 32
632 # define rshr(r0,r1,r2) SRAW(r0,r1,r2)
634 # define rshr(r0,r1,r2) SRAD(r0,r1,r2)
636 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
637 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
638 # if __WORDSIZE == 32
639 # define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
641 # define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
643 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
644 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
645 # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
646 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
647 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
648 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
649 # define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
650 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
651 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
652 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
653 # define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
654 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
655 # define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
656 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
657 # define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
658 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
659 # define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
660 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
661 # define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
662 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
663 # define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
664 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
665 # define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
666 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
667 # define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
668 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
669 # define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
670 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
671 # define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
672 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
673 # define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
674 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
675 # define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
676 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
677 # define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
678 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
679 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
680 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
681 # define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
682 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
683 # define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
684 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
685 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
686 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
687 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
688 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
689 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
690 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
691 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
692 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
693 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
694 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
695 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
696 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
697 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
698 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
699 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
700 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
701 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
702 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
703 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
704 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
705 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
706 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
707 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
708 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
709 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
710 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
711 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
712 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
713 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
714 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
715 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
716 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
717 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
718 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
719 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
720 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
721 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
722 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
723 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
724 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
725 #define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
726 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
727 #define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
728 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
729 #define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
730 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
731 #define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
732 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
733 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
734 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
735 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
736 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
737 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
738 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
739 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
740 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
741 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
742 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
743 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
744 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
745 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
746 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
747 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
748 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
749 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
750 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
751 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
752 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
753 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
754 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
755 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
756 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
757 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
758 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
759 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
760 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
761 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
762 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
763 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
764 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
765 # define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
766 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
767 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
768 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
769 # define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
770 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
771 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
772 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
773 # define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
774 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
775 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
776 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
777 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
778 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
779 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
780 # define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
781 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
782 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
783 # define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
784 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
785 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
786 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
787 # define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
788 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
789 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
790 # define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
791 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
792 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
793 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
794 # if __WORDSIZE == 32
795 # define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
797 # define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
799 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
800 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
801 # define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
802 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
803 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
804 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
805 # if __WORDSIZE == 64
806 # define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
807 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
808 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
809 # define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
810 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
811 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
812 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
813 # define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
814 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
815 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
816 # define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
817 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
818 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
819 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
821 # define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
822 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
823 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
824 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
825 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
826 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
827 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
828 # define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
829 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
830 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
831 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
832 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
833 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
834 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
835 # define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
836 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
837 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
838 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
839 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
840 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
841 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
842 # if __WORDSIZE == 64
843 # define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
844 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
845 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
846 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
847 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
848 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
849 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
851 # define jmpr(r0) _jmpr(_jit,r0)
852 static void _jmpr(jit_state_t*,jit_int32_t);
853 # define jmpi(i0) _jmpi(_jit,i0)
854 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
855 # define jmpi_p(i0) _jmpi_p(_jit,i0)
856 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
858 # define callr(r0,i0) _callr(_jit,r0,i0)
859 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
860 # define calli(i0,i1) _calli(_jit,i0,i1)
861 static void _calli(jit_state_t*,jit_word_t,jit_int32_t);
862 # define calli_p(i0,i1) _calli_p(_jit,i0,i1)
863 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
865 # define callr(r0) _callr(_jit,r0)
866 static void _callr(jit_state_t*,jit_int32_t);
867 # define calli(i0) _calli(_jit,i0)
868 static void _calli(jit_state_t*,jit_word_t);
869 # define calli_p(i0) _calli_p(_jit,i0)
870 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
872 # define prolog(node) _prolog(_jit, node)
873 static void _prolog(jit_state_t*, jit_node_t*);
874 # define epilog(node) _epilog(_jit, node)
875 static void _epilog(jit_state_t*, jit_node_t*);
876 # define vastart(r0) _vastart(_jit, r0)
877 static void _vastart(jit_state_t*, jit_int32_t);
878 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
879 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
880 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
881 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
882 # define patch_at(i,l) _patch_at(_jit,i,l)
883 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
887 # define _u16(v) ((v) & 0xffff)
888 # define _u26(v) ((v) & 0x3ffffff)
890 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
892 assert(!(o & ~((1 << 6) - 1)));
893 assert(!(d & ~((1 << 5) - 1)));
894 assert(!(a & ~((1 << 5) - 1)));
895 assert(!(b & ~((1 << 5) - 1)));
896 assert(!(e & ~((1 << 1) - 1)));
897 assert(!(x & ~((1 << 9) - 1)));
898 assert(!(r & ~((1 << 1) - 1)));
899 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
903 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
905 assert(!(o & ~((1 << 6) - 1)));
906 assert(!(d & ~((1 << 5) - 1)));
907 assert(!(a & ~((1 << 5) - 1)));
908 assert(can_sign_extend_short_p(s));
909 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
913 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
915 assert(!(o & ~((1 << 6) - 1)));
916 assert(!(d & ~((1 << 5) - 1)));
917 assert(!(a & ~((1 << 5) - 1)));
918 assert(can_zero_extend_short_p(s));
919 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
923 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
925 assert(!(o & ~((1 << 6) - 1)));
926 assert(!(s & ~((1 << 5) - 1)));
927 assert(!(a & ~((1 << 5) - 1)));
928 assert(!(b & ~((1 << 5) - 1)));
929 assert(!(x & ~((1 << 10) - 1)));
930 assert(!(r & ~((1 << 1) - 1)));
931 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
935 _FI(jit_state_t *_jit, int o, int t, int a, int k)
937 assert(!(o & ~(( 1 << 6) - 1)));
938 assert(!(t & 3) && can_sign_extend_jump_p(t));
939 assert(!(a & ~(( 1 << 1) - 1)));
940 assert(!(k & ~(( 1 << 1) - 1)));
941 ii((o<<26)|_u26(t)|(a<<1)|k);
945 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
947 assert(!( o & ~((1 << 6) - 1)));
948 assert(!(bo & ~((1 << 5) - 1)));
949 assert(!(bi & ~((1 << 5) - 1)));
950 assert(!(t & 3) && can_sign_extend_short_p(t));
951 assert(!(a & ~(( 1 << 1) - 1)));
952 assert(!(k & ~(( 1 << 1) - 1)));
953 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
957 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
959 assert(!( o & ~((1 << 6) - 1)));
960 assert(!(bo & ~((1 << 5) - 1)));
961 assert(!(bi & ~((1 << 5) - 1)));
962 assert(!(x & ~(( 1 << 10) - 1)));
963 assert(!(k & ~(( 1 << 1) - 1)));
964 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
968 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
970 assert(!(o & ~((1 << 6) - 1)));
971 assert(!(d & ~((1 << 3) - 1)));
972 assert(!(l & ~((1 << 1) - 1)));
973 assert(!(a & ~((1 << 5) - 1)));
974 assert(!(b & ~((1 << 5) - 1)));
975 assert(!(x & ~((1 << 10) - 1)));
976 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
980 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
982 assert(!(o & ~((1 << 6) - 1)));
983 assert(!(d & ~((1 << 3) - 1)));
984 assert(!(l & ~((1 << 1) - 1)));
985 assert(!(a & ~((1 << 5) - 1)));
986 if (o == 11) assert(can_sign_extend_short_p(s));
987 else if (o == 10) assert(can_zero_extend_short_p(s));
991 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
995 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
997 assert(!(o & ~((1 << 6) - 1)));
998 assert(!(d & ~((1 << 5) - 1)));
999 assert(!(x & ~((1 << 10) - 1)));
1000 assert(!(f & ~((1 << 10) - 1)));
1001 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1005 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
1007 assert(!(o & ~((1 << 6) - 1)));
1008 assert(!(s & ~((1 << 5) - 1)));
1009 assert(!(a & ~((1 << 5) - 1)));
1010 assert(!(h & ~((1 << 5) - 1)));
1011 assert(!(b & ~((1 << 5) - 1)));
1012 assert(!(e & ~((1 << 5) - 1)));
1013 assert(!(r & ~((1 << 1) - 1)));
1014 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1017 # if __WORDSIZE == 64
1019 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1021 assert(!(o & ~((1 << 6) - 1)));
1022 assert(!(s & ~((1 << 5) - 1)));
1023 assert(!(a & ~((1 << 5) - 1)));
1024 assert(!(b & ~((1 << 5) - 1)));
1025 assert(!(e & ~((1 << 6) - 1)));
1026 assert(!(x & ~((1 << 4) - 1)));
1027 assert(!(r & ~((1 << 1) - 1)));
1028 e = (e >> 5) | ((e << 1) & 63);
1029 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1033 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1035 assert(!(o & ~((1 << 6) - 1)));
1036 assert(!(s & ~((1 << 5) - 1)));
1037 assert(!(a & ~((1 << 5) - 1)));
1038 assert(!(h & ~((1 << 5) - 1)));
1039 assert(!(e & ~((1 << 6) - 1)));
1040 assert(!(x & ~((1 << 3) - 1)));
1041 assert(!(i & ~((1 << 1) - 1)));
1042 assert(!(r & ~((1 << 1) - 1)));
1043 e = (e >> 5) | ((e << 1) & 63);
1044 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1048 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1050 assert(!(o & ~((1 << 6) - 1)));
1051 assert(!(s & ~((1 << 5) - 1)));
1052 assert(!(a & ~((1 << 5) - 1)));
1053 assert(!(h & ~((1 << 5) - 1)));
1054 assert(!(x & ~((1 << 9) - 1)));
1055 assert(!(i & ~((1 << 1) - 1)));
1056 assert(!(r & ~((1 << 1) - 1)));
1057 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1063 * Use the sequence commented at
1064 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1067 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1070 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1072 MTCRF(128, rn(reg));
1073 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1080 _nop(jit_state_t *_jit, jit_int32_t i0)
1082 for (; i0 > 0; i0 -= 4)
1088 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1095 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1097 if (can_sign_extend_short_p(i0))
1100 if (can_sign_extend_int_p(i0))
1101 LIS(r0, (jit_int16_t)(i0 >> 16));
1102 else if (can_zero_extend_int_p(i0)) {
1103 if (i0 & 0xffff0000) {
1104 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1108 # if __WORDSIZE == 64
1110 movi(r0, (jit_uint32_t)(i0 >> 32));
1111 if (i0 & 0xffff0000) {
1113 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1121 ORI(r0, r0, (jit_uint16_t)i0);
1126 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1134 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1142 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1144 jit_word_t word = _jit->pc.w;
1145 # if __WORDSIZE == 32
1146 LIS(r0, (jit_int16_t)(i0 >> 16));
1147 ORI(r0, r0, (jit_uint16_t)i0);
1149 LIS(r0, (jit_int16_t)(i0 >> 48));
1150 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1152 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1154 ORI(r0, r0, (jit_uint16_t)i0);
1160 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1161 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1163 jit_int32_t r1_reg, iscasi;
1164 jit_word_t retry, done, jump0, jump1;
1165 if ((iscasi = (r1 == _NOREG))) {
1166 r1_reg = jit_get_reg(jit_class_gpr);
1173 # if __WORDSIZE == 32
1174 LWARX(r0, _R0_REGNO, r1);
1176 LDARX(r0, _R0_REGNO, r1);
1178 jump0 = bner(_jit->pc.w, r0, r2); /* bne done r0 r2 */
1179 # if __WORDSIZE == 32
1180 STWCX_(r3, _R0_REGNO, r1);
1182 STDCX_(r3, _R0_REGNO, r1);
1185 BNE(0); /* BNE retry */
1190 EXTRWI(r0, r0, 1, CR_EQ);
1191 patch_at(jump0, done);
1192 patch_at(jump1, retry);
1194 jit_unget_reg(r1_reg);
1198 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1200 jit_int32_t reg, addr_reg;
1202 /* Convert load followed by bswap to a single instruction */
1203 /* FIXME r0 and r1 do not need to be the same, only must check if
1204 * r1 was loaded in previous instruction */
1205 if (no_flag && r0 == r1) {
1206 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00022e | r0 << 21)) {
1207 /* Convert LHZX to LHBRX */
1209 LHBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1213 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0xa0000000 | r0 << 21)) {
1214 /* Convert LHZ to LHBRX */
1216 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1218 reg = jit_get_reg(jit_class_gpr);
1219 LI(rn(reg), (short)*_jit->pc.ui);
1220 LHBRX(r0, rn(reg), addr_reg);
1227 RLWIMI(r0, r0, 16, 8, 15);
1228 RLWINM(r0, r0, 24, 16, 31);
1230 RLWINM(r0, r1, 8, 16, 23);
1231 RLWIMI(r0, r1, 24, 24, 31);
1236 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1238 jit_int32_t reg, addr_reg;
1240 /* Convert load followed by bswap to a single instruction */
1241 /* FIXME r0 and r1 do not need to be the same, only must check if
1242 * r1 was loaded in previous instruction */
1243 if (no_flag && r0 == r1) {
1244 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00002e | r0 << 21)) {
1245 /* Convert LWZX to LWBRX */
1247 LWBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1251 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0x80000000 | r0 << 21)) {
1252 /* Convert LWZ to LWBRX */
1254 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1256 reg = jit_get_reg(jit_class_gpr);
1257 LI(rn(reg), (short)*_jit->pc.ui);
1258 LWBRX(r0, rn(reg), addr_reg);
1264 reg = jit_get_reg(jit_class_gpr);
1265 ROTLWI(rn(reg), r1, 8);
1266 RLWIMI(rn(reg), r1, 24, 0, 7);
1267 RLWIMI(rn(reg), r1, 24, 16, 23);
1268 # if __WORDSIZE == 64
1269 CLRLDI(r0, rn(reg), 32);
1277 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1280 if (can_sign_extend_short_p(i0))
1282 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1283 ADDIS(r0, r1, i0 >> 16);
1285 reg = jit_get_reg(jit_class_gpr);
1287 ADD(r0, r1, rn(reg));
1293 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1296 if (can_sign_extend_short_p(i0))
1299 reg = jit_get_reg(jit_class_gpr);
1301 ADDC(r0, r1, rn(reg));
1307 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1310 reg = jit_get_reg(jit_class_gpr);
1312 ADDE(r0, r1, rn(reg));
1317 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1320 jit_word_t ni0 = -i0;
1321 if (can_sign_extend_short_p(ni0))
1323 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1324 ADDIS(r0, r1, ni0 >> 16);
1326 reg = jit_get_reg(jit_class_gpr);
1328 SUB(r0, r1, rn(reg));
1334 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1337 reg = jit_get_reg(jit_class_gpr);
1339 SUBC(r0, r1, rn(reg));
1344 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1347 reg = jit_get_reg(jit_class_gpr);
1349 SUBE(r0, r1, rn(reg));
1354 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1361 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1364 if (can_sign_extend_short_p(i0))
1367 reg = jit_get_reg(jit_class_gpr);
1369 mulr(r0, r1, rn(reg));
1375 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1376 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1379 if (r0 == r2 || r0 == r3) {
1380 reg = jit_get_reg(jit_class_gpr);
1381 mullr(rn(reg), r2, r3);
1388 mulhr_u(r1, r2, r3);
1389 if (r0 == r2 || r0 == r3) {
1396 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1397 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1400 reg = jit_get_reg(jit_class_gpr);
1402 iqmulr(r0, r1, r2, rn(reg), sign);
1407 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1410 reg = jit_get_reg(jit_class_gpr);
1412 divr(r0, r1, rn(reg));
1417 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1420 reg = jit_get_reg(jit_class_gpr);
1422 divr_u(r0, r1, rn(reg));
1427 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1428 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1430 jit_int32_t sv0, rg0;
1431 jit_int32_t sv1, rg1;
1433 if (r0 == r2 || r0 == r3) {
1434 sv0 = jit_get_reg(jit_class_gpr);
1439 if (r1 == r2 || r1 == r3) {
1440 sv1 = jit_get_reg(jit_class_gpr);
1449 divr_u(rg0, r2, r3);
1463 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1464 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1467 reg = jit_get_reg(jit_class_gpr);
1469 iqdivr(r0, r1, r2, rn(reg), sign);
1474 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1477 if (r0 == r1 || r0 == r2) {
1478 reg = jit_get_reg(jit_class_gpr);
1479 divr(rn(reg), r1, r2);
1480 mulr(rn(reg), r2, rn(reg));
1481 subr(r0, r1, rn(reg));
1492 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1495 reg = jit_get_reg(jit_class_gpr);
1497 remr(r0, r1, rn(reg));
1502 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1505 if (r0 == r1 || r0 == r2) {
1506 reg = jit_get_reg(jit_class_gpr);
1507 divr_u(rn(reg), r1, r2);
1508 mulr(rn(reg), r2, rn(reg));
1509 subr(r0, r1, rn(reg));
1520 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1523 reg = jit_get_reg(jit_class_gpr);
1525 remr_u(r0, r1, rn(reg));
1529 # define is_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
1532 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1534 jit_int32_t reg, offt;
1535 if (can_zero_extend_short_p(i0))
1537 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1538 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1539 else if (__WORDSIZE == 32 && is_mask(i0)) {
1540 offt = __builtin_ctzl(i0);
1541 RLWINM(r0, r1, 0, 32 - offt - __builtin_popcountl(i0), 31 - offt);
1542 } else if (__WORDSIZE == 32 && is_mask(~i0)) {
1543 offt = __builtin_ctzl(~i0);
1544 RLWINM(r0, r1, 0, 32 - offt, 31 - offt - __builtin_popcountl(~i0));
1546 reg = jit_get_reg(jit_class_gpr);
1548 AND(r0, r1, rn(reg));
1554 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1557 if (can_zero_extend_short_p(i0))
1559 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1560 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1562 reg = jit_get_reg(jit_class_gpr);
1564 OR(r0, r1, rn(reg));
1570 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1573 if (can_zero_extend_short_p(i0))
1575 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1576 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1578 reg = jit_get_reg(jit_class_gpr);
1580 XOR(r0, r1, rn(reg));
1586 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1591 # if __WORDSIZE == 32
1600 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1605 # if __WORDSIZE == 32
1614 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1619 # if __WORDSIZE == 32
1628 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1632 EXTRWI(r0, r0, 1, CR_LT);
1636 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1639 if (can_sign_extend_short_p(i0))
1642 reg = jit_get_reg(jit_class_gpr);
1648 EXTRWI(r0, r0, 1, CR_LT);
1652 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1656 EXTRWI(r0, r0, 1, CR_LT);
1660 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1663 if (can_zero_extend_short_p(i0))
1666 reg = jit_get_reg(jit_class_gpr);
1672 EXTRWI(r0, r0, 1, CR_LT);
1676 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1679 CRNOT(CR_GT, CR_GT);
1681 EXTRWI(r0, r0, 1, CR_GT);
1685 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1688 if (can_sign_extend_short_p(i0))
1691 reg = jit_get_reg(jit_class_gpr);
1696 CRNOT(CR_GT, CR_GT);
1698 EXTRWI(r0, r0, 1, CR_GT);
1702 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1705 CRNOT(CR_GT, CR_GT);
1707 EXTRWI(r0, r0, 1, CR_GT);
1711 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1714 if (can_zero_extend_short_p(i0))
1717 reg = jit_get_reg(jit_class_gpr);
1722 CRNOT(CR_GT, CR_GT);
1724 EXTRWI(r0, r0, 1, CR_GT);
1728 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1732 EXTRWI(r0, r0, 1, CR_EQ);
1736 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1739 if (can_sign_extend_short_p(i0))
1741 else if (can_zero_extend_short_p(i0))
1744 reg = jit_get_reg(jit_class_gpr);
1750 EXTRWI(r0, r0, 1, CR_EQ);
1754 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1757 CRNOT(CR_LT, CR_LT);
1759 EXTRWI(r0, r0, 1, CR_LT);
1763 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1766 if (can_sign_extend_short_p(i0))
1769 reg = jit_get_reg(jit_class_gpr);
1774 CRNOT(CR_LT, CR_LT);
1776 EXTRWI(r0, r0, 1, CR_LT);
1780 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1783 CRNOT(CR_LT, CR_LT);
1785 EXTRWI(r0, r0, 1, CR_LT);
1789 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1792 if (can_zero_extend_short_p(i0))
1795 reg = jit_get_reg(jit_class_gpr);
1800 CRNOT(CR_LT, CR_LT);
1802 EXTRWI(r0, r0, 1, CR_LT);
1806 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1810 EXTRWI(r0, r0, 1, CR_GT);
1814 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1817 if (can_sign_extend_short_p(i0))
1820 reg = jit_get_reg(jit_class_gpr);
1826 EXTRWI(r0, r0, 1, CR_GT);
1830 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1834 EXTRWI(r0, r0, 1, CR_GT);
1838 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1841 if (can_zero_extend_short_p(i0))
1844 reg = jit_get_reg(jit_class_gpr);
1850 EXTRWI(r0, r0, 1, CR_GT);
1854 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1857 CRNOT(CR_EQ, CR_EQ);
1859 EXTRWI(r0, r0, 1, CR_EQ);
1863 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1866 if (can_sign_extend_short_p(i0))
1868 else if (can_zero_extend_short_p(i0))
1871 reg = jit_get_reg(jit_class_gpr);
1876 CRNOT(CR_EQ, CR_EQ);
1878 EXTRWI(r0, r0, 1, CR_EQ);
1882 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1893 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1897 if (can_sign_extend_short_p(i1))
1900 reg = jit_get_reg(jit_class_gpr);
1912 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1923 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1927 if (can_zero_extend_short_p(i1))
1930 reg = jit_get_reg(jit_class_gpr);
1942 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1953 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1957 if (can_sign_extend_short_p(i1))
1960 reg = jit_get_reg(jit_class_gpr);
1972 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1983 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1987 if (can_zero_extend_short_p(i1))
1990 reg = jit_get_reg(jit_class_gpr);
2002 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2013 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2017 if (can_sign_extend_short_p(i1))
2019 else if (can_zero_extend_short_p(i1))
2022 reg = jit_get_reg(jit_class_gpr);
2034 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2045 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2049 if (can_sign_extend_short_p(i1))
2052 reg = jit_get_reg(jit_class_gpr);
2064 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2075 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2079 if (can_zero_extend_short_p(i1))
2082 reg = jit_get_reg(jit_class_gpr);
2094 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2105 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2109 if (can_sign_extend_short_p(i1))
2112 reg = jit_get_reg(jit_class_gpr);
2124 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2135 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2139 if (can_zero_extend_short_p(i1))
2142 reg = jit_get_reg(jit_class_gpr);
2154 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2165 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2169 if (can_sign_extend_short_p(i1))
2171 else if (can_zero_extend_short_p(i1))
2174 reg = jit_get_reg(jit_class_gpr);
2186 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2190 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2191 andr(rn(reg), r0, r1);
2192 w = bnei(i0, rn(reg), 0);
2198 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2202 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2203 andi(rn(reg), r0, i1);
2204 w = bnei(i0, rn(reg), 0);
2210 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2214 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2215 andr(rn(reg), r0, r1);
2216 w = beqi(i0, rn(reg), 0);
2222 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2226 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2227 andi(rn(reg), r0, i1);
2228 w = beqi(i0, rn(reg), 0);
2234 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2241 BGT(d); /* GT = bit 1 of XER = OV */
2246 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2250 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2252 w = boaddr(i0, r0, rn(reg));
2258 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2270 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2274 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2276 w = bxaddr(i0, r0, rn(reg));
2282 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2294 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2298 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2300 w = bosubr(i0, r0, rn(reg));
2306 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2318 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2322 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2324 w = bxsubr(i0, r0, rn(reg));
2330 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2337 BEQ(d); /* EQ = bit 2 of XER = CA */
2342 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2346 if (can_sign_extend_short_p(i1)) {
2354 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2356 w = boaddr_u(i0, r0, rn(reg));
2362 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2374 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2378 if (can_sign_extend_short_p(i1)) {
2386 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2388 w = bxaddr_u(i0, r0, rn(reg));
2394 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2401 BNE(d); /* PPC uses "carry" not "borrow" */
2406 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2410 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2412 w = bosubr_u(i0, r0, rn(reg));
2418 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2430 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2434 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2436 w = bxsubr_u(i0, r0, rn(reg));
2442 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2449 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2456 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2458 ldxr_uc(r0, r1, r2);
2463 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2465 ldxi_uc(r0, r1, i0);
2470 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2475 if (can_sign_extend_short_p(i0))
2476 LBZ(r0, _R0_REGNO, i0);
2477 else if (can_sign_extend_int_p(i0)) {
2478 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2479 lo = (jit_int16_t)(i0 - (hi << 16));
2480 reg = jit_get_reg(jit_class_gpr);
2481 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2483 LBZ(r0, rn(reg), lo);
2485 if (inv) jit_unget_reg(_R0);
2488 reg = jit_get_reg(jit_class_gpr);
2490 ldr_uc(r0, rn(reg));
2496 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2499 if (r1 == _R0_REGNO) {
2500 if (r2 != _R0_REGNO)
2503 reg = jit_get_reg(jit_class_gpr);
2505 LBZX(r0, rn(reg), r2);
2514 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2519 else if (can_sign_extend_short_p(i0)) {
2520 if (r1 == _R0_REGNO) {
2521 reg = jit_get_reg(jit_class_gpr);
2523 LBZ(r0, rn(reg), i0);
2530 reg = jit_get_reg(jit_class_gpr);
2532 ldxr_uc(r0, r1, rn(reg));
2538 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2543 if (can_sign_extend_short_p(i0))
2544 LHA(r0, _R0_REGNO, i0);
2545 else if (can_sign_extend_int_p(i0)) {
2546 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2547 lo = (jit_int16_t)(i0 - (hi << 16));
2548 reg = jit_get_reg(jit_class_gpr);
2549 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2551 LHA(r0, rn(reg), lo);
2553 if (inv) jit_unget_reg(_R0);
2556 reg = jit_get_reg(jit_class_gpr);
2564 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2567 if (r1 == _R0_REGNO) {
2568 if (r2 != _R0_REGNO)
2571 reg = jit_get_reg(jit_class_gpr);
2573 LHAX(r0, rn(reg), r2);
2582 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2587 else if (can_sign_extend_short_p(i0)) {
2588 if (r1 == _R0_REGNO) {
2589 reg = jit_get_reg(jit_class_gpr);
2591 LHA(r0, rn(reg), i0);
2598 reg = jit_get_reg(jit_class_gpr);
2600 ldxr_s(r0, r1, rn(reg));
2606 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2611 if (can_sign_extend_short_p(i0))
2612 LHZ(r0, _R0_REGNO, i0);
2613 else if (can_sign_extend_int_p(i0)) {
2614 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2615 lo = (jit_int16_t)(i0 - (hi << 16));
2616 reg = jit_get_reg(jit_class_gpr);
2617 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2619 LHZ(r0, rn(reg), lo);
2621 if (inv) jit_unget_reg(_R0);
2624 reg = jit_get_reg(jit_class_gpr);
2626 ldr_us(r0, rn(reg));
2632 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2635 if (r1 == _R0_REGNO) {
2636 if (r2 != _R0_REGNO)
2639 reg = jit_get_reg(jit_class_gpr);
2641 LHZX(r0, rn(reg), r2);
2650 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2655 else if (can_sign_extend_short_p(i0)) {
2656 if (r1 == _R0_REGNO) {
2657 reg = jit_get_reg(jit_class_gpr);
2659 LHZ(r0, rn(reg), i0);
2666 reg = jit_get_reg(jit_class_gpr);
2668 ldxr_us(r0, r1, rn(reg));
2673 # if __WORDSIZE == 32
2675 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2680 if (can_sign_extend_short_p(i0))
2681 LWZ(r0, _R0_REGNO, i0);
2682 else if (can_sign_extend_int_p(i0)) {
2683 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2684 lo = (jit_int16_t)(i0 - (hi << 16));
2685 reg = jit_get_reg(jit_class_gpr);
2686 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2688 LWZ(r0, rn(reg), lo);
2690 if (inv) jit_unget_reg(_R0);
2693 reg = jit_get_reg(jit_class_gpr);
2701 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2704 if (r1 == _R0_REGNO) {
2705 if (r2 != _R0_REGNO)
2708 reg = jit_get_reg(jit_class_gpr);
2710 LWZX(r0, rn(reg), r2);
2719 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2724 else if (can_sign_extend_short_p(i0)) {
2725 if (r1 == _R0_REGNO) {
2726 reg = jit_get_reg(jit_class_gpr);
2728 LWZ(r0, rn(reg), i0);
2735 reg = jit_get_reg(jit_class_gpr);
2737 ldxr_i(r0, r1, rn(reg));
2744 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2749 if (can_sign_extend_short_p(i0))
2750 LWA(r0, _R0_REGNO, i0);
2751 else if (can_sign_extend_int_p(i0)) {
2752 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2753 lo = (jit_int16_t)(i0 - (hi << 16));
2754 reg = jit_get_reg(jit_class_gpr);
2755 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2757 LWA(r0, rn(reg), lo);
2759 if (inv) jit_unget_reg(_R0);
2762 reg = jit_get_reg(jit_class_gpr);
2770 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2773 if (r1 == _R0_REGNO) {
2774 if (r2 != _R0_REGNO)
2777 reg = jit_get_reg(jit_class_gpr);
2779 LWAX(r0, rn(reg), r2);
2788 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2793 else if (can_sign_extend_short_p(i0)) {
2794 if (r1 == _R0_REGNO) {
2795 reg = jit_get_reg(jit_class_gpr);
2797 LWA(r0, rn(reg), i0);
2804 reg = jit_get_reg(jit_class_gpr);
2806 ldxr_i(r0, r1, rn(reg));
2812 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2817 if (can_sign_extend_short_p(i0))
2818 LWZ(r0, _R0_REGNO, i0);
2819 else if (can_sign_extend_int_p(i0)) {
2820 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2821 lo = (jit_int16_t)(i0 - (hi << 16));
2822 reg = jit_get_reg(jit_class_gpr);
2823 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2825 LWZ(r0, rn(reg), lo);
2827 if (inv) jit_unget_reg(_R0);
2830 reg = jit_get_reg(jit_class_gpr);
2832 ldr_ui(r0, rn(reg));
2838 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2841 if (r1 == _R0_REGNO) {
2842 if (r2 != _R0_REGNO)
2845 reg = jit_get_reg(jit_class_gpr);
2847 LWZX(r0, rn(reg), r2);
2856 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2861 else if (can_sign_extend_short_p(i0)) {
2862 if (r1 == _R0_REGNO) {
2863 reg = jit_get_reg(jit_class_gpr);
2865 LWZ(r0, rn(reg), i0);
2872 reg = jit_get_reg(jit_class_gpr);
2874 ldxr_ui(r0, r1, rn(reg));
2880 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2885 if (can_sign_extend_short_p(i0))
2886 LD(r0, _R0_REGNO, i0);
2887 else if (can_sign_extend_int_p(i0)) {
2888 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2889 lo = (jit_int16_t)(i0 - (hi << 16));
2890 reg = jit_get_reg(jit_class_gpr);
2891 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2893 LD(r0, rn(reg), lo);
2895 if (inv) jit_unget_reg(_R0);
2898 reg = jit_get_reg(jit_class_gpr);
2906 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2909 if (r1 == _R0_REGNO) {
2910 if (r2 != _R0_REGNO)
2913 reg = jit_get_reg(jit_class_gpr);
2915 LDX(r0, rn(reg), r2);
2924 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2929 else if (can_sign_extend_short_p(i0)) {
2930 if (r1 == _R0_REGNO) {
2931 reg = jit_get_reg(jit_class_gpr);
2933 LD(r0, rn(reg), i0);
2940 reg = jit_get_reg(jit_class_gpr);
2942 ldxr_l(r0, r1, rn(reg));
2949 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2954 if (can_sign_extend_short_p(i0))
2955 STB(r0, _R0_REGNO, i0);
2956 else if (can_sign_extend_int_p(i0)) {
2957 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2958 lo = (jit_int16_t)(i0 - (hi << 16));
2959 reg = jit_get_reg(jit_class_gpr);
2960 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2962 STB(r0, rn(reg), lo);
2964 if (inv) jit_unget_reg(_R0);
2967 reg = jit_get_reg(jit_class_gpr);
2975 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2978 if (r0 == _R0_REGNO) {
2979 if (r1 != _R0_REGNO)
2982 reg = jit_get_reg(jit_class_gpr);
2984 STBX(r2, rn(reg), r1);
2993 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2998 else if (can_sign_extend_short_p(i0)) {
2999 if (r0 == _R0_REGNO) {
3000 reg = jit_get_reg(jit_class_gpr);
3002 STB(r1, rn(reg), i0);
3009 reg = jit_get_reg(jit_class_gpr);
3011 stxr_c(rn(reg), r0, r1);
3017 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3022 if (can_sign_extend_short_p(i0))
3023 STH(r0, _R0_REGNO, i0);
3024 else if (can_sign_extend_int_p(i0)) {
3025 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3026 lo = (jit_int16_t)(i0 - (hi << 16));
3027 reg = jit_get_reg(jit_class_gpr);
3028 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3030 STH(r0, rn(reg), lo);
3032 if (inv) jit_unget_reg(_R0);
3035 reg = jit_get_reg(jit_class_gpr);
3043 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3046 if (r0 == _R0_REGNO) {
3047 if (r1 != _R0_REGNO)
3050 reg = jit_get_reg(jit_class_gpr);
3052 STHX(r2, rn(reg), r1);
3061 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3066 else if (can_sign_extend_short_p(i0)) {
3067 if (r0 == _R0_REGNO) {
3068 reg = jit_get_reg(jit_class_gpr);
3070 STH(r1, rn(reg), i0);
3077 reg = jit_get_reg(jit_class_gpr);
3079 stxr_s(rn(reg), r0, r1);
3085 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3090 if (can_sign_extend_short_p(i0))
3091 STW(r0, _R0_REGNO, i0);
3092 else if (can_sign_extend_int_p(i0)) {
3093 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3094 lo = (jit_int16_t)(i0 - (hi << 16));
3095 reg = jit_get_reg(jit_class_gpr);
3096 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3098 STW(r0, rn(reg), lo);
3100 if (inv) jit_unget_reg(_R0);
3103 reg = jit_get_reg(jit_class_gpr);
3111 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3114 if (r0 == _R0_REGNO) {
3115 if (r1 != _R0_REGNO)
3118 reg = jit_get_reg(jit_class_gpr);
3120 STWX(r2, rn(reg), r1);
3129 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3134 else if (can_sign_extend_short_p(i0)) {
3135 if (r0 == _R0_REGNO) {
3136 reg = jit_get_reg(jit_class_gpr);
3138 STW(r1, rn(reg), i0);
3145 reg = jit_get_reg(jit_class_gpr);
3147 stxr_i(rn(reg), r0, r1);
3152 # if __WORDSIZE == 64
3154 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3159 if (can_sign_extend_short_p(i0))
3160 STD(r0, _R0_REGNO, i0);
3161 else if (can_sign_extend_int_p(i0)) {
3162 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3163 lo = (jit_int16_t)(i0 - (hi << 16));
3164 reg = jit_get_reg(jit_class_gpr);
3165 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3167 STD(r0, rn(reg), lo);
3169 if (inv) jit_unget_reg(_R0);
3172 reg = jit_get_reg(jit_class_gpr);
3180 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3183 if (r0 == _R0_REGNO) {
3184 if (r1 != _R0_REGNO)
3187 reg = jit_get_reg(jit_class_gpr);
3189 STDX(r2, rn(reg), r1);
3198 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3203 else if (can_sign_extend_short_p(i0)) {
3204 if (r0 == _R0_REGNO) {
3205 reg = jit_get_reg(jit_class_gpr);
3207 STD(r1, rn(reg), i0);
3214 reg = jit_get_reg(jit_class_gpr);
3216 stxr_l(rn(reg), r0, r1);
3223 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3234 /* pc relative jump */
3236 _jmpi(jit_state_t *_jit, jit_word_t i0)
3242 if (can_sign_extend_jump_p(d))
3245 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3246 w = movi_p(rn(reg), i0);
3255 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3259 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3260 w = movi_p(rn(reg), i0);
3267 _callr(jit_state_t *_jit, jit_int32_t r0
3269 , jit_int32_t varargs
3274 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3275 /* FIXME Pretend to not know about r11? */
3276 if (r0 == _R0_REGNO) {
3277 movr(_R11_REGNO, _R0_REGNO);
3278 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3279 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3282 ldxi(_R2_REGNO, r0, sizeof(void*));
3283 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3288 /* Tell double arguments were passed in registers. */
3292 movr(_R12_REGNO, r0);
3299 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3303 /* assume fixed address or reachable address */
3305 _calli(jit_state_t *_jit, jit_word_t i0
3307 , jit_int32_t varargs
3313 d = (i0 - _jit->pc.w - !!varargs * 4) & ~3;
3314 if (can_sign_extend_jump_p(d)) {
3315 /* Tell double arguments were passed in registers. */
3322 movi(_R12_REGNO, i0);
3333 _calli_p(jit_state_t *_jit, jit_word_t i0
3335 , jit_int32_t varargs
3340 w = movi_p(_R12_REGNO, i0);
3349 /* order is not guaranteed to be sequential */
3350 static jit_int32_t save[] = {
3351 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3352 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3356 _prolog(jit_state_t *_jit, jit_node_t *node)
3358 unsigned long regno;
3361 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3362 jit_int32_t frame = -_jitc->function->frame;
3363 assert(_jitc->function->self.aoff >= frame);
3364 if (_jitc->function->assume_frame)
3366 _jitc->function->self.aoff = frame;
3368 if (_jitc->function->allocar) {
3369 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3370 _jitc->function->self.aoff &= -16;
3372 _jitc->function->stack = ((_jitc->function->self.alen +
3373 _jitc->function->self.size -
3374 _jitc->function->self.aoff) + 15) & -16;
3376 /* return address */
3379 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3380 * alloca < %r31-80 */
3383 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3385 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3387 offset = -gpr_save_area;
3388 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3389 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3390 stxi(offset, _SP_REGNO, rn(save[regno]));
3392 for (offset = 0; offset < 8; offset++) {
3393 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3394 stxi_d(-(gpr_save_area + 8 + offset * 8),
3395 _SP_REGNO, rn(_F14 + offset));
3398 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3400 movr(_FP_REGNO, _SP_REGNO);
3401 #if __WORDSIZE == 32
3402 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3404 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3407 if (_jitc->function->allocar) {
3408 regno = jit_get_reg(jit_class_gpr);
3409 movi(rn(regno), _jitc->function->self.aoff);
3410 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3411 jit_unget_reg(regno);
3415 if (_jitc->function->self.call & jit_call_varargs) {
3416 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3417 stxi(params_offset + regno * sizeof(jit_word_t),
3418 _FP_REGNO, rn(JIT_RA0 - regno));
3421 if (_jitc->function->self.call & jit_call_varargs) {
3422 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3423 stxi(_jitc->function->vaoff + first_gp_offset +
3424 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3425 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3426 stxi_d(_jitc->function->vaoff + first_fp_offset +
3427 regno * va_fp_increment, _FP_REGNO,
3428 rn(JIT_FA0 - regno));
3434 _epilog(jit_state_t *_jit, jit_node_t *node)
3436 unsigned long regno;
3439 if (_jitc->function->assume_frame)
3441 if (_jitc->function->allocar)
3442 ldr(_SP_REGNO, _SP_REGNO);
3444 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3446 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3448 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3450 offset = -gpr_save_area;
3451 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3452 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3453 ldxi(rn(save[regno]), _SP_REGNO, offset);
3455 for (offset = 0; offset < 8; offset++) {
3456 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3457 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3458 -(gpr_save_area + 8 + offset * 8));
3462 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3468 _vastart(jit_state_t *_jit, jit_int32_t r0)
3471 assert(_jitc->function->self.call & jit_call_varargs);
3472 /* Initialize stack pointer to the first stack argument. */
3473 addi(r0, _FP_REGNO, _jitc->function->self.size);
3476 assert(_jitc->function->self.call & jit_call_varargs);
3478 /* Return jit_va_list_t in the register argument */
3479 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3480 reg = jit_get_reg(jit_class_gpr);
3482 /* Initialize the gp counter. */
3483 movi(rn(reg), _jitc->function->vagp);
3484 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3486 /* Initialize the fp counter. */
3487 movi(rn(reg), _jitc->function->vafp);
3488 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3490 /* Initialize overflow pointer to the first stack argument. */
3491 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3492 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3494 /* Initialize register save area pointer. */
3495 addi(rn(reg), r0, first_gp_offset);
3496 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3503 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3506 assert(_jitc->function->self.call & jit_call_varargs);
3507 /* Load argument. */
3509 /* Update va_list. */
3510 addi(r1, r1, sizeof(jit_word_t));
3517 assert(_jitc->function->self.call & jit_call_varargs);
3519 rg0 = jit_get_reg(jit_class_gpr);
3520 rg1 = jit_get_reg(jit_class_gpr);
3522 /* Load the gp offset in save area in the first temporary. */
3523 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3525 /* Jump over if there are no remaining arguments in the save area. */
3526 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3528 /* Update the gp counter. */
3529 addi(rn(rg1), rn(rg0), 1);
3530 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3532 /* Load the save area pointer in the second temporary. */
3533 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3535 /* Load the vararg argument in the first argument. */
3536 lshi(rn(rg0), rn(rg0), va_gp_shift);
3537 ldxr(r0, rn(rg1), rn(rg0));
3539 /* Will only need one temporary register below. */
3542 /* Jump over overflow code. */
3543 lt_code = _jit->pc.w;
3546 /* Where to land if argument is in overflow area. */
3547 patch_at(ge_code, _jit->pc.w);
3549 /* Load overflow pointer. */
3550 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3552 /* Load argument. */
3555 /* Update overflow pointer. */
3556 addi(rn(rg0), rn(rg0), va_gp_increment);
3557 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3559 /* Where to land if argument is in save area. */
3560 patch_at(lt_code, _jit->pc.w);
3567 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3570 assert(_jitc->function->self.call & jit_call_varargs);
3571 /* Load argument. */
3573 /* Update va_list. */
3574 addi(r1, r1, sizeof(jit_float64_t));
3581 assert(_jitc->function->self.call & jit_call_varargs);
3583 rg0 = jit_get_reg(jit_class_gpr);
3584 rg1 = jit_get_reg(jit_class_gpr);
3586 /* Load the fp offset in save area in the first temporary. */
3587 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3589 /* Jump over if there are no remaining arguments in the save area. */
3590 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3592 /* Update the fp counter. */
3593 addi(rn(rg1), rn(rg0), 1);
3594 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3596 /* Load the save area pointer in the second temporary. */
3597 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3599 /* Load the vararg argument in the first argument. */
3600 lshi(rn(rg0), rn(rg0), 3);
3601 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3602 offsetof(jit_va_list_t, first_gp_argument));
3603 ldxr_d(r0, rn(rg1), rn(rg0));
3605 /* Jump over overflow code. */
3606 lt_code = _jit->pc.w;
3609 /* Where to land if argument is in overflow area. */
3610 patch_at(ge_code, _jit->pc.w);
3612 /* Load overflow pointer. */
3613 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3615 # if __WORDSIZE == 32
3616 /* Align if required. */
3617 andi(rn(rg1), rn(rg0), 7);
3618 addr(rn(rg0), rn(rg0), rn(rg1));
3621 /* Load argument. */
3624 /* Update overflow pointer. */
3625 addi(rn(rg0), rn(rg0), va_fp_increment);
3626 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3628 /* Where to land if argument is in save area. */
3629 patch_at(lt_code, _jit->pc.w);
3637 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3645 switch ((u.i[0] & 0xfc000000) >> 26) {
3649 if (!can_sign_extend_short_p(d)) {
3650 /* use absolute address */
3651 assert(can_sign_extend_short_p(label));
3654 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3658 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3659 /* zero is used for toc and env, so, quick check
3660 * if this is a "jmpi main" like initial jit
3662 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3663 for (d = 0; d < _jitc->prolog.offset; d++) {
3664 /* not so pretty, but hides powerpc
3665 * specific abi intrinsics and/or
3666 * implementation from user */
3667 if (_jitc->prolog.ptr[d] == label) {
3668 label += sizeof(void*) * 3;
3677 if (!can_sign_extend_jump_p(d)) {
3678 /* use absolute address */
3679 assert(can_sign_extend_jump_p(label));
3682 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3685 #if __WORDSIZE == 32
3686 # define MTCTR_OFF 2
3689 # define MTCTR_OFF 6
3693 /* movi reg label; jmpr reg */
3696 /* check for MLTR(reg) */
3697 (u.i[MTCTR_OFF] >> 26) == 31 &&
3698 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3699 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3701 u.i[BCTR_OFF] == 0x4e800020) {
3703 /* check for MTCTR(reg) */
3704 (u.i[MTCTR_OFF] >> 26) == 31 &&
3705 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3706 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3707 /* check for BCTR */
3708 u.i[BCTR_OFF] == 0x4e800420) {
3710 /* zero is used for toc and env, so, quick check
3711 * if this is a "jmpi main" like initial jit
3713 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3714 for (d = 0; d < _jitc->prolog.offset; d++) {
3715 /* not so pretty, but hides powerpc
3716 * specific abi intrinsics and/or
3717 * implementation from user */
3718 if (_jitc->prolog.ptr[d] == label) {
3719 label += sizeof(void*) * 3;
3728 #if __WORDSIZE == 32
3729 assert(!(u.i[0] & 0x1f0000));
3730 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3731 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3732 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3733 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3735 assert(!(u.i[0] & 0x1f0000));
3736 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3737 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3738 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3739 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3740 /* not fully validating SLDI */
3741 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3742 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3743 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3744 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3745 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3746 /* not fully validating SLDI */
3747 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3748 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3749 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3750 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3751 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3755 assert(!"unhandled branch opcode");