2 * Copyright (C) 2012-2019 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);
1184 jump1 = bnei(_jit->pc.w, r0, 0); /* bne retry r0 0 */
1189 patch_at(jump0, done);
1190 patch_at(jump1, retry);
1192 jit_unget_reg(r1_reg);
1196 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1198 jit_int32_t reg, addr_reg;
1200 /* Convert load followed by bswap to a single instruction */
1201 /* FIXME r0 and r1 do not need to be the same, only must check if
1202 * r1 was loaded in previous instruction */
1203 if (no_flag && r0 == r1) {
1204 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00022e | r0 << 21)) {
1205 /* Convert LHZX to LHBRX */
1207 LHBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1211 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0xa0000000 | r0 << 21)) {
1212 /* Convert LHZ to LHBRX */
1214 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1216 reg = jit_get_reg(jit_class_gpr);
1217 LI(rn(reg), (short)*_jit->pc.ui);
1218 LHBRX(r0, rn(reg), addr_reg);
1225 RLWIMI(r0, r0, 16, 8, 15);
1226 RLWINM(r0, r0, 24, 16, 31);
1228 RLWINM(r0, r1, 8, 16, 23);
1229 RLWIMI(r0, r1, 24, 24, 31);
1234 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1236 jit_int32_t reg, addr_reg;
1238 /* Convert load followed by bswap to a single instruction */
1239 /* FIXME r0 and r1 do not need to be the same, only must check if
1240 * r1 was loaded in previous instruction */
1241 if (no_flag && r0 == r1) {
1242 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00002e | r0 << 21)) {
1243 /* Convert LWZX to LWBRX */
1245 LWBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1249 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0x80000000 | r0 << 21)) {
1250 /* Convert LWZ to LWBRX */
1252 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1254 reg = jit_get_reg(jit_class_gpr);
1255 LI(rn(reg), (short)*_jit->pc.ui);
1256 LWBRX(r0, rn(reg), addr_reg);
1262 reg = jit_get_reg(jit_class_gpr);
1263 ROTLWI(rn(reg), r1, 8);
1264 RLWIMI(rn(reg), r1, 24, 0, 7);
1265 RLWIMI(rn(reg), r1, 24, 16, 23);
1266 # if __WORDSIZE == 64
1267 CLRLDI(r0, rn(reg), 32);
1275 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1278 if (can_sign_extend_short_p(i0))
1280 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1281 ADDIS(r0, r1, i0 >> 16);
1283 reg = jit_get_reg(jit_class_gpr);
1285 ADD(r0, r1, rn(reg));
1291 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1294 if (can_sign_extend_short_p(i0))
1297 reg = jit_get_reg(jit_class_gpr);
1299 ADDC(r0, r1, rn(reg));
1305 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1308 reg = jit_get_reg(jit_class_gpr);
1310 ADDE(r0, r1, rn(reg));
1315 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1318 jit_word_t ni0 = -i0;
1319 if (can_sign_extend_short_p(ni0))
1321 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1322 ADDIS(r0, r1, ni0 >> 16);
1324 reg = jit_get_reg(jit_class_gpr);
1326 SUB(r0, r1, rn(reg));
1332 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1335 reg = jit_get_reg(jit_class_gpr);
1337 SUBC(r0, r1, rn(reg));
1342 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1345 reg = jit_get_reg(jit_class_gpr);
1347 SUBE(r0, r1, rn(reg));
1352 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1359 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1362 if (can_sign_extend_short_p(i0))
1365 reg = jit_get_reg(jit_class_gpr);
1367 mulr(r0, r1, rn(reg));
1373 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1374 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1377 if (r0 == r2 || r0 == r3) {
1378 reg = jit_get_reg(jit_class_gpr);
1379 mullr(rn(reg), r2, r3);
1386 mulhr_u(r1, r2, r3);
1387 if (r0 == r2 || r0 == r3) {
1394 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1395 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1398 reg = jit_get_reg(jit_class_gpr);
1400 iqmulr(r0, r1, r2, rn(reg), sign);
1405 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1408 reg = jit_get_reg(jit_class_gpr);
1410 divr(r0, r1, rn(reg));
1415 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1418 reg = jit_get_reg(jit_class_gpr);
1420 divr_u(r0, r1, rn(reg));
1425 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1426 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1428 jit_int32_t sv0, rg0;
1429 jit_int32_t sv1, rg1;
1431 if (r0 == r2 || r0 == r3) {
1432 sv0 = jit_get_reg(jit_class_gpr);
1437 if (r1 == r2 || r1 == r3) {
1438 sv1 = jit_get_reg(jit_class_gpr);
1447 divr_u(rg0, r2, r3);
1461 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1462 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1465 reg = jit_get_reg(jit_class_gpr);
1467 iqdivr(r0, r1, r2, rn(reg), sign);
1472 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1475 if (r0 == r1 || r0 == r2) {
1476 reg = jit_get_reg(jit_class_gpr);
1477 divr(rn(reg), r1, r2);
1478 mulr(rn(reg), r2, rn(reg));
1479 subr(r0, r1, rn(reg));
1490 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1493 reg = jit_get_reg(jit_class_gpr);
1495 remr(r0, r1, rn(reg));
1500 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1503 if (r0 == r1 || r0 == r2) {
1504 reg = jit_get_reg(jit_class_gpr);
1505 divr_u(rn(reg), r1, r2);
1506 mulr(rn(reg), r2, rn(reg));
1507 subr(r0, r1, rn(reg));
1518 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1521 reg = jit_get_reg(jit_class_gpr);
1523 remr_u(r0, r1, rn(reg));
1527 # define is_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
1530 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1532 jit_int32_t reg, offt;
1533 if (can_zero_extend_short_p(i0))
1535 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1536 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1537 else if (__WORDSIZE == 32 && is_mask(i0)) {
1538 offt = __builtin_ctzl(i0);
1539 RLWINM(r0, r1, 0, 32 - offt - __builtin_popcountl(i0), 31 - offt);
1540 } else if (__WORDSIZE == 32 && is_mask(~i0)) {
1541 offt = __builtin_ctzl(~i0);
1542 RLWINM(r0, r1, 0, 32 - offt, 31 - offt - __builtin_popcountl(~i0));
1544 reg = jit_get_reg(jit_class_gpr);
1546 AND(r0, r1, rn(reg));
1552 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1555 if (can_zero_extend_short_p(i0))
1557 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1558 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1560 reg = jit_get_reg(jit_class_gpr);
1562 OR(r0, r1, rn(reg));
1568 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1571 if (can_zero_extend_short_p(i0))
1573 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1574 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1576 reg = jit_get_reg(jit_class_gpr);
1578 XOR(r0, r1, rn(reg));
1584 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1589 # if __WORDSIZE == 32
1598 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1603 # if __WORDSIZE == 32
1612 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1617 # if __WORDSIZE == 32
1626 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1630 EXTRWI(r0, r0, 1, CR_LT);
1634 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1637 if (can_sign_extend_short_p(i0))
1640 reg = jit_get_reg(jit_class_gpr);
1646 EXTRWI(r0, r0, 1, CR_LT);
1650 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1654 EXTRWI(r0, r0, 1, CR_LT);
1658 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1661 if (can_zero_extend_short_p(i0))
1664 reg = jit_get_reg(jit_class_gpr);
1670 EXTRWI(r0, r0, 1, CR_LT);
1674 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1677 CRNOT(CR_GT, CR_GT);
1679 EXTRWI(r0, r0, 1, CR_GT);
1683 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1686 if (can_sign_extend_short_p(i0))
1689 reg = jit_get_reg(jit_class_gpr);
1694 CRNOT(CR_GT, CR_GT);
1696 EXTRWI(r0, r0, 1, CR_GT);
1700 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1703 CRNOT(CR_GT, CR_GT);
1705 EXTRWI(r0, r0, 1, CR_GT);
1709 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1712 if (can_zero_extend_short_p(i0))
1715 reg = jit_get_reg(jit_class_gpr);
1720 CRNOT(CR_GT, CR_GT);
1722 EXTRWI(r0, r0, 1, CR_GT);
1726 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1730 EXTRWI(r0, r0, 1, CR_EQ);
1734 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1737 if (can_sign_extend_short_p(i0))
1739 else if (can_zero_extend_short_p(i0))
1742 reg = jit_get_reg(jit_class_gpr);
1748 EXTRWI(r0, r0, 1, CR_EQ);
1752 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1755 CRNOT(CR_LT, CR_LT);
1757 EXTRWI(r0, r0, 1, CR_LT);
1761 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1764 if (can_sign_extend_short_p(i0))
1767 reg = jit_get_reg(jit_class_gpr);
1772 CRNOT(CR_LT, CR_LT);
1774 EXTRWI(r0, r0, 1, CR_LT);
1778 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1781 CRNOT(CR_LT, CR_LT);
1783 EXTRWI(r0, r0, 1, CR_LT);
1787 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1790 if (can_zero_extend_short_p(i0))
1793 reg = jit_get_reg(jit_class_gpr);
1798 CRNOT(CR_LT, CR_LT);
1800 EXTRWI(r0, r0, 1, CR_LT);
1804 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1808 EXTRWI(r0, r0, 1, CR_GT);
1812 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1815 if (can_sign_extend_short_p(i0))
1818 reg = jit_get_reg(jit_class_gpr);
1824 EXTRWI(r0, r0, 1, CR_GT);
1828 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1832 EXTRWI(r0, r0, 1, CR_GT);
1836 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1839 if (can_zero_extend_short_p(i0))
1842 reg = jit_get_reg(jit_class_gpr);
1848 EXTRWI(r0, r0, 1, CR_GT);
1852 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1855 CRNOT(CR_EQ, CR_EQ);
1857 EXTRWI(r0, r0, 1, CR_EQ);
1861 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1864 if (can_sign_extend_short_p(i0))
1866 else if (can_zero_extend_short_p(i0))
1869 reg = jit_get_reg(jit_class_gpr);
1874 CRNOT(CR_EQ, CR_EQ);
1876 EXTRWI(r0, r0, 1, CR_EQ);
1880 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1891 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1895 if (can_sign_extend_short_p(i1))
1898 reg = jit_get_reg(jit_class_gpr);
1910 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1921 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1925 if (can_zero_extend_short_p(i1))
1928 reg = jit_get_reg(jit_class_gpr);
1940 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1951 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1955 if (can_sign_extend_short_p(i1))
1958 reg = jit_get_reg(jit_class_gpr);
1970 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1981 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1985 if (can_zero_extend_short_p(i1))
1988 reg = jit_get_reg(jit_class_gpr);
2000 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2011 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2015 if (can_sign_extend_short_p(i1))
2017 else if (can_zero_extend_short_p(i1))
2020 reg = jit_get_reg(jit_class_gpr);
2032 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2043 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2047 if (can_sign_extend_short_p(i1))
2050 reg = jit_get_reg(jit_class_gpr);
2062 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2073 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2077 if (can_zero_extend_short_p(i1))
2080 reg = jit_get_reg(jit_class_gpr);
2092 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2103 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2107 if (can_sign_extend_short_p(i1))
2110 reg = jit_get_reg(jit_class_gpr);
2122 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2133 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2137 if (can_zero_extend_short_p(i1))
2140 reg = jit_get_reg(jit_class_gpr);
2152 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2163 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2167 if (can_sign_extend_short_p(i1))
2169 else if (can_zero_extend_short_p(i1))
2172 reg = jit_get_reg(jit_class_gpr);
2184 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2188 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2189 andr(rn(reg), r0, r1);
2190 w = bnei(i0, rn(reg), 0);
2196 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2200 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2201 andi(rn(reg), r0, i1);
2202 w = bnei(i0, rn(reg), 0);
2208 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2212 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2213 andr(rn(reg), r0, r1);
2214 w = beqi(i0, rn(reg), 0);
2220 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2224 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2225 andi(rn(reg), r0, i1);
2226 w = beqi(i0, rn(reg), 0);
2232 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2239 BGT(d); /* GT = bit 1 of XER = OV */
2244 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2248 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2250 w = boaddr(i0, r0, rn(reg));
2256 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2268 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2272 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2274 w = bxaddr(i0, r0, rn(reg));
2280 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2292 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2296 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2298 w = bosubr(i0, r0, rn(reg));
2304 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2316 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2320 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2322 w = bxsubr(i0, r0, rn(reg));
2328 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2335 BEQ(d); /* EQ = bit 2 of XER = CA */
2340 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2344 if (can_sign_extend_short_p(i1)) {
2352 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2354 w = boaddr_u(i0, r0, rn(reg));
2360 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2372 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2376 if (can_sign_extend_short_p(i1)) {
2384 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2386 w = bxaddr_u(i0, r0, rn(reg));
2392 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2399 BNE(d); /* PPC uses "carry" not "borrow" */
2404 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2408 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2410 w = bosubr_u(i0, r0, rn(reg));
2416 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2428 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2432 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2434 w = bxsubr_u(i0, r0, rn(reg));
2440 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2447 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2454 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2456 ldxr_uc(r0, r1, r2);
2461 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2463 ldxi_uc(r0, r1, i0);
2468 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2473 if (can_sign_extend_short_p(i0))
2474 LBZ(r0, _R0_REGNO, i0);
2475 else if (can_sign_extend_int_p(i0)) {
2476 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2477 lo = (jit_int16_t)(i0 - (hi << 16));
2478 reg = jit_get_reg(jit_class_gpr);
2479 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2481 LBZ(r0, rn(reg), lo);
2483 if (inv) jit_unget_reg(_R0);
2486 reg = jit_get_reg(jit_class_gpr);
2488 ldr_uc(r0, rn(reg));
2494 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2497 if (r1 == _R0_REGNO) {
2498 if (r2 != _R0_REGNO)
2501 reg = jit_get_reg(jit_class_gpr);
2503 LBZX(r0, rn(reg), r2);
2512 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2517 else if (can_sign_extend_short_p(i0)) {
2518 if (r1 == _R0_REGNO) {
2519 reg = jit_get_reg(jit_class_gpr);
2521 LBZ(r0, rn(reg), i0);
2528 reg = jit_get_reg(jit_class_gpr);
2530 ldxr_uc(r0, r1, rn(reg));
2536 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2541 if (can_sign_extend_short_p(i0))
2542 LHA(r0, _R0_REGNO, i0);
2543 else if (can_sign_extend_int_p(i0)) {
2544 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2545 lo = (jit_int16_t)(i0 - (hi << 16));
2546 reg = jit_get_reg(jit_class_gpr);
2547 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2549 LHA(r0, rn(reg), lo);
2551 if (inv) jit_unget_reg(_R0);
2554 reg = jit_get_reg(jit_class_gpr);
2562 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2565 if (r1 == _R0_REGNO) {
2566 if (r2 != _R0_REGNO)
2569 reg = jit_get_reg(jit_class_gpr);
2571 LHAX(r0, rn(reg), r2);
2580 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2585 else if (can_sign_extend_short_p(i0)) {
2586 if (r1 == _R0_REGNO) {
2587 reg = jit_get_reg(jit_class_gpr);
2589 LHA(r0, rn(reg), i0);
2596 reg = jit_get_reg(jit_class_gpr);
2598 ldxr_s(r0, r1, rn(reg));
2604 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2609 if (can_sign_extend_short_p(i0))
2610 LHZ(r0, _R0_REGNO, i0);
2611 else if (can_sign_extend_int_p(i0)) {
2612 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2613 lo = (jit_int16_t)(i0 - (hi << 16));
2614 reg = jit_get_reg(jit_class_gpr);
2615 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2617 LHZ(r0, rn(reg), lo);
2619 if (inv) jit_unget_reg(_R0);
2622 reg = jit_get_reg(jit_class_gpr);
2624 ldr_us(r0, rn(reg));
2630 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2633 if (r1 == _R0_REGNO) {
2634 if (r2 != _R0_REGNO)
2637 reg = jit_get_reg(jit_class_gpr);
2639 LHZX(r0, rn(reg), r2);
2648 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2653 else if (can_sign_extend_short_p(i0)) {
2654 if (r1 == _R0_REGNO) {
2655 reg = jit_get_reg(jit_class_gpr);
2657 LHZ(r0, rn(reg), i0);
2664 reg = jit_get_reg(jit_class_gpr);
2666 ldxr_us(r0, r1, rn(reg));
2671 # if __WORDSIZE == 32
2673 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2678 if (can_sign_extend_short_p(i0))
2679 LWZ(r0, _R0_REGNO, i0);
2680 else if (can_sign_extend_int_p(i0)) {
2681 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2682 lo = (jit_int16_t)(i0 - (hi << 16));
2683 reg = jit_get_reg(jit_class_gpr);
2684 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2686 LWZ(r0, rn(reg), lo);
2688 if (inv) jit_unget_reg(_R0);
2691 reg = jit_get_reg(jit_class_gpr);
2699 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2702 if (r1 == _R0_REGNO) {
2703 if (r2 != _R0_REGNO)
2706 reg = jit_get_reg(jit_class_gpr);
2708 LWZX(r0, rn(reg), r2);
2717 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2722 else if (can_sign_extend_short_p(i0)) {
2723 if (r1 == _R0_REGNO) {
2724 reg = jit_get_reg(jit_class_gpr);
2726 LWZ(r0, rn(reg), i0);
2733 reg = jit_get_reg(jit_class_gpr);
2735 ldxr_i(r0, r1, rn(reg));
2742 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2747 if (can_sign_extend_short_p(i0))
2748 LWA(r0, _R0_REGNO, i0);
2749 else if (can_sign_extend_int_p(i0)) {
2750 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2751 lo = (jit_int16_t)(i0 - (hi << 16));
2752 reg = jit_get_reg(jit_class_gpr);
2753 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2755 LWA(r0, rn(reg), lo);
2757 if (inv) jit_unget_reg(_R0);
2760 reg = jit_get_reg(jit_class_gpr);
2768 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2771 if (r1 == _R0_REGNO) {
2772 if (r2 != _R0_REGNO)
2775 reg = jit_get_reg(jit_class_gpr);
2777 LWAX(r0, rn(reg), r2);
2786 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2791 else if (can_sign_extend_short_p(i0)) {
2792 if (r1 == _R0_REGNO) {
2793 reg = jit_get_reg(jit_class_gpr);
2795 LWA(r0, rn(reg), i0);
2802 reg = jit_get_reg(jit_class_gpr);
2804 ldxr_i(r0, r1, rn(reg));
2810 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2815 if (can_sign_extend_short_p(i0))
2816 LWZ(r0, _R0_REGNO, i0);
2817 else if (can_sign_extend_int_p(i0)) {
2818 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2819 lo = (jit_int16_t)(i0 - (hi << 16));
2820 reg = jit_get_reg(jit_class_gpr);
2821 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2823 LWZ(r0, rn(reg), lo);
2825 if (inv) jit_unget_reg(_R0);
2828 reg = jit_get_reg(jit_class_gpr);
2830 ldr_ui(r0, rn(reg));
2836 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2839 if (r1 == _R0_REGNO) {
2840 if (r2 != _R0_REGNO)
2843 reg = jit_get_reg(jit_class_gpr);
2845 LWZX(r0, rn(reg), r2);
2854 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2859 else if (can_sign_extend_short_p(i0)) {
2860 if (r1 == _R0_REGNO) {
2861 reg = jit_get_reg(jit_class_gpr);
2863 LWZ(r0, rn(reg), i0);
2870 reg = jit_get_reg(jit_class_gpr);
2872 ldxr_ui(r0, r1, rn(reg));
2878 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2883 if (can_sign_extend_short_p(i0))
2884 LD(r0, _R0_REGNO, i0);
2885 else if (can_sign_extend_int_p(i0)) {
2886 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2887 lo = (jit_int16_t)(i0 - (hi << 16));
2888 reg = jit_get_reg(jit_class_gpr);
2889 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2891 LD(r0, rn(reg), lo);
2893 if (inv) jit_unget_reg(_R0);
2896 reg = jit_get_reg(jit_class_gpr);
2904 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2907 if (r1 == _R0_REGNO) {
2908 if (r2 != _R0_REGNO)
2911 reg = jit_get_reg(jit_class_gpr);
2913 LDX(r0, rn(reg), r2);
2922 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2927 else if (can_sign_extend_short_p(i0)) {
2928 if (r1 == _R0_REGNO) {
2929 reg = jit_get_reg(jit_class_gpr);
2931 LD(r0, rn(reg), i0);
2938 reg = jit_get_reg(jit_class_gpr);
2940 ldxr_l(r0, r1, rn(reg));
2947 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2952 if (can_sign_extend_short_p(i0))
2953 STB(r0, _R0_REGNO, i0);
2954 else if (can_sign_extend_int_p(i0)) {
2955 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2956 lo = (jit_int16_t)(i0 - (hi << 16));
2957 reg = jit_get_reg(jit_class_gpr);
2958 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2960 STB(r0, rn(reg), lo);
2962 if (inv) jit_unget_reg(_R0);
2965 reg = jit_get_reg(jit_class_gpr);
2973 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2976 if (r0 == _R0_REGNO) {
2977 if (r1 != _R0_REGNO)
2980 reg = jit_get_reg(jit_class_gpr);
2982 STBX(r2, rn(reg), r1);
2991 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2996 else if (can_sign_extend_short_p(i0)) {
2997 if (r0 == _R0_REGNO) {
2998 reg = jit_get_reg(jit_class_gpr);
3000 STB(r1, rn(reg), i0);
3007 reg = jit_get_reg(jit_class_gpr);
3009 stxr_c(rn(reg), r0, r1);
3015 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3020 if (can_sign_extend_short_p(i0))
3021 STH(r0, _R0_REGNO, i0);
3022 else if (can_sign_extend_int_p(i0)) {
3023 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3024 lo = (jit_int16_t)(i0 - (hi << 16));
3025 reg = jit_get_reg(jit_class_gpr);
3026 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3028 STH(r0, rn(reg), lo);
3030 if (inv) jit_unget_reg(_R0);
3033 reg = jit_get_reg(jit_class_gpr);
3041 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3044 if (r0 == _R0_REGNO) {
3045 if (r1 != _R0_REGNO)
3048 reg = jit_get_reg(jit_class_gpr);
3050 STHX(r2, rn(reg), r1);
3059 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3064 else if (can_sign_extend_short_p(i0)) {
3065 if (r0 == _R0_REGNO) {
3066 reg = jit_get_reg(jit_class_gpr);
3068 STH(r1, rn(reg), i0);
3075 reg = jit_get_reg(jit_class_gpr);
3077 stxr_s(rn(reg), r0, r1);
3083 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3088 if (can_sign_extend_short_p(i0))
3089 STW(r0, _R0_REGNO, i0);
3090 else if (can_sign_extend_int_p(i0)) {
3091 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3092 lo = (jit_int16_t)(i0 - (hi << 16));
3093 reg = jit_get_reg(jit_class_gpr);
3094 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3096 STW(r0, rn(reg), lo);
3098 if (inv) jit_unget_reg(_R0);
3101 reg = jit_get_reg(jit_class_gpr);
3109 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3112 if (r0 == _R0_REGNO) {
3113 if (r1 != _R0_REGNO)
3116 reg = jit_get_reg(jit_class_gpr);
3118 STWX(r2, rn(reg), r1);
3127 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3132 else if (can_sign_extend_short_p(i0)) {
3133 if (r0 == _R0_REGNO) {
3134 reg = jit_get_reg(jit_class_gpr);
3136 STW(r1, rn(reg), i0);
3143 reg = jit_get_reg(jit_class_gpr);
3145 stxr_i(rn(reg), r0, r1);
3150 # if __WORDSIZE == 64
3152 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3157 if (can_sign_extend_short_p(i0))
3158 STD(r0, _R0_REGNO, i0);
3159 else if (can_sign_extend_int_p(i0)) {
3160 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3161 lo = (jit_int16_t)(i0 - (hi << 16));
3162 reg = jit_get_reg(jit_class_gpr);
3163 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3165 STD(r0, rn(reg), lo);
3167 if (inv) jit_unget_reg(_R0);
3170 reg = jit_get_reg(jit_class_gpr);
3178 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3181 if (r0 == _R0_REGNO) {
3182 if (r1 != _R0_REGNO)
3185 reg = jit_get_reg(jit_class_gpr);
3187 STDX(r2, rn(reg), r1);
3196 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3201 else if (can_sign_extend_short_p(i0)) {
3202 if (r0 == _R0_REGNO) {
3203 reg = jit_get_reg(jit_class_gpr);
3205 STD(r1, rn(reg), i0);
3212 reg = jit_get_reg(jit_class_gpr);
3214 stxr_l(rn(reg), r0, r1);
3221 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3232 /* pc relative jump */
3234 _jmpi(jit_state_t *_jit, jit_word_t i0)
3240 if (can_sign_extend_jump_p(d))
3243 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3244 w = movi_p(rn(reg), i0);
3253 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3257 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3258 w = movi_p(rn(reg), i0);
3265 _callr(jit_state_t *_jit, jit_int32_t r0
3267 , jit_int32_t varargs
3272 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3273 /* FIXME Pretend to not know about r11? */
3274 if (r0 == _R0_REGNO) {
3275 movr(_R11_REGNO, _R0_REGNO);
3276 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3277 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3280 ldxi(_R2_REGNO, r0, sizeof(void*));
3281 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3286 /* Tell double arguments were passed in registers. */
3290 movr(_R12_REGNO, r0);
3297 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3301 /* assume fixed address or reachable address */
3303 _calli(jit_state_t *_jit, jit_word_t i0
3305 , jit_int32_t varargs
3311 d = (i0 - _jit->pc.w - !!varargs * 4) & ~3;
3312 if (can_sign_extend_jump_p(d)) {
3313 /* Tell double arguments were passed in registers. */
3320 movi(_R12_REGNO, i0);
3331 _calli_p(jit_state_t *_jit, jit_word_t i0
3333 , jit_int32_t varargs
3338 w = movi_p(_R12_REGNO, i0);
3347 /* order is not guaranteed to be sequential */
3348 static jit_int32_t save[] = {
3349 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3350 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3354 _prolog(jit_state_t *_jit, jit_node_t *node)
3356 unsigned long regno;
3359 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3360 jit_int32_t frame = -_jitc->function->frame;
3361 assert(_jitc->function->self.aoff >= frame);
3362 if (_jitc->function->assume_frame)
3364 _jitc->function->self.aoff = frame;
3366 if (_jitc->function->allocar) {
3367 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3368 _jitc->function->self.aoff &= -16;
3370 _jitc->function->stack = ((_jitc->function->self.alen +
3371 _jitc->function->self.size -
3372 _jitc->function->self.aoff) + 15) & -16;
3374 /* return address */
3377 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3378 * alloca < %r31-80 */
3381 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3383 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3385 offset = -gpr_save_area;
3386 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3387 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3388 stxi(offset, _SP_REGNO, rn(save[regno]));
3390 for (offset = 0; offset < 8; offset++) {
3391 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3392 stxi_d(-(gpr_save_area + 8 + offset * 8),
3393 _SP_REGNO, rn(_F14 + offset));
3396 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3398 movr(_FP_REGNO, _SP_REGNO);
3399 #if __WORDSIZE == 32
3400 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3402 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3405 if (_jitc->function->allocar) {
3406 regno = jit_get_reg(jit_class_gpr);
3407 movi(rn(regno), _jitc->function->self.aoff);
3408 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3409 jit_unget_reg(regno);
3413 if (_jitc->function->self.call & jit_call_varargs) {
3414 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3415 stxi(params_offset + regno * sizeof(jit_word_t),
3416 _FP_REGNO, rn(JIT_RA0 - regno));
3419 if (_jitc->function->self.call & jit_call_varargs) {
3420 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3421 stxi(_jitc->function->vaoff + first_gp_offset +
3422 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3423 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3424 stxi_d(_jitc->function->vaoff + first_fp_offset +
3425 regno * va_fp_increment, _FP_REGNO,
3426 rn(JIT_FA0 - regno));
3432 _epilog(jit_state_t *_jit, jit_node_t *node)
3434 unsigned long regno;
3437 if (_jitc->function->assume_frame)
3439 if (_jitc->function->allocar)
3440 ldr(_SP_REGNO, _SP_REGNO);
3442 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3444 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3446 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3448 offset = -gpr_save_area;
3449 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3450 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3451 ldxi(rn(save[regno]), _SP_REGNO, offset);
3453 for (offset = 0; offset < 8; offset++) {
3454 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3455 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3456 -(gpr_save_area + 8 + offset * 8));
3460 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3466 _vastart(jit_state_t *_jit, jit_int32_t r0)
3469 assert(_jitc->function->self.call & jit_call_varargs);
3470 /* Initialize stack pointer to the first stack argument. */
3471 addi(r0, _FP_REGNO, _jitc->function->self.size);
3474 assert(_jitc->function->self.call & jit_call_varargs);
3476 /* Return jit_va_list_t in the register argument */
3477 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3478 reg = jit_get_reg(jit_class_gpr);
3480 /* Initialize the gp counter. */
3481 movi(rn(reg), _jitc->function->vagp);
3482 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3484 /* Initialize the fp counter. */
3485 movi(rn(reg), _jitc->function->vafp);
3486 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3488 /* Initialize overflow pointer to the first stack argument. */
3489 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3490 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3492 /* Initialize register save area pointer. */
3493 addi(rn(reg), r0, first_gp_offset);
3494 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3501 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3504 assert(_jitc->function->self.call & jit_call_varargs);
3505 /* Load argument. */
3507 /* Update va_list. */
3508 addi(r1, r1, sizeof(jit_word_t));
3515 assert(_jitc->function->self.call & jit_call_varargs);
3517 rg0 = jit_get_reg(jit_class_gpr);
3518 rg1 = jit_get_reg(jit_class_gpr);
3520 /* Load the gp offset in save area in the first temporary. */
3521 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3523 /* Jump over if there are no remaining arguments in the save area. */
3524 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3526 /* Update the gp counter. */
3527 addi(rn(rg1), rn(rg0), 1);
3528 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3530 /* Load the save area pointer in the second temporary. */
3531 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3533 /* Load the vararg argument in the first argument. */
3534 lshi(rn(rg0), rn(rg0), va_gp_shift);
3535 ldxr(r0, rn(rg1), rn(rg0));
3537 /* Will only need one temporary register below. */
3540 /* Jump over overflow code. */
3541 lt_code = _jit->pc.w;
3544 /* Where to land if argument is in overflow area. */
3545 patch_at(ge_code, _jit->pc.w);
3547 /* Load overflow pointer. */
3548 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3550 /* Load argument. */
3553 /* Update overflow pointer. */
3554 addi(rn(rg0), rn(rg0), va_gp_increment);
3555 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3557 /* Where to land if argument is in save area. */
3558 patch_at(lt_code, _jit->pc.w);
3565 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3568 assert(_jitc->function->self.call & jit_call_varargs);
3569 /* Load argument. */
3571 /* Update va_list. */
3572 addi(r1, r1, sizeof(jit_float64_t));
3579 assert(_jitc->function->self.call & jit_call_varargs);
3581 rg0 = jit_get_reg(jit_class_gpr);
3582 rg1 = jit_get_reg(jit_class_gpr);
3584 /* Load the fp offset in save area in the first temporary. */
3585 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3587 /* Jump over if there are no remaining arguments in the save area. */
3588 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3590 /* Update the fp counter. */
3591 addi(rn(rg1), rn(rg0), 1);
3592 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3594 /* Load the save area pointer in the second temporary. */
3595 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3597 /* Load the vararg argument in the first argument. */
3598 lshi(rn(rg0), rn(rg0), 3);
3599 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3600 offsetof(jit_va_list_t, first_gp_argument));
3601 ldxr_d(r0, rn(rg1), rn(rg0));
3603 /* Jump over overflow code. */
3604 lt_code = _jit->pc.w;
3607 /* Where to land if argument is in overflow area. */
3608 patch_at(ge_code, _jit->pc.w);
3610 /* Load overflow pointer. */
3611 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3613 # if __WORDSIZE == 32
3614 /* Align if required. */
3615 andi(rn(rg1), rn(rg0), 7);
3616 addr(rn(rg0), rn(rg0), rn(rg1));
3619 /* Load argument. */
3622 /* Update overflow pointer. */
3623 addi(rn(rg0), rn(rg0), va_fp_increment);
3624 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3626 /* Where to land if argument is in save area. */
3627 patch_at(lt_code, _jit->pc.w);
3635 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3643 switch ((u.i[0] & 0xfc000000) >> 26) {
3647 if (!can_sign_extend_short_p(d)) {
3648 /* use absolute address */
3649 assert(can_sign_extend_short_p(label));
3652 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3656 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3657 /* zero is used for toc and env, so, quick check
3658 * if this is a "jmpi main" like initial jit
3660 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3661 for (d = 0; d < _jitc->prolog.offset; d++) {
3662 /* not so pretty, but hides powerpc
3663 * specific abi intrinsics and/or
3664 * implementation from user */
3665 if (_jitc->prolog.ptr[d] == label) {
3666 label += sizeof(void*) * 3;
3675 if (!can_sign_extend_jump_p(d)) {
3676 /* use absolute address */
3677 assert(can_sign_extend_jump_p(label));
3680 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3683 #if __WORDSIZE == 32
3684 # define MTCTR_OFF 2
3687 # define MTCTR_OFF 6
3691 /* movi reg label; jmpr reg */
3694 /* check for MLTR(reg) */
3695 (u.i[MTCTR_OFF] >> 26) == 31 &&
3696 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3697 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3699 u.i[BCTR_OFF] == 0x4e800020) {
3701 /* check for MTCTR(reg) */
3702 (u.i[MTCTR_OFF] >> 26) == 31 &&
3703 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3704 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3705 /* check for BCTR */
3706 u.i[BCTR_OFF] == 0x4e800420) {
3708 /* zero is used for toc and env, so, quick check
3709 * if this is a "jmpi main" like initial jit
3711 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3712 for (d = 0; d < _jitc->prolog.offset; d++) {
3713 /* not so pretty, but hides powerpc
3714 * specific abi intrinsics and/or
3715 * implementation from user */
3716 if (_jitc->prolog.ptr[d] == label) {
3717 label += sizeof(void*) * 3;
3726 #if __WORDSIZE == 32
3727 assert(!(u.i[0] & 0x1f0000));
3728 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3729 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3730 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3731 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3733 assert(!(u.i[0] & 0x1f0000));
3734 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3735 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3736 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3737 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3738 /* not fully validating SLDI */
3739 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3740 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3741 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3742 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3743 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3744 /* not fully validating SLDI */
3745 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3746 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3747 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3748 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3749 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3753 assert(!"unhandled branch opcode");