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 LHRBX(d,a,b) FX(31,d,a,b,790)
264 # define LHZ(d,a,s) FDs(40,d,a,s)
265 # define LHZU(d,a,s) FDs(41,d,a,s)
266 # define LHZUX(d,a,b) FX(31,d,a,b,311)
267 # define LHZX(d,a,b) FX(31,d,a,b,279)
268 # define LA(d,a,s) ADDI(d,a,s)
269 # define LI(d,s) ADDI(d,0,s)
270 # define LMW(d,a,s) FDs(46,d,a,s)
271 # define LSWI(d,a,n) FX(31,d,a,n,597)
272 # define LSWX(d,a,b) FX(31,d,a,b,533)
273 # define LWARX(d,a,b) FX(31,d,a,b,20)
274 # define LWBRX(d,a,b) FX(31,d,a,b,534)
275 # define LWA(d,a,s) FDs(58,d,a,s|2)
276 # define LWAUX(d,a,b) FX(31,d,a,b,373)
277 # define LWAX(d,a,b) FX(31,d,a,b,341)
278 # define LWZ(d,a,s) FDs(32,d,a,s)
279 # define LWZU(d,a,s) FDs(33,d,a,s)
280 # define LWZUX(d,a,b) FX(31,d,a,b,55)
281 # define LWZX(d,a,b) FX(31,d,a,b,23)
282 # define LD(d,a,s) FDs(58,d,a,s)
283 # define LDX(d,a,b) FX(31,d,a,b,21)
284 # define MCRF(d,s) FXL(19,d<<2,(s)<<2,0)
286 /* In case instruction is emulated, check the kernel can handle it.
287 Will only generate it if DEBUG is enabled.
289 Chapter 6. Optional Facilities and Instructions that are being
290 Phased Out of the Architecture
292 6.1 Move To Condition Register from XER
293 The mcrxr instruction is being phased out of the archi-
294 tecture. Its description is included here as an aid to
295 constructing operating system code to emulate it.
297 Move to Condition Register from XER
300 31 BF // /// /// 512 /
302 CR(4xBF:4xBF+3) <- XER(32:35)
304 The contents of XER(32:35) are copied to Condition Reg-
305 ister field BF. XER(32:35) are set to zero.
306 Special Registers Altered:
307 CR field BF XER(32:35)
310 Warning: This instruction has been phased out of
311 the architecture. Attempting to execute this
312 instruction will cause the system illegal instruction
313 error handler to be invoked
316 # define MCRXR(d) FX(31,d<<2,0,0,512)
318 # define MCRXR(cr) _MCRXR(_jit,cr);
319 static void _MCRXR(jit_state_t*, jit_int32_t);
321 # define MFCR(d) FX(31,d,0,0,19)
322 # define MFMSR(d) FX(31,d,0,0,83)
323 # define MFSPR(d,s) FXFX(31,d,s<<5,339)
324 # define MFXER(d) MFSPR(d,1)
325 # define MFLR(d) MFSPR(d,8)
326 # define MFCTR(d) MFSPR(d,9)
327 # define MFSR(d,s) FX(31,d,s,0,595)
328 # define MFSRIN(d,b) FX(31,d,0,b,659)
329 # define MFTB(d,x,y) FXFX(31,d,(x)|((y)<<5),371)
330 # define MFTBL(d) MFTB(d,8,12)
331 # define MFTBU(d) MFTB(d,8,13)
332 # define MTCRF(c,s) FXFX(31,s,c<<1,144)
333 # define MTCR(s) MTCRF(0xff,s)
334 # define MTMSR(s) FX(31,s,0,0,146)
335 # define MTSPR(d,s) FXFX(31,d,s<<5,467)
336 # define MTXER(d) MTSPR(d,1)
337 # define MTLR(d) MTSPR(d,8)
338 # define MTCTR(d) MTSPR(d,9)
339 # define MTSR(r,s) FX(31,s<<1,r,0,210)
340 # define MTSRIN(r,b) FX(31,r<<1,0,b,242)
341 # define MULLI(d,a,s) FDs(07,d,a,s)
342 # define MULHW(d,a,b) FXO(31,d,a,b,0,75)
343 # define MULHW_(d,a,b) FXO_(31,d,a,b,0,75)
344 # define MULHWU(d,a,b) FXO(31,d,a,b,0,11)
345 # define MULHWU_(d,a,b) FXO_(31,d,a,b,0,11)
346 # define MULLW(d,a,b) FXO(31,d,a,b,0,235)
347 # define MULLW_(d,a,b) FXO_(31,d,a,b,0,235)
348 # define MULLWO(d,a,b) FXO(31,d,a,b,1,235)
349 # define MULLWO_(d,a,b) FXO_(31,d,a,b,1,235)
350 # define MULHD(d,a,b) FXO(31,d,a,b,0,73)
351 # define MULHD_(d,a,b) FXO_(31,d,a,b,0,73)
352 # define MULHDU(d,a,b) FXO(31,d,a,b,0,9)
353 # define MULHDU_(d,a,b) FXO_(31,d,a,b,0,9)
354 # define MULLD(d,a,b) FXO(31,d,a,b,0,233)
355 # define MULLD_(d,a,b) FXO_(31,d,a,b,0,233)
356 # define MULLDO(d,a,b) FXO(31,d,a,b,1,233)
357 # define MULLDO_(d,a,b) FXO_(31,d,a,b,1,233)
358 # define NAND(d,a,b) FX(31,a,d,b,476)
359 # define NAND_(d,a,b) FX_(31,a,d,b,476)
360 # define NEG(d,a) FXO(31,d,a,0,0,104)
361 # define NEG_(d,a) FXO_(31,d,a,0,0,104)
362 # define NEGO(d,a) FXO(31,d,a,0,1,104)
363 # define NEGO_(d,a) FXO_(31,d,a,0,1,104)
364 # define NOR(d,a,b) FX(31,a,d,b,124)
365 # define NOR_(d,a,b) FX_(31,a,d,b,124)
366 # define NOT(d,s) NOR(d,s,s)
367 # define OR(d,a,b) FX(31,a,d,b,444)
368 # define OR_(d,a,b) FX_(31,a,d,b,444)
369 # define MR(d,a) OR(d,a,a)
370 # define ORC(d,a,b) FX(31,a,d,b,412)
371 # define ORC_(d,a,b) FX_(31,a,d,b,412)
372 # define ORI(d,a,u) FDu(24,a,d,u)
373 # define NOP() ORI(0,0,0)
374 # define ORIS(d,a,u) FDu(25,a,d,u)
375 # define RFI() FXL(19,0,0,50)
376 # define RLWIMI(d,s,h,b,e) FM(20,s,d,h,b,e,0)
377 # define RLWIMI_(d,s,h,b,e) FM(20,s,d,h,b,e,1)
378 # define INSLWI(a,s,n,b) RLWIMI(a,s,32-b,b,b+n-1)
379 # define INSRWI(a,s,n,b) RLWIMI(a,s,32-(b+n),b,(b+n)-1)
380 # define RLWINM(a,s,h,b,e) FM(21,s,a,h,b,e,0)
381 # define RLWINM_(a,s,h,b,e) FM(21,s,a,h,b,e,1)
382 # define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,n-1)
383 # define EXTRWI(a,s,n,b) RLWINM(a,s,b+n,32-n,31)
384 # define ROTLWI(a,s,n) RLWINM(a,s,n,0,31)
385 # define ROTRWI(a,s,n) RLWINM(a,s,32-n,0,31)
386 # define SLWI(a,s,n) RLWINM(a,s,n,0,31-n)
387 # define SRWI(a,s,n) RLWINM(a,s,32-n,n,31)
388 # define CLRLWI(a,s,n) RLWINM(a,s,0,n,31)
389 # define CLRRWI(a,s,n) RLWINM(a,s,0,0,31-n)
390 # define CLRLSWI(a,s,b,n) RLWINM(a,s,n,b-n,31-n)
391 # define RLWNM(a,s,b,m,e) FM(23,s,a,b,m,e,0)
392 # define RLWNM_(a,s,b,m,e) FM(23,s,a,b,m,e,1)
393 # define ROTLW(a,s,b) RLWNM(a,s,b,0,31)
394 # define SC() FDu(17,0,0,2)
395 # define SLW(a,s,b) FX(31,s,a,b,24)
396 # define SLW_(a,s,b) FX_(31,s,a,b,24)
397 # define SRAW(a,s,b) FX(31,s,a,b,792)
398 # define SRAW_(a,s,b) FX_(31,s,a,b,792)
399 # define SRAWI(a,s,h) FX(31,s,a,h,824)
400 # define SRAWI_(a,s,h) FX_(31,s,a,h,824)
401 # define SRW(a,s,b) FX(31,s,a,b,536)
402 # define SRW_(a,s,b) FX_(31,s,a,b,536)
403 # if __WORDSIZE == 64
404 # define RLDICL(a,s,h,b) FMD(30,s,a,h&~32,b,0,h>>5)
405 # define RLDICL_(a,s,h,b) FMD_(30,s,a,h&~32,b,0,h>>5)
406 # define EXTRDI(x,y,n,b) RLDICL(x,y,(b+n),(64-n))
407 # define SRDI(x,y,n) RLDICL(x,y,(64-n),n)
408 # define CLRLDI(x,y,n) RLDICL(x,y,0,n)
409 # define RLDICR(a,s,h,e) FMD(30,s,a,h&~32,e,1,h>>5)
410 # define RLDICR_(a,s,h,e) FMD_(30,s,a,h&~32,e,1,h>>5)
411 # define EXTRLI(x,y,n,b) RLDICR(x,y,b,(n-1))
412 # define SLDI(x,y,n) RLDICR(x,y,n,(63-n))
413 # define CLRRDI(x,y,n) RLDICR(x,y,0,(63-n))
414 # define RLDIC(a,s,h,b) FMD(30,s,a,h&~32,b,2,h>>5)
415 # define RLDIC_(a,s,h,b) FMD_(30,s,a,h&~32,b,2,h>>5)
416 # define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,(b-n))
417 # define RLDCL(a,s,h,b) FMDS(30,s,a,h,b,8)
418 # define RLDCL_(a,s,h,b) FMDS_(30,s,a,h,b,8)
419 # define ROTLD(x,y,z) RLDCL(x,y,z,0)
420 # define RLDCR(a,s,b,e) FMDS(30,s,a,b,e,0)
421 # define RLDCR_(a,s,b,e) FMDS_(30,s,a,b,e,0)
422 # define RLDIMI(a,s,h,b) FMD(30,s,a,h&~32,b,3,h>>5)
423 # define RLDIMI_(a,s,h,b) FMD_(30,s,a,h&~32,b,3,h>>5)
424 # define INSRDI(x,y,n,b) RLDIMI(x,y,(64-(b+n)),b)
425 # define SLD(a,s,b) FX(31,s,a,b,27)
426 # define SLD_(a,s,b) FX_(31,s,a,b,27)
427 # define SRD(a,s,b) FX(31,s,a,b,539)
428 # define SRD_(a,s,b) FX_(31,s,a,b,539)
429 # define SRADI(a,s,h) FXS(31,s,a,h&~32,413,h>>5)
430 # define SRADI_(a,s,h) FXS_(31,s,a,h&~32,413,h>>5)
431 # define SRAD(a,s,b) FX(31,s,a,b,794)
432 # define SRAD_(a,s,b) FX_(31,s,a,b,794)
434 # define STB(s,a,d) FDs(38,s,a,d)
435 # define STBU(s,a,d) FDs(39,s,a,d)
436 # define STBUX(s,a,b) FX(31,s,a,b,247)
437 # define STBX(s,a,b) FX(31,s,a,b,215)
438 # define STH(s,a,d) FDs(44,s,a,d)
439 # define STHBRX(s,a,b) FX(31,s,a,b,918)
440 # define STHU(s,a,d) FDs(45,s,a,d)
441 # define STHUX(s,a,b) FX(31,s,a,b,439)
442 # define STHX(s,a,b) FX(31,s,a,b,407)
443 # define STMW(s,a,d) FDs(47,s,a,d)
444 # define STWSI(s,a,nb) FX(31,s,a,nb,725)
445 # define STSWX(s,a,b) FX(31,s,a,b,661)
446 # define STW(s,a,d) FDs(36,s,a,d)
447 # define STWBRX(s,a,b) FX(31,s,a,b,662)
448 # define STWCX_(s,a,b) FX_(31,s,a,b,150)
449 # define STWU(s,a,d) FDs(37,s,a,d)
450 # define STWUX(s,a,b) FX(31,s,a,b,183)
451 # define STWX(s,a,b) FX(31,s,a,b,151)
452 # define STD(s,a,d) FDs(62,s,a,d)
453 # define STDX(s,a,b) FX(31,s,a,b,149)
454 # define STDU(s,a,d) FDs(62,s,a,d|1)
455 # define STDUX(s,a,b) FX(31,s,a,b,181)
456 # define SUBF(d,a,b) FXO(31,d,a,b,0,40)
457 # define SUBF_(d,a,b) FXO_(31,d,a,b,0,40)
458 # define SUBFO(d,a,b) FXO(31,d,a,b,1,40)
459 # define SUBFO_(d,a,b) FXO_(31,d,a,b,1,40)
460 # define SUB(d,a,b) SUBF(d,b,a)
461 # define SUB_(d,a,b) SUBF_(d,b,a)
462 # define SUBO(d,a,b) SUBFO(d,b,a)
463 # define SUBO_(d,a,b) SUBFO_(d,b,a)
464 # define SUBI(d,a,s) ADDI(d,a,-s)
465 # define SUBIS(d,a,s) ADDIS(d,a,-s)
466 # define SUBFC(d,a,b) FXO(31,d,a,b,0,8)
467 # define SUBFC_(d,a,b) FXO_(31,d,a,b,0,8)
468 # define SUBFCO(d,a,b) FXO(31,d,a,b,1,8)
469 # define SUBFCO_(d,a,b) FXO_(31,d,a,b,1,8)
470 # define SUBC(d,a,b) SUBFC(d,b,a)
471 # define SUBIC(d,a,s) ADDIC(d,a,-s)
472 # define SUBIC_(d,a,s) ADDIC_(d,a,-s)
473 # define SUBFE(d,a,b) FXO(31,d,a,b,0,136)
474 # define SUBFE_(d,a,b) FXO_(31,d,a,b,0,136)
475 # define SUBFEO(d,a,b) FXO(31,d,a,b,1,136)
476 # define SUBFEO_(d,a,b) FXO_(31,d,a,b,1,136)
477 # define SUBE(d,a,b) SUBFE(d,b,a)
478 # define SUBFIC(d,a,s) FDs(8,d,a,s)
479 # define SUBFME(d,a) FXO(31,d,a,0,0,232)
480 # define SUBFME_(d,a) FXO_(31,d,a,0,0,232)
481 # define SUBFMEO(d,a) FXO(31,d,a,0,1,232)
482 # define SUBFMEO_(d,a) FXO_(31,d,a,0,1,232)
483 # define SUBFZE(d,a) FXO(31,d,a,0,0,200)
484 # define SUBFZE_(d,a) FXO_(31,d,a,0,0,200)
485 # define SUBFZEO(d,a) FXO(31,d,a,0,1,200)
486 # define SUBFZEO_(d,a) FXO_(31,d,a,0,1,200)
487 # define SYNC() FX(31,0,0,0,598)
488 # define TLBIA() FX(31,0,0,0,370)
489 # define TLBIE(b) FX(31,0,0,b,306)
490 # define TLBSYNC() FX(31,0,0,0,566)
491 # define TW(t,a,b) FX(31,t,a,b,4)
492 # define TWEQ(a,b) FX(31,4,a,b,4)
493 # define TWLGE(a,b) FX(31,5,a,b,4)
494 # define TRAP() FX(31,31,0,0,4)
495 # define TWI(t,a,s) FDs(3,t,a,s)
496 # define TWGTI(a,s) TWI(8,a,s)
497 # define TWLLEI(a,s) TWI(6,a,s)
498 # define XOR(d,a,b) FX(31,a,d,b,316)
499 # define XOR_(d,a,b) FX_(31,a,d,b,316)
500 # define XORI(s,a,u) FDu(26,a,s,u)
501 # define XORIS(s,a,u) FDu(27,a,s,u)
502 # define nop(c) _nop(_jit,c)
503 static void _nop(jit_state_t*,jit_int32_t);
504 # define movr(r0,r1) _movr(_jit,r0,r1)
505 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
506 # define movi(r0,i0) _movi(_jit,r0,i0)
507 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
508 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
509 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
510 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
511 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
512 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
513 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
514 # define negr(r0,r1) NEG(r0,r1)
515 # define comr(r0,r1) NOT(r0,r1)
516 # define extr_c(r0,r1) EXTSB(r0,r1)
517 # define extr_uc(r0,r1) ANDI_(r0,r1,0xff)
518 # define extr_s(r0,r1) EXTSH(r0,r1)
519 # define extr_us(r0,r1) ANDI_(r0,r1,0xffff)
520 # if __WORDSIZE == 64
521 # define extr_i(r0,r1) EXTSW(r0,r1)
522 # define extr_ui(r0,r1) CLRLDI(r0,r1,32)
524 # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1)
525 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
526 # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1)
527 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
528 # if __WORDSIZE == 64
529 # define bswapr_ul(r0,r1) generic_bswapr_ul(_jit,r0,r1)
531 # define addr(r0,r1,r2) ADD(r0,r1,r2)
532 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
533 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
534 # define addcr(r0,r1,r2) ADDC(r0,r1,r2)
535 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
536 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
537 # define addxr(r0,r1,r2) ADDE(r0,r1,r2)
538 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
539 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
540 # define subr(r0,r1,r2) SUB(r0,r1,r2)
541 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
542 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
543 # define subcr(r0,r1,r2) SUBC(r0,r1,r2)
544 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
545 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
546 # define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
547 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
548 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
549 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
550 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
551 # if __WORDSIZE == 32
552 # define mulr(r0,r1,r2) MULLW(r0,r1,r2)
553 # define mullr(r0,r1,r2) MULLW(r0,r1,r2)
554 # define mulhr(r0,r1,r2) MULHW(r0,r1,r2)
555 # define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2)
557 # define mulr(r0,r1,r2) MULLD(r0,r1,r2)
558 # define mullr(r0,r1,r2) MULLD(r0,r1,r2)
559 # define mulhr(r0,r1,r2) MULHD(r0,r1,r2)
560 # define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2)
562 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
563 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
564 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
565 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
566 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
567 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
568 jit_int32_t,jit_int32_t,jit_bool_t);
569 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
570 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
571 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
572 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
573 jit_int32_t,jit_word_t,jit_bool_t);
574 # if __WORDSIZE == 32
575 # define divr(r0,r1,r2) DIVW(r0,r1,r2)
577 # define divr(r0,r1,r2) DIVD(r0,r1,r2)
579 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
580 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
581 # if __WORDSIZE == 32
582 # define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
584 # define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
586 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
587 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
588 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
589 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
590 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
591 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
592 jit_int32_t,jit_int32_t,jit_bool_t);
593 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
594 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
595 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
596 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
597 jit_int32_t,jit_word_t,jit_bool_t);
598 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
599 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
600 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
601 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
602 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
603 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
604 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
605 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
606 # define andr(r0,r1,r2) AND(r0,r1,r2)
607 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
608 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
609 # define orr(r0,r1,r2) OR(r0,r1,r2)
610 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
611 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
612 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
613 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
614 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
615 # if __WORDSIZE == 32
616 # define lshr(r0,r1,r2) SLW(r0,r1,r2)
618 # define lshr(r0,r1,r2) SLD(r0,r1,r2)
620 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
621 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
622 # if __WORDSIZE == 32
623 # define rshr(r0,r1,r2) SRAW(r0,r1,r2)
625 # define rshr(r0,r1,r2) SRAD(r0,r1,r2)
627 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
628 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
629 # if __WORDSIZE == 32
630 # define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
632 # define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
634 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
635 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
636 # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
637 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
638 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
639 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
640 # define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
641 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
642 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
643 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
644 # define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
645 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
646 # define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
647 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
648 # define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
649 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
650 # define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
651 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
652 # define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
653 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
654 # define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
655 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
656 # define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
657 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
658 # define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
659 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
660 # define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
661 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
662 # define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
663 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
664 # define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
665 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
666 # define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
667 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
668 # define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
669 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
670 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
671 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
672 # define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
673 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
674 # define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
675 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
676 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
677 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
678 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
679 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
680 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
681 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
682 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
683 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
684 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
685 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
686 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
687 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
688 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
689 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
690 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
691 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
692 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
693 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
694 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
695 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
696 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
697 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
698 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
699 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
700 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
701 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
702 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
703 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
704 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
705 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
706 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
707 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
708 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
709 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
710 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
711 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
712 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
713 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
714 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
715 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
716 #define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
717 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
718 #define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
719 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
720 #define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
721 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
722 #define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
723 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
724 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
725 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
726 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
727 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
728 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
729 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
730 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
731 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
732 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
733 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
734 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
735 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
736 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
737 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
738 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
739 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
740 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
741 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
742 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
743 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
744 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
745 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
746 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
747 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
748 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
749 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
750 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
751 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
752 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
753 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
754 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
755 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
756 # define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
757 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
758 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
759 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
760 # define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
761 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
762 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
763 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
764 # define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
765 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
766 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
767 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
768 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
769 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
770 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
771 # define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
772 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
773 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
774 # define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
775 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
776 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
777 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
778 # define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
779 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
780 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
781 # define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
782 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
783 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
784 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
785 # if __WORDSIZE == 32
786 # define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
788 # define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
790 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
791 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
792 # define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
793 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
794 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
795 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
796 # if __WORDSIZE == 64
797 # define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
798 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
799 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
800 # define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
801 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
802 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
803 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
804 # define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
805 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
806 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
807 # define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
808 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
809 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
810 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
812 # define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
813 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
814 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
815 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
816 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
817 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
818 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
819 # define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
820 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
821 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
822 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
823 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
824 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
825 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
826 # define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
827 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
828 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
829 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
830 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
831 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
832 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
833 # if __WORDSIZE == 64
834 # define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
835 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
836 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
837 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
838 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
839 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
840 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
842 # define jmpr(r0) _jmpr(_jit,r0)
843 static void _jmpr(jit_state_t*,jit_int32_t);
844 # define jmpi(i0) _jmpi(_jit,i0)
845 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
846 # define jmpi_p(i0) _jmpi_p(_jit,i0)
847 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
849 # define callr(r0,i0) _callr(_jit,r0,i0)
850 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
851 # define calli(i0,i1) _calli(_jit,i0,i1)
852 static void _calli(jit_state_t*,jit_word_t,jit_int32_t);
853 # define calli_p(i0,i1) _calli_p(_jit,i0,i1)
854 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
856 # define callr(r0) _callr(_jit,r0)
857 static void _callr(jit_state_t*,jit_int32_t);
858 # define calli(i0) _calli(_jit,i0)
859 static void _calli(jit_state_t*,jit_word_t);
860 # define calli_p(i0) _calli_p(_jit,i0)
861 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
863 # define prolog(node) _prolog(_jit, node)
864 static void _prolog(jit_state_t*, jit_node_t*);
865 # define epilog(node) _epilog(_jit, node)
866 static void _epilog(jit_state_t*, jit_node_t*);
867 # define vastart(r0) _vastart(_jit, r0)
868 static void _vastart(jit_state_t*, jit_int32_t);
869 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
870 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
871 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
872 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
873 # define patch_at(i,l) _patch_at(_jit,i,l)
874 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
878 # define _u16(v) ((v) & 0xffff)
879 # define _u26(v) ((v) & 0x3ffffff)
881 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
883 assert(!(o & ~((1 << 6) - 1)));
884 assert(!(d & ~((1 << 5) - 1)));
885 assert(!(a & ~((1 << 5) - 1)));
886 assert(!(b & ~((1 << 5) - 1)));
887 assert(!(e & ~((1 << 1) - 1)));
888 assert(!(x & ~((1 << 9) - 1)));
889 assert(!(r & ~((1 << 1) - 1)));
890 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
894 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
896 assert(!(o & ~((1 << 6) - 1)));
897 assert(!(d & ~((1 << 5) - 1)));
898 assert(!(a & ~((1 << 5) - 1)));
899 assert(can_sign_extend_short_p(s));
900 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
904 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
906 assert(!(o & ~((1 << 6) - 1)));
907 assert(!(d & ~((1 << 5) - 1)));
908 assert(!(a & ~((1 << 5) - 1)));
909 assert(can_zero_extend_short_p(s));
910 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
914 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
916 assert(!(o & ~((1 << 6) - 1)));
917 assert(!(s & ~((1 << 5) - 1)));
918 assert(!(a & ~((1 << 5) - 1)));
919 assert(!(b & ~((1 << 5) - 1)));
920 assert(!(x & ~((1 << 10) - 1)));
921 assert(!(r & ~((1 << 1) - 1)));
922 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
926 _FI(jit_state_t *_jit, int o, int t, int a, int k)
928 assert(!(o & ~(( 1 << 6) - 1)));
929 assert(!(t & 3) && can_sign_extend_jump_p(t));
930 assert(!(a & ~(( 1 << 1) - 1)));
931 assert(!(k & ~(( 1 << 1) - 1)));
932 ii((o<<26)|_u26(t)|(a<<1)|k);
936 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
938 assert(!( o & ~((1 << 6) - 1)));
939 assert(!(bo & ~((1 << 5) - 1)));
940 assert(!(bi & ~((1 << 5) - 1)));
941 assert(!(t & 3) && can_sign_extend_short_p(t));
942 assert(!(a & ~(( 1 << 1) - 1)));
943 assert(!(k & ~(( 1 << 1) - 1)));
944 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
948 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
950 assert(!( o & ~((1 << 6) - 1)));
951 assert(!(bo & ~((1 << 5) - 1)));
952 assert(!(bi & ~((1 << 5) - 1)));
953 assert(!(x & ~(( 1 << 10) - 1)));
954 assert(!(k & ~(( 1 << 1) - 1)));
955 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
959 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
961 assert(!(o & ~((1 << 6) - 1)));
962 assert(!(d & ~((1 << 3) - 1)));
963 assert(!(l & ~((1 << 1) - 1)));
964 assert(!(a & ~((1 << 5) - 1)));
965 assert(!(b & ~((1 << 5) - 1)));
966 assert(!(x & ~((1 << 10) - 1)));
967 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
971 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
973 assert(!(o & ~((1 << 6) - 1)));
974 assert(!(d & ~((1 << 3) - 1)));
975 assert(!(l & ~((1 << 1) - 1)));
976 assert(!(a & ~((1 << 5) - 1)));
977 if (o == 11) assert(can_sign_extend_short_p(s));
978 else if (o == 10) assert(can_zero_extend_short_p(s));
982 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
986 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
988 assert(!(o & ~((1 << 6) - 1)));
989 assert(!(d & ~((1 << 5) - 1)));
990 assert(!(x & ~((1 << 10) - 1)));
991 assert(!(f & ~((1 << 10) - 1)));
992 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
996 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
998 assert(!(o & ~((1 << 6) - 1)));
999 assert(!(s & ~((1 << 5) - 1)));
1000 assert(!(a & ~((1 << 5) - 1)));
1001 assert(!(h & ~((1 << 5) - 1)));
1002 assert(!(b & ~((1 << 5) - 1)));
1003 assert(!(e & ~((1 << 5) - 1)));
1004 assert(!(r & ~((1 << 1) - 1)));
1005 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1008 # if __WORDSIZE == 64
1010 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1012 assert(!(o & ~((1 << 6) - 1)));
1013 assert(!(s & ~((1 << 5) - 1)));
1014 assert(!(a & ~((1 << 5) - 1)));
1015 assert(!(b & ~((1 << 5) - 1)));
1016 assert(!(e & ~((1 << 6) - 1)));
1017 assert(!(x & ~((1 << 4) - 1)));
1018 assert(!(r & ~((1 << 1) - 1)));
1019 e = (e >> 5) | ((e << 1) & 63);
1020 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1024 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1026 assert(!(o & ~((1 << 6) - 1)));
1027 assert(!(s & ~((1 << 5) - 1)));
1028 assert(!(a & ~((1 << 5) - 1)));
1029 assert(!(h & ~((1 << 5) - 1)));
1030 assert(!(e & ~((1 << 6) - 1)));
1031 assert(!(x & ~((1 << 3) - 1)));
1032 assert(!(i & ~((1 << 1) - 1)));
1033 assert(!(r & ~((1 << 1) - 1)));
1034 e = (e >> 5) | ((e << 1) & 63);
1035 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1039 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1041 assert(!(o & ~((1 << 6) - 1)));
1042 assert(!(s & ~((1 << 5) - 1)));
1043 assert(!(a & ~((1 << 5) - 1)));
1044 assert(!(h & ~((1 << 5) - 1)));
1045 assert(!(x & ~((1 << 9) - 1)));
1046 assert(!(i & ~((1 << 1) - 1)));
1047 assert(!(r & ~((1 << 1) - 1)));
1048 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1054 * Use the sequence commented at
1055 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1058 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1061 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1063 MTCRF(128, rn(reg));
1064 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1071 _nop(jit_state_t *_jit, jit_int32_t i0)
1073 for (; i0 > 0; i0 -= 4)
1079 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1086 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1088 if (can_sign_extend_short_p(i0))
1091 if (can_sign_extend_int_p(i0))
1092 LIS(r0, (jit_int16_t)(i0 >> 16));
1093 else if (can_zero_extend_int_p(i0)) {
1094 if (i0 & 0xffff0000) {
1095 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1099 # if __WORDSIZE == 64
1101 movi(r0, (jit_uint32_t)(i0 >> 32));
1102 if (i0 & 0xffff0000) {
1104 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1112 ORI(r0, r0, (jit_uint16_t)i0);
1117 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1125 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1133 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1135 jit_word_t word = _jit->pc.w;
1136 # if __WORDSIZE == 32
1137 LIS(r0, (jit_int16_t)(i0 >> 16));
1138 ORI(r0, r0, (jit_uint16_t)i0);
1140 LIS(r0, (jit_int16_t)(i0 >> 48));
1141 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1143 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1145 ORI(r0, r0, (jit_uint16_t)i0);
1151 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1154 RLWIMI(r0, r0, 16, 8, 15);
1155 RLWINM(r0, r0, 24, 16, 31);
1157 RLWINM(r0, r1, 8, 16, 23);
1158 RLWIMI(r0, r1, 24, 24, 31);
1163 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1166 reg = jit_get_reg(jit_class_gpr);
1167 ROTLWI(rn(reg), r1, 8);
1168 RLWIMI(rn(reg), r1, 24, 0, 7);
1169 RLWIMI(rn(reg), r1, 24, 16, 23);
1170 # if __WORDSIZE == 64
1171 CLRLDI(r0, rn(reg), 32);
1179 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1182 if (can_sign_extend_short_p(i0))
1184 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1185 ADDIS(r0, r1, i0 >> 16);
1187 reg = jit_get_reg(jit_class_gpr);
1189 ADD(r0, r1, rn(reg));
1195 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1198 if (can_sign_extend_short_p(i0))
1201 reg = jit_get_reg(jit_class_gpr);
1203 ADDC(r0, r1, rn(reg));
1209 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1212 reg = jit_get_reg(jit_class_gpr);
1214 ADDE(r0, r1, rn(reg));
1219 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1222 jit_word_t ni0 = -i0;
1223 if (can_sign_extend_short_p(ni0))
1225 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1226 ADDIS(r0, r1, ni0 >> 16);
1228 reg = jit_get_reg(jit_class_gpr);
1230 SUB(r0, r1, rn(reg));
1236 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1239 reg = jit_get_reg(jit_class_gpr);
1241 SUBC(r0, r1, rn(reg));
1246 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1249 reg = jit_get_reg(jit_class_gpr);
1251 SUBE(r0, r1, rn(reg));
1256 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1263 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1266 if (can_sign_extend_short_p(i0))
1269 reg = jit_get_reg(jit_class_gpr);
1271 mulr(r0, r1, rn(reg));
1277 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1278 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1281 if (r0 == r2 || r0 == r3) {
1282 reg = jit_get_reg(jit_class_gpr);
1283 mullr(rn(reg), r2, r3);
1290 mulhr_u(r1, r2, r3);
1291 if (r0 == r2 || r0 == r3) {
1298 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1299 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1302 reg = jit_get_reg(jit_class_gpr);
1304 iqmulr(r0, r1, r2, rn(reg), sign);
1309 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1312 reg = jit_get_reg(jit_class_gpr);
1314 divr(r0, r1, rn(reg));
1319 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1322 reg = jit_get_reg(jit_class_gpr);
1324 divr_u(r0, r1, rn(reg));
1329 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1330 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1332 jit_int32_t sv0, rg0;
1333 jit_int32_t sv1, rg1;
1335 if (r0 == r2 || r0 == r3) {
1336 sv0 = jit_get_reg(jit_class_gpr);
1341 if (r1 == r2 || r1 == r3) {
1342 sv1 = jit_get_reg(jit_class_gpr);
1351 divr_u(rg0, r2, r3);
1365 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1366 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1369 reg = jit_get_reg(jit_class_gpr);
1371 iqdivr(r0, r1, r2, rn(reg), sign);
1376 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1379 if (r0 == r1 || r0 == r2) {
1380 reg = jit_get_reg(jit_class_gpr);
1381 divr(rn(reg), r1, r2);
1382 mulr(rn(reg), r2, rn(reg));
1383 subr(r0, r1, rn(reg));
1394 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1397 reg = jit_get_reg(jit_class_gpr);
1399 remr(r0, r1, rn(reg));
1404 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1407 if (r0 == r1 || r0 == r2) {
1408 reg = jit_get_reg(jit_class_gpr);
1409 divr_u(rn(reg), r1, r2);
1410 mulr(rn(reg), r2, rn(reg));
1411 subr(r0, r1, rn(reg));
1422 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1425 reg = jit_get_reg(jit_class_gpr);
1427 remr_u(r0, r1, rn(reg));
1432 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1435 if (can_zero_extend_short_p(i0))
1437 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1438 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1440 reg = jit_get_reg(jit_class_gpr);
1442 AND(r0, r1, rn(reg));
1448 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1451 if (can_zero_extend_short_p(i0))
1453 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1454 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1456 reg = jit_get_reg(jit_class_gpr);
1458 OR(r0, r1, rn(reg));
1464 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1467 if (can_zero_extend_short_p(i0))
1469 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1470 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1472 reg = jit_get_reg(jit_class_gpr);
1474 XOR(r0, r1, rn(reg));
1480 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1485 # if __WORDSIZE == 32
1494 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1499 # if __WORDSIZE == 32
1508 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1513 # if __WORDSIZE == 32
1522 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1526 EXTRWI(r0, r0, 1, CR_LT);
1530 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1533 if (can_sign_extend_short_p(i0))
1536 reg = jit_get_reg(jit_class_gpr);
1542 EXTRWI(r0, r0, 1, CR_LT);
1546 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1550 EXTRWI(r0, r0, 1, CR_LT);
1554 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1557 if (can_zero_extend_short_p(i0))
1560 reg = jit_get_reg(jit_class_gpr);
1566 EXTRWI(r0, r0, 1, CR_LT);
1570 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1573 CRNOT(CR_GT, CR_GT);
1575 EXTRWI(r0, r0, 1, CR_GT);
1579 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1582 if (can_sign_extend_short_p(i0))
1585 reg = jit_get_reg(jit_class_gpr);
1590 CRNOT(CR_GT, CR_GT);
1592 EXTRWI(r0, r0, 1, CR_GT);
1596 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1599 CRNOT(CR_GT, CR_GT);
1601 EXTRWI(r0, r0, 1, CR_GT);
1605 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1608 if (can_zero_extend_short_p(i0))
1611 reg = jit_get_reg(jit_class_gpr);
1616 CRNOT(CR_GT, CR_GT);
1618 EXTRWI(r0, r0, 1, CR_GT);
1622 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1626 EXTRWI(r0, r0, 1, CR_EQ);
1630 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1633 if (can_sign_extend_short_p(i0))
1635 else if (can_zero_extend_short_p(i0))
1638 reg = jit_get_reg(jit_class_gpr);
1644 EXTRWI(r0, r0, 1, CR_EQ);
1648 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1651 CRNOT(CR_LT, CR_LT);
1653 EXTRWI(r0, r0, 1, CR_LT);
1657 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1660 if (can_sign_extend_short_p(i0))
1663 reg = jit_get_reg(jit_class_gpr);
1668 CRNOT(CR_LT, CR_LT);
1670 EXTRWI(r0, r0, 1, CR_LT);
1674 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1677 CRNOT(CR_LT, CR_LT);
1679 EXTRWI(r0, r0, 1, CR_LT);
1683 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1686 if (can_zero_extend_short_p(i0))
1689 reg = jit_get_reg(jit_class_gpr);
1694 CRNOT(CR_LT, CR_LT);
1696 EXTRWI(r0, r0, 1, CR_LT);
1700 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1704 EXTRWI(r0, r0, 1, CR_GT);
1708 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1711 if (can_sign_extend_short_p(i0))
1714 reg = jit_get_reg(jit_class_gpr);
1720 EXTRWI(r0, r0, 1, CR_GT);
1724 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1728 EXTRWI(r0, r0, 1, CR_GT);
1732 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1735 if (can_zero_extend_short_p(i0))
1738 reg = jit_get_reg(jit_class_gpr);
1744 EXTRWI(r0, r0, 1, CR_GT);
1748 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1751 CRNOT(CR_EQ, CR_EQ);
1753 EXTRWI(r0, r0, 1, CR_EQ);
1757 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1760 if (can_sign_extend_short_p(i0))
1762 else if (can_zero_extend_short_p(i0))
1765 reg = jit_get_reg(jit_class_gpr);
1770 CRNOT(CR_EQ, CR_EQ);
1772 EXTRWI(r0, r0, 1, CR_EQ);
1776 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1787 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1791 if (can_sign_extend_short_p(i1))
1794 reg = jit_get_reg(jit_class_gpr);
1806 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1817 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1821 if (can_zero_extend_short_p(i1))
1824 reg = jit_get_reg(jit_class_gpr);
1836 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1847 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1851 if (can_sign_extend_short_p(i1))
1854 reg = jit_get_reg(jit_class_gpr);
1866 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1877 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1881 if (can_zero_extend_short_p(i1))
1884 reg = jit_get_reg(jit_class_gpr);
1896 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1907 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1911 if (can_sign_extend_short_p(i1))
1913 else if (can_zero_extend_short_p(i1))
1916 reg = jit_get_reg(jit_class_gpr);
1928 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1939 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1943 if (can_sign_extend_short_p(i1))
1946 reg = jit_get_reg(jit_class_gpr);
1958 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1969 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1973 if (can_zero_extend_short_p(i1))
1976 reg = jit_get_reg(jit_class_gpr);
1988 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1999 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2003 if (can_sign_extend_short_p(i1))
2006 reg = jit_get_reg(jit_class_gpr);
2018 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2029 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2033 if (can_zero_extend_short_p(i1))
2036 reg = jit_get_reg(jit_class_gpr);
2048 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2059 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2063 if (can_sign_extend_short_p(i1))
2065 else if (can_zero_extend_short_p(i1))
2068 reg = jit_get_reg(jit_class_gpr);
2080 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2084 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2085 andr(rn(reg), r0, r1);
2086 w = bnei(i0, rn(reg), 0);
2092 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2096 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2097 andi(rn(reg), r0, i1);
2098 w = bnei(i0, rn(reg), 0);
2104 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2108 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2109 andr(rn(reg), r0, r1);
2110 w = beqi(i0, rn(reg), 0);
2116 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2120 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2121 andi(rn(reg), r0, i1);
2122 w = beqi(i0, rn(reg), 0);
2128 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2135 BGT(d); /* GT = bit 1 of XER = OV */
2140 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2144 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2146 w = boaddr(i0, r0, rn(reg));
2152 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2164 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2168 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2170 w = bxaddr(i0, r0, rn(reg));
2176 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2188 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2192 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2194 w = bosubr(i0, r0, rn(reg));
2200 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2212 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2216 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2218 w = bxsubr(i0, r0, rn(reg));
2224 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2231 BEQ(d); /* EQ = bit 2 of XER = CA */
2236 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2240 if (can_sign_extend_short_p(i1)) {
2248 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2250 w = boaddr_u(i0, r0, rn(reg));
2256 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2268 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2272 if (can_sign_extend_short_p(i1)) {
2280 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2282 w = bxaddr_u(i0, r0, rn(reg));
2288 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2295 BNE(d); /* PPC uses "carry" not "borrow" */
2300 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2304 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2306 w = bosubr_u(i0, r0, rn(reg));
2312 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2324 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2328 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2330 w = bxsubr_u(i0, r0, rn(reg));
2336 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2343 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2350 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2352 ldxr_uc(r0, r1, r2);
2357 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2359 ldxi_uc(r0, r1, i0);
2364 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2369 if (can_sign_extend_short_p(i0))
2370 LBZ(r0, _R0_REGNO, i0);
2371 else if (can_sign_extend_int_p(i0)) {
2372 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2373 lo = (jit_int16_t)(i0 - (hi << 16));
2374 reg = jit_get_reg(jit_class_gpr);
2375 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2377 LBZ(r0, rn(reg), lo);
2379 if (inv) jit_unget_reg(_R0);
2382 reg = jit_get_reg(jit_class_gpr);
2384 ldr_uc(r0, rn(reg));
2390 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2393 if (r1 == _R0_REGNO) {
2394 if (r2 != _R0_REGNO)
2397 reg = jit_get_reg(jit_class_gpr);
2399 LBZX(r0, rn(reg), r2);
2408 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2413 else if (can_sign_extend_short_p(i0)) {
2414 if (r1 == _R0_REGNO) {
2415 reg = jit_get_reg(jit_class_gpr);
2417 LBZ(r0, rn(reg), i0);
2424 reg = jit_get_reg(jit_class_gpr);
2426 ldxr_uc(r0, r1, rn(reg));
2432 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2437 if (can_sign_extend_short_p(i0))
2438 LHA(r0, _R0_REGNO, i0);
2439 else if (can_sign_extend_int_p(i0)) {
2440 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2441 lo = (jit_int16_t)(i0 - (hi << 16));
2442 reg = jit_get_reg(jit_class_gpr);
2443 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2445 LHA(r0, rn(reg), lo);
2447 if (inv) jit_unget_reg(_R0);
2450 reg = jit_get_reg(jit_class_gpr);
2458 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2461 if (r1 == _R0_REGNO) {
2462 if (r2 != _R0_REGNO)
2465 reg = jit_get_reg(jit_class_gpr);
2467 LHAX(r0, rn(reg), r2);
2476 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2481 else if (can_sign_extend_short_p(i0)) {
2482 if (r1 == _R0_REGNO) {
2483 reg = jit_get_reg(jit_class_gpr);
2485 LHA(r0, rn(reg), i0);
2492 reg = jit_get_reg(jit_class_gpr);
2494 ldxr_s(r0, r1, rn(reg));
2500 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2505 if (can_sign_extend_short_p(i0))
2506 LHZ(r0, _R0_REGNO, i0);
2507 else if (can_sign_extend_int_p(i0)) {
2508 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2509 lo = (jit_int16_t)(i0 - (hi << 16));
2510 reg = jit_get_reg(jit_class_gpr);
2511 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2513 LHZ(r0, rn(reg), lo);
2515 if (inv) jit_unget_reg(_R0);
2518 reg = jit_get_reg(jit_class_gpr);
2520 ldr_us(r0, rn(reg));
2526 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2529 if (r1 == _R0_REGNO) {
2530 if (r2 != _R0_REGNO)
2533 reg = jit_get_reg(jit_class_gpr);
2535 LHZX(r0, rn(reg), r2);
2544 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2549 else if (can_sign_extend_short_p(i0)) {
2550 if (r1 == _R0_REGNO) {
2551 reg = jit_get_reg(jit_class_gpr);
2553 LHZ(r0, rn(reg), i0);
2560 reg = jit_get_reg(jit_class_gpr);
2562 ldxr_us(r0, r1, rn(reg));
2567 # if __WORDSIZE == 32
2569 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2574 if (can_sign_extend_short_p(i0))
2575 LWZ(r0, _R0_REGNO, i0);
2576 else if (can_sign_extend_int_p(i0)) {
2577 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2578 lo = (jit_int16_t)(i0 - (hi << 16));
2579 reg = jit_get_reg(jit_class_gpr);
2580 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2582 LWZ(r0, rn(reg), lo);
2584 if (inv) jit_unget_reg(_R0);
2587 reg = jit_get_reg(jit_class_gpr);
2595 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2598 if (r1 == _R0_REGNO) {
2599 if (r2 != _R0_REGNO)
2602 reg = jit_get_reg(jit_class_gpr);
2604 LWZX(r0, rn(reg), r2);
2613 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2618 else if (can_sign_extend_short_p(i0)) {
2619 if (r1 == _R0_REGNO) {
2620 reg = jit_get_reg(jit_class_gpr);
2622 LWZ(r0, rn(reg), i0);
2629 reg = jit_get_reg(jit_class_gpr);
2631 ldxr_i(r0, r1, rn(reg));
2638 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2643 if (can_sign_extend_short_p(i0))
2644 LWA(r0, _R0_REGNO, i0);
2645 else if (can_sign_extend_int_p(i0)) {
2646 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2647 lo = (jit_int16_t)(i0 - (hi << 16));
2648 reg = jit_get_reg(jit_class_gpr);
2649 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2651 LWA(r0, rn(reg), lo);
2653 if (inv) jit_unget_reg(_R0);
2656 reg = jit_get_reg(jit_class_gpr);
2664 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2667 if (r1 == _R0_REGNO) {
2668 if (r2 != _R0_REGNO)
2671 reg = jit_get_reg(jit_class_gpr);
2673 LWAX(r0, rn(reg), r2);
2682 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2687 else if (can_sign_extend_short_p(i0)) {
2688 if (r1 == _R0_REGNO) {
2689 reg = jit_get_reg(jit_class_gpr);
2691 LWA(r0, rn(reg), i0);
2698 reg = jit_get_reg(jit_class_gpr);
2700 ldxr_i(r0, r1, rn(reg));
2706 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2711 if (can_sign_extend_short_p(i0))
2712 LWZ(r0, _R0_REGNO, i0);
2713 else if (can_sign_extend_int_p(i0)) {
2714 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2715 lo = (jit_int16_t)(i0 - (hi << 16));
2716 reg = jit_get_reg(jit_class_gpr);
2717 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2719 LWZ(r0, rn(reg), lo);
2721 if (inv) jit_unget_reg(_R0);
2724 reg = jit_get_reg(jit_class_gpr);
2726 ldr_ui(r0, rn(reg));
2732 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2735 if (r1 == _R0_REGNO) {
2736 if (r2 != _R0_REGNO)
2739 reg = jit_get_reg(jit_class_gpr);
2741 LWZX(r0, rn(reg), r2);
2750 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2755 else if (can_sign_extend_short_p(i0)) {
2756 if (r1 == _R0_REGNO) {
2757 reg = jit_get_reg(jit_class_gpr);
2759 LWZ(r0, rn(reg), i0);
2766 reg = jit_get_reg(jit_class_gpr);
2768 ldxr_ui(r0, r1, rn(reg));
2774 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2779 if (can_sign_extend_short_p(i0))
2780 LD(r0, _R0_REGNO, i0);
2781 else if (can_sign_extend_int_p(i0)) {
2782 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2783 lo = (jit_int16_t)(i0 - (hi << 16));
2784 reg = jit_get_reg(jit_class_gpr);
2785 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2787 LD(r0, rn(reg), lo);
2789 if (inv) jit_unget_reg(_R0);
2792 reg = jit_get_reg(jit_class_gpr);
2800 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2803 if (r1 == _R0_REGNO) {
2804 if (r2 != _R0_REGNO)
2807 reg = jit_get_reg(jit_class_gpr);
2809 LDX(r0, rn(reg), r2);
2818 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2823 else if (can_sign_extend_short_p(i0)) {
2824 if (r1 == _R0_REGNO) {
2825 reg = jit_get_reg(jit_class_gpr);
2827 LD(r0, rn(reg), i0);
2834 reg = jit_get_reg(jit_class_gpr);
2836 ldxr_l(r0, r1, rn(reg));
2843 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2848 if (can_sign_extend_short_p(i0))
2849 STB(r0, _R0_REGNO, i0);
2850 else if (can_sign_extend_int_p(i0)) {
2851 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2852 lo = (jit_int16_t)(i0 - (hi << 16));
2853 reg = jit_get_reg(jit_class_gpr);
2854 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2856 STB(r0, rn(reg), lo);
2858 if (inv) jit_unget_reg(_R0);
2861 reg = jit_get_reg(jit_class_gpr);
2869 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2872 if (r0 == _R0_REGNO) {
2873 if (r1 != _R0_REGNO)
2876 reg = jit_get_reg(jit_class_gpr);
2878 STBX(r2, rn(reg), r1);
2887 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2892 else if (can_sign_extend_short_p(i0)) {
2893 if (r0 == _R0_REGNO) {
2894 reg = jit_get_reg(jit_class_gpr);
2896 STB(r1, rn(reg), i0);
2903 reg = jit_get_reg(jit_class_gpr);
2905 stxr_c(rn(reg), r0, r1);
2911 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2916 if (can_sign_extend_short_p(i0))
2917 STH(r0, _R0_REGNO, i0);
2918 else if (can_sign_extend_int_p(i0)) {
2919 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2920 lo = (jit_int16_t)(i0 - (hi << 16));
2921 reg = jit_get_reg(jit_class_gpr);
2922 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2924 STH(r0, rn(reg), lo);
2926 if (inv) jit_unget_reg(_R0);
2929 reg = jit_get_reg(jit_class_gpr);
2937 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2940 if (r0 == _R0_REGNO) {
2941 if (r1 != _R0_REGNO)
2944 reg = jit_get_reg(jit_class_gpr);
2946 STHX(r2, rn(reg), r1);
2955 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2960 else if (can_sign_extend_short_p(i0)) {
2961 if (r0 == _R0_REGNO) {
2962 reg = jit_get_reg(jit_class_gpr);
2964 STH(r1, rn(reg), i0);
2971 reg = jit_get_reg(jit_class_gpr);
2973 stxr_s(rn(reg), r0, r1);
2979 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2984 if (can_sign_extend_short_p(i0))
2985 STW(r0, _R0_REGNO, i0);
2986 else if (can_sign_extend_int_p(i0)) {
2987 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2988 lo = (jit_int16_t)(i0 - (hi << 16));
2989 reg = jit_get_reg(jit_class_gpr);
2990 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2992 STW(r0, rn(reg), lo);
2994 if (inv) jit_unget_reg(_R0);
2997 reg = jit_get_reg(jit_class_gpr);
3005 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3008 if (r0 == _R0_REGNO) {
3009 if (r1 != _R0_REGNO)
3012 reg = jit_get_reg(jit_class_gpr);
3014 STWX(r2, rn(reg), r1);
3023 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3028 else if (can_sign_extend_short_p(i0)) {
3029 if (r0 == _R0_REGNO) {
3030 reg = jit_get_reg(jit_class_gpr);
3032 STW(r1, rn(reg), i0);
3039 reg = jit_get_reg(jit_class_gpr);
3041 stxr_i(rn(reg), r0, r1);
3046 # if __WORDSIZE == 64
3048 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3053 if (can_sign_extend_short_p(i0))
3054 STD(r0, _R0_REGNO, i0);
3055 else if (can_sign_extend_int_p(i0)) {
3056 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3057 lo = (jit_int16_t)(i0 - (hi << 16));
3058 reg = jit_get_reg(jit_class_gpr);
3059 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3061 STD(r0, rn(reg), lo);
3063 if (inv) jit_unget_reg(_R0);
3066 reg = jit_get_reg(jit_class_gpr);
3074 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3077 if (r0 == _R0_REGNO) {
3078 if (r1 != _R0_REGNO)
3081 reg = jit_get_reg(jit_class_gpr);
3083 STDX(r2, rn(reg), r1);
3092 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3097 else if (can_sign_extend_short_p(i0)) {
3098 if (r0 == _R0_REGNO) {
3099 reg = jit_get_reg(jit_class_gpr);
3101 STD(r1, rn(reg), i0);
3108 reg = jit_get_reg(jit_class_gpr);
3110 stxr_l(rn(reg), r0, r1);
3117 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3128 /* pc relative jump */
3130 _jmpi(jit_state_t *_jit, jit_word_t i0)
3136 if (can_sign_extend_jump_p(d))
3139 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3140 w = movi_p(rn(reg), i0);
3149 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3153 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3154 w = movi_p(rn(reg), i0);
3161 _callr(jit_state_t *_jit, jit_int32_t r0
3163 , jit_int32_t varargs
3168 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3169 /* FIXME Pretend to not know about r11? */
3170 if (r0 == _R0_REGNO) {
3171 movr(_R11_REGNO, _R0_REGNO);
3172 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3173 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3176 ldxi(_R2_REGNO, r0, sizeof(void*));
3177 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3182 /* Tell double arguments were passed in registers. */
3186 movr(_R12_REGNO, r0);
3193 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3197 /* assume fixed address or reachable address */
3199 _calli(jit_state_t *_jit, jit_word_t i0
3201 , jit_int32_t varargs
3207 d = (i0 - _jit->pc.w) & ~3;
3208 if (can_sign_extend_jump_p(d))
3213 movi(_R12_REGNO, i0);
3224 _calli_p(jit_state_t *_jit, jit_word_t i0
3226 , jit_int32_t varargs
3231 w = movi_p(_R12_REGNO, i0);
3240 /* order is not guaranteed to be sequential */
3241 static jit_int32_t save[] = {
3242 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3243 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3247 _prolog(jit_state_t *_jit, jit_node_t *node)
3249 unsigned long regno;
3252 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3253 jit_int32_t frame = -_jitc->function->frame;
3254 assert(_jitc->function->self.aoff >= frame);
3255 if (_jitc->function->assume_frame)
3257 _jitc->function->self.aoff = frame;
3259 if (_jitc->function->allocar) {
3260 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3261 _jitc->function->self.aoff &= -16;
3263 _jitc->function->stack = ((_jitc->function->self.alen +
3264 _jitc->function->self.size -
3265 _jitc->function->self.aoff) + 15) & -16;
3267 /* return address */
3270 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3271 * alloca < %r31-80 */
3274 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3276 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3278 offset = -gpr_save_area;
3279 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3280 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3281 stxi(offset, _SP_REGNO, rn(save[regno]));
3283 for (offset = 0; offset < 8; offset++) {
3284 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3285 stxi_d(-(gpr_save_area + 8 + offset * 8),
3286 _SP_REGNO, rn(_F14 + offset));
3289 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3291 movr(_FP_REGNO, _SP_REGNO);
3292 #if __WORDSIZE == 32
3293 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3295 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3298 if (_jitc->function->allocar) {
3299 regno = jit_get_reg(jit_class_gpr);
3300 movi(rn(regno), _jitc->function->self.aoff);
3301 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3302 jit_unget_reg(regno);
3306 if (_jitc->function->self.call & jit_call_varargs) {
3307 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3308 stxi(params_offset + regno * sizeof(jit_word_t),
3309 _FP_REGNO, rn(JIT_RA0 - regno));
3312 if (_jitc->function->self.call & jit_call_varargs) {
3313 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3314 stxi(_jitc->function->vaoff + first_gp_offset +
3315 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3316 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3317 stxi_d(_jitc->function->vaoff + first_fp_offset +
3318 regno * va_fp_increment, _FP_REGNO,
3319 rn(JIT_FA0 - regno));
3325 _epilog(jit_state_t *_jit, jit_node_t *node)
3327 unsigned long regno;
3330 if (_jitc->function->assume_frame)
3332 if (_jitc->function->allocar)
3333 ldr(_SP_REGNO, _SP_REGNO);
3335 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3337 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3339 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3341 offset = -gpr_save_area;
3342 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3343 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3344 ldxi(rn(save[regno]), _SP_REGNO, offset);
3346 for (offset = 0; offset < 8; offset++) {
3347 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3348 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3349 -(gpr_save_area + 8 + offset * 8));
3353 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3359 _vastart(jit_state_t *_jit, jit_int32_t r0)
3362 assert(_jitc->function->self.call & jit_call_varargs);
3363 /* Initialize stack pointer to the first stack argument. */
3364 addi(r0, _FP_REGNO, _jitc->function->self.size);
3367 assert(_jitc->function->self.call & jit_call_varargs);
3369 /* Return jit_va_list_t in the register argument */
3370 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3371 reg = jit_get_reg(jit_class_gpr);
3373 /* Initialize the gp counter. */
3374 movi(rn(reg), _jitc->function->vagp);
3375 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3377 /* Initialize the fp counter. */
3378 movi(rn(reg), _jitc->function->vafp);
3379 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3381 /* Initialize overflow pointer to the first stack argument. */
3382 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3383 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3385 /* Initialize register save area pointer. */
3386 addi(rn(reg), r0, first_gp_offset);
3387 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3394 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3397 assert(_jitc->function->self.call & jit_call_varargs);
3398 /* Load argument. */
3400 /* Update va_list. */
3401 addi(r1, r1, sizeof(jit_word_t));
3408 assert(_jitc->function->self.call & jit_call_varargs);
3410 rg0 = jit_get_reg(jit_class_gpr);
3411 rg1 = jit_get_reg(jit_class_gpr);
3413 /* Load the gp offset in save area in the first temporary. */
3414 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3416 /* Jump over if there are no remaining arguments in the save area. */
3417 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3419 /* Update the gp counter. */
3420 addi(rn(rg1), rn(rg0), 1);
3421 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3423 /* Load the save area pointer in the second temporary. */
3424 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3426 /* Load the vararg argument in the first argument. */
3427 lshi(rn(rg0), rn(rg0), va_gp_shift);
3428 ldxr(r0, rn(rg1), rn(rg0));
3430 /* Will only need one temporary register below. */
3433 /* Jump over overflow code. */
3434 lt_code = _jit->pc.w;
3437 /* Where to land if argument is in overflow area. */
3438 patch_at(ge_code, _jit->pc.w);
3440 /* Load overflow pointer. */
3441 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3443 /* Load argument. */
3446 /* Update overflow pointer. */
3447 addi(rn(rg0), rn(rg0), va_gp_increment);
3448 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3450 /* Where to land if argument is in save area. */
3451 patch_at(lt_code, _jit->pc.w);
3458 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3461 assert(_jitc->function->self.call & jit_call_varargs);
3462 /* Load argument. */
3464 /* Update va_list. */
3465 addi(r1, r1, sizeof(jit_float64_t));
3472 assert(_jitc->function->self.call & jit_call_varargs);
3474 rg0 = jit_get_reg(jit_class_gpr);
3475 rg1 = jit_get_reg(jit_class_gpr);
3477 /* Load the fp offset in save area in the first temporary. */
3478 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3480 /* Jump over if there are no remaining arguments in the save area. */
3481 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3483 /* Update the fp counter. */
3484 addi(rn(rg1), rn(rg0), 1);
3485 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3487 /* Load the save area pointer in the second temporary. */
3488 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3490 /* Load the vararg argument in the first argument. */
3491 lshi(rn(rg0), rn(rg0), 3);
3492 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3493 offsetof(jit_va_list_t, first_gp_argument));
3494 ldxr_d(r0, rn(rg1), rn(rg0));
3496 /* Jump over overflow code. */
3497 lt_code = _jit->pc.w;
3500 /* Where to land if argument is in overflow area. */
3501 patch_at(ge_code, _jit->pc.w);
3503 /* Load overflow pointer. */
3504 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3506 # if __WORDSIZE == 32
3507 /* Align if required. */
3508 andi(rn(rg1), rn(rg0), 7);
3509 addr(rn(rg0), rn(rg0), rn(rg1));
3512 /* Load argument. */
3515 /* Update overflow pointer. */
3516 addi(rn(rg0), rn(rg0), va_fp_increment);
3517 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3519 /* Where to land if argument is in save area. */
3520 patch_at(lt_code, _jit->pc.w);
3528 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3536 switch ((u.i[0] & 0xfc000000) >> 26) {
3540 if (!can_sign_extend_short_p(d)) {
3541 /* use absolute address */
3542 assert(can_sign_extend_short_p(label));
3545 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3549 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3550 /* zero is used for toc and env, so, quick check
3551 * if this is a "jmpi main" like initial jit
3553 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3554 for (d = 0; d < _jitc->prolog.offset; d++) {
3555 /* not so pretty, but hides powerpc
3556 * specific abi intrinsics and/or
3557 * implementation from user */
3558 if (_jitc->prolog.ptr[d] == label) {
3559 label += sizeof(void*) * 3;
3568 if (!can_sign_extend_jump_p(d)) {
3569 /* use absolute address */
3570 assert(can_sign_extend_jump_p(label));
3573 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3576 #if __WORDSIZE == 32
3577 # define MTCTR_OFF 2
3580 # define MTCTR_OFF 6
3584 /* movi reg label; jmpr reg */
3587 /* check for MLTR(reg) */
3588 (u.i[MTCTR_OFF] >> 26) == 31 &&
3589 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3590 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3592 u.i[BCTR_OFF] == 0x4e800020) {
3594 /* check for MTCTR(reg) */
3595 (u.i[MTCTR_OFF] >> 26) == 31 &&
3596 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3597 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3598 /* check for BCTR */
3599 u.i[BCTR_OFF] == 0x4e800420) {
3601 /* zero is used for toc and env, so, quick check
3602 * if this is a "jmpi main" like initial jit
3604 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3605 for (d = 0; d < _jitc->prolog.offset; d++) {
3606 /* not so pretty, but hides powerpc
3607 * specific abi intrinsics and/or
3608 * implementation from user */
3609 if (_jitc->prolog.ptr[d] == label) {
3610 label += sizeof(void*) * 3;
3619 #if __WORDSIZE == 32
3620 assert(!(u.i[0] & 0x1f0000));
3621 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3622 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3623 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3624 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3626 assert(!(u.i[0] & 0x1f0000));
3627 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3628 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3629 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3630 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3631 /* not fully validating SLDI */
3632 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3633 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3634 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3635 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3636 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3637 /* not fully validating SLDI */
3638 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3639 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3640 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3641 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3642 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3646 assert(!"unhandled branch opcode");