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 movi_p(r0,i0) _movi_p(_jit,r0,i0)
509 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
510 # define negr(r0,r1) NEG(r0,r1)
511 # define comr(r0,r1) NOT(r0,r1)
512 # define extr_c(r0,r1) EXTSB(r0,r1)
513 # define extr_uc(r0,r1) ANDI_(r0,r1,0xff)
514 # define extr_s(r0,r1) EXTSH(r0,r1)
515 # define extr_us(r0,r1) ANDI_(r0,r1,0xffff)
516 # if __WORDSIZE == 64
517 # define extr_i(r0,r1) EXTSW(r0,r1)
518 # define extr_ui(r0,r1) CLRLDI(r0,r1,32)
520 # if __BYTE_ORDER == __BIG_ENDIAN
521 # define htonr_us(r0,r1) extr_us(r0,r1)
522 # if __WORDSIZE == 32
523 # define htonr_ui(r0,r1) movr(r0,r1)
525 # define htonr_ui(r0,r1) extr_ui(r0,r1)
526 # define htonr_ul(r0,r1) movr(r0,r1)
529 # define htonr_us(r0,r1) _htonr_us(_jit,r0,r1)
530 static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
531 # define htonr_ui(r0,r1) _htonr_ui(_jit,r0,r1)
532 static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
533 # if __WORDSIZE == 64
534 # define htonr_ul(r0,r1) _htonr_ul(_jit,r0,r1)
535 static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
538 # define addr(r0,r1,r2) ADD(r0,r1,r2)
539 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
540 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
541 # define addcr(r0,r1,r2) ADDC(r0,r1,r2)
542 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
543 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
544 # define addxr(r0,r1,r2) ADDE(r0,r1,r2)
545 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
546 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
547 # define subr(r0,r1,r2) SUB(r0,r1,r2)
548 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
549 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
550 # define subcr(r0,r1,r2) SUBC(r0,r1,r2)
551 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
552 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
553 # define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
554 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
555 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
556 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
557 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
558 # if __WORDSIZE == 32
559 # define mulr(r0,r1,r2) MULLW(r0,r1,r2)
560 # define mullr(r0,r1,r2) MULLW(r0,r1,r2)
561 # define mulhr(r0,r1,r2) MULHW(r0,r1,r2)
562 # define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2)
564 # define mulr(r0,r1,r2) MULLD(r0,r1,r2)
565 # define mullr(r0,r1,r2) MULLD(r0,r1,r2)
566 # define mulhr(r0,r1,r2) MULHD(r0,r1,r2)
567 # define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2)
569 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
570 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
571 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
572 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
573 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
574 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
575 jit_int32_t,jit_int32_t,jit_bool_t);
576 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
577 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
578 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
579 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
580 jit_int32_t,jit_word_t,jit_bool_t);
581 # if __WORDSIZE == 32
582 # define divr(r0,r1,r2) DIVW(r0,r1,r2)
584 # define divr(r0,r1,r2) DIVD(r0,r1,r2)
586 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
587 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
588 # if __WORDSIZE == 32
589 # define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
591 # define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
593 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
594 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
595 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
596 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
597 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
598 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
599 jit_int32_t,jit_int32_t,jit_bool_t);
600 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
601 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
602 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
603 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
604 jit_int32_t,jit_word_t,jit_bool_t);
605 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
606 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
607 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
608 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
609 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
610 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
611 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
612 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
613 # define andr(r0,r1,r2) AND(r0,r1,r2)
614 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
615 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
616 # define orr(r0,r1,r2) OR(r0,r1,r2)
617 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
618 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
619 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
620 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
621 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
622 # if __WORDSIZE == 32
623 # define lshr(r0,r1,r2) SLW(r0,r1,r2)
625 # define lshr(r0,r1,r2) SLD(r0,r1,r2)
627 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
628 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
629 # if __WORDSIZE == 32
630 # define rshr(r0,r1,r2) SRAW(r0,r1,r2)
632 # define rshr(r0,r1,r2) SRAD(r0,r1,r2)
634 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
635 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
636 # if __WORDSIZE == 32
637 # define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
639 # define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
641 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
642 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
643 # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
644 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
645 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
646 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
647 # define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
648 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
649 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
650 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
651 # define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
652 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
653 # define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
654 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
655 # define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
656 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
657 # define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
658 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
659 # define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
660 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
661 # define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
662 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
663 # define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
664 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
665 # define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
666 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
667 # define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
668 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
669 # define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
670 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
671 # define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
672 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
673 # define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
674 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
675 # define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
676 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
677 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
678 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
679 # define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
680 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
681 # define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
682 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
683 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
684 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
685 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
686 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
687 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
688 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
689 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
690 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
691 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
692 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
693 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
694 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
695 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
696 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
697 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
698 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
699 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
700 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
701 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
702 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
703 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
704 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
705 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
706 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
707 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
708 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
709 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
710 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
711 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
712 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
713 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
714 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
715 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
716 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
717 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
718 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
719 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
720 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
721 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
722 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
723 #define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
724 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
725 #define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
726 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
727 #define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
728 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
729 #define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
730 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
731 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
732 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
733 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
734 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
735 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
736 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
737 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
738 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
739 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
740 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
741 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
742 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
743 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
744 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
745 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
746 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
747 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
748 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
749 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
750 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
751 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
752 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
753 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
754 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
755 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
756 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
757 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
758 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
759 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
760 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
761 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
762 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
763 # define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
764 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
765 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
766 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
767 # define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
768 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
769 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
770 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
771 # define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
772 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
773 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
774 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
775 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
776 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
777 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
778 # define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
779 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
780 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
781 # define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
782 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
783 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
784 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
785 # define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
786 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
787 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
788 # define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
789 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
790 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
791 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
792 # if __WORDSIZE == 32
793 # define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
795 # define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
797 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
798 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
799 # define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
800 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
801 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
802 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
803 # if __WORDSIZE == 64
804 # define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
805 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
806 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
807 # define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
808 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
809 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
810 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
811 # define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
812 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
813 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
814 # define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
815 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
816 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
817 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
819 # define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
820 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
821 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
822 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
823 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
824 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
825 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
826 # define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
827 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
828 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
829 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
830 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
831 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
832 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
833 # define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
834 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
835 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
836 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
837 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
838 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
839 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
840 # if __WORDSIZE == 64
841 # define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
842 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
843 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
844 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
845 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
846 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
847 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
849 # define jmpr(r0) _jmpr(_jit,r0)
850 static void _jmpr(jit_state_t*,jit_int32_t);
851 # define jmpi(i0) _jmpi(_jit,i0)
852 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
853 # define jmpi_p(i0) _jmpi_p(_jit,i0)
854 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
856 # define callr(r0,i0) _callr(_jit,r0,i0)
857 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
858 # define calli(i0,i1) _calli(_jit,i0,i1)
859 static void _calli(jit_state_t*,jit_word_t,jit_int32_t);
860 # define calli_p(i0,i1) _calli_p(_jit,i0,i1)
861 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
863 # define callr(r0) _callr(_jit,r0)
864 static void _callr(jit_state_t*,jit_int32_t);
865 # define calli(i0) _calli(_jit,i0)
866 static void _calli(jit_state_t*,jit_word_t);
867 # define calli_p(i0) _calli_p(_jit,i0)
868 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
870 # define prolog(node) _prolog(_jit, node)
871 static void _prolog(jit_state_t*, jit_node_t*);
872 # define epilog(node) _epilog(_jit, node)
873 static void _epilog(jit_state_t*, jit_node_t*);
874 # define vastart(r0) _vastart(_jit, r0)
875 static void _vastart(jit_state_t*, jit_int32_t);
876 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
877 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
878 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
879 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
880 # define patch_at(i,l) _patch_at(_jit,i,l)
881 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
885 # define _u16(v) ((v) & 0xffff)
886 # define _u26(v) ((v) & 0x3ffffff)
888 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
890 assert(!(o & ~((1 << 6) - 1)));
891 assert(!(d & ~((1 << 5) - 1)));
892 assert(!(a & ~((1 << 5) - 1)));
893 assert(!(b & ~((1 << 5) - 1)));
894 assert(!(e & ~((1 << 1) - 1)));
895 assert(!(x & ~((1 << 9) - 1)));
896 assert(!(r & ~((1 << 1) - 1)));
897 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
901 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
903 assert(!(o & ~((1 << 6) - 1)));
904 assert(!(d & ~((1 << 5) - 1)));
905 assert(!(a & ~((1 << 5) - 1)));
906 assert(can_sign_extend_short_p(s));
907 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
911 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
913 assert(!(o & ~((1 << 6) - 1)));
914 assert(!(d & ~((1 << 5) - 1)));
915 assert(!(a & ~((1 << 5) - 1)));
916 assert(can_zero_extend_short_p(s));
917 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
921 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
923 assert(!(o & ~((1 << 6) - 1)));
924 assert(!(s & ~((1 << 5) - 1)));
925 assert(!(a & ~((1 << 5) - 1)));
926 assert(!(b & ~((1 << 5) - 1)));
927 assert(!(x & ~((1 << 10) - 1)));
928 assert(!(r & ~((1 << 1) - 1)));
929 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
933 _FI(jit_state_t *_jit, int o, int t, int a, int k)
935 assert(!(o & ~(( 1 << 6) - 1)));
936 assert(!(t & 3) && can_sign_extend_jump_p(t));
937 assert(!(a & ~(( 1 << 1) - 1)));
938 assert(!(k & ~(( 1 << 1) - 1)));
939 ii((o<<26)|_u26(t)|(a<<1)|k);
943 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
945 assert(!( o & ~((1 << 6) - 1)));
946 assert(!(bo & ~((1 << 5) - 1)));
947 assert(!(bi & ~((1 << 5) - 1)));
948 assert(!(t & 3) && can_sign_extend_short_p(t));
949 assert(!(a & ~(( 1 << 1) - 1)));
950 assert(!(k & ~(( 1 << 1) - 1)));
951 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
955 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
957 assert(!( o & ~((1 << 6) - 1)));
958 assert(!(bo & ~((1 << 5) - 1)));
959 assert(!(bi & ~((1 << 5) - 1)));
960 assert(!(x & ~(( 1 << 10) - 1)));
961 assert(!(k & ~(( 1 << 1) - 1)));
962 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
966 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
968 assert(!(o & ~((1 << 6) - 1)));
969 assert(!(d & ~((1 << 3) - 1)));
970 assert(!(l & ~((1 << 1) - 1)));
971 assert(!(a & ~((1 << 5) - 1)));
972 assert(!(b & ~((1 << 5) - 1)));
973 assert(!(x & ~((1 << 10) - 1)));
974 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
978 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
980 assert(!(o & ~((1 << 6) - 1)));
981 assert(!(d & ~((1 << 3) - 1)));
982 assert(!(l & ~((1 << 1) - 1)));
983 assert(!(a & ~((1 << 5) - 1)));
984 if (o == 11) assert(can_sign_extend_short_p(s));
985 else if (o == 10) assert(can_zero_extend_short_p(s));
989 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
993 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
995 assert(!(o & ~((1 << 6) - 1)));
996 assert(!(d & ~((1 << 5) - 1)));
997 assert(!(x & ~((1 << 10) - 1)));
998 assert(!(f & ~((1 << 10) - 1)));
999 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1003 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
1005 assert(!(o & ~((1 << 6) - 1)));
1006 assert(!(s & ~((1 << 5) - 1)));
1007 assert(!(a & ~((1 << 5) - 1)));
1008 assert(!(h & ~((1 << 5) - 1)));
1009 assert(!(b & ~((1 << 5) - 1)));
1010 assert(!(e & ~((1 << 5) - 1)));
1011 assert(!(r & ~((1 << 1) - 1)));
1012 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1015 # if __WORDSIZE == 64
1017 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1019 assert(!(o & ~((1 << 6) - 1)));
1020 assert(!(s & ~((1 << 5) - 1)));
1021 assert(!(a & ~((1 << 5) - 1)));
1022 assert(!(b & ~((1 << 5) - 1)));
1023 assert(!(e & ~((1 << 6) - 1)));
1024 assert(!(x & ~((1 << 4) - 1)));
1025 assert(!(r & ~((1 << 1) - 1)));
1026 e = (e >> 5) | ((e << 1) & 63);
1027 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1031 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1033 assert(!(o & ~((1 << 6) - 1)));
1034 assert(!(s & ~((1 << 5) - 1)));
1035 assert(!(a & ~((1 << 5) - 1)));
1036 assert(!(h & ~((1 << 5) - 1)));
1037 assert(!(e & ~((1 << 6) - 1)));
1038 assert(!(x & ~((1 << 3) - 1)));
1039 assert(!(i & ~((1 << 1) - 1)));
1040 assert(!(r & ~((1 << 1) - 1)));
1041 e = (e >> 5) | ((e << 1) & 63);
1042 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1046 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1048 assert(!(o & ~((1 << 6) - 1)));
1049 assert(!(s & ~((1 << 5) - 1)));
1050 assert(!(a & ~((1 << 5) - 1)));
1051 assert(!(h & ~((1 << 5) - 1)));
1052 assert(!(x & ~((1 << 9) - 1)));
1053 assert(!(i & ~((1 << 1) - 1)));
1054 assert(!(r & ~((1 << 1) - 1)));
1055 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1061 * Use the sequence commented at
1062 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1065 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1068 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1070 MTCRF(128, rn(reg));
1071 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1078 _nop(jit_state_t *_jit, jit_int32_t i0)
1080 for (; i0 > 0; i0 -= 4)
1086 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1093 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1095 if (can_sign_extend_short_p(i0))
1098 if (can_sign_extend_int_p(i0))
1099 LIS(r0, (jit_int16_t)(i0 >> 16));
1100 else if (can_zero_extend_int_p(i0)) {
1101 if (i0 & 0xffff0000) {
1102 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1106 # if __WORDSIZE == 64
1108 movi(r0, (jit_uint32_t)(i0 >> 32));
1109 if (i0 & 0xffff0000) {
1111 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1119 ORI(r0, r0, (jit_uint16_t)i0);
1124 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1126 jit_word_t word = _jit->pc.w;
1127 # if __WORDSIZE == 32
1128 LIS(r0, (jit_int16_t)(i0 >> 16));
1129 ORI(r0, r0, (jit_uint16_t)i0);
1131 LIS(r0, (jit_int16_t)(i0 >> 48));
1132 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1134 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1136 ORI(r0, r0, (jit_uint16_t)i0);
1141 # if __BYTE_ORDER == __LITTLE_ENDIAN
1143 _htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1146 t0 = jit_get_reg(jit_class_gpr);
1147 rshi(rn(t0), r1, 8);
1149 andi(rn(t0), rn(t0), 0xff);
1151 orr(r0, r0, rn(t0));
1156 _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1159 reg = jit_get_reg(jit_class_gpr);
1160 ROTLWI(rn(reg), r1, 8);
1161 RLWIMI(rn(reg), r1, 24, 0, 7);
1162 RLWIMI(rn(reg), r1, 24, 16, 23);
1163 # if __WORDSIZE == 64
1164 CLRLDI(r0, rn(reg), 32);
1171 # if __WORDSIZE == 64
1173 _htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1176 reg = jit_get_reg(jit_class_gpr);
1177 rshi_u(rn(reg), r1, 32);
1179 htonr_ui(rn(reg), rn(reg));
1181 orr(r0, r0, rn(reg));
1188 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1191 if (can_sign_extend_short_p(i0))
1193 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1194 ADDIS(r0, r1, i0 >> 16);
1196 reg = jit_get_reg(jit_class_gpr);
1198 ADD(r0, r1, rn(reg));
1204 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1207 if (can_sign_extend_short_p(i0))
1210 reg = jit_get_reg(jit_class_gpr);
1212 ADDC(r0, r1, rn(reg));
1218 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1221 reg = jit_get_reg(jit_class_gpr);
1223 ADDE(r0, r1, rn(reg));
1228 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1231 jit_word_t ni0 = -i0;
1232 if (can_sign_extend_short_p(ni0))
1234 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1235 ADDIS(r0, r1, ni0 >> 16);
1237 reg = jit_get_reg(jit_class_gpr);
1239 SUB(r0, r1, rn(reg));
1245 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1248 reg = jit_get_reg(jit_class_gpr);
1250 SUBC(r0, r1, rn(reg));
1255 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1258 reg = jit_get_reg(jit_class_gpr);
1260 SUBE(r0, r1, rn(reg));
1265 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1272 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1275 if (can_sign_extend_short_p(i0))
1278 reg = jit_get_reg(jit_class_gpr);
1280 mulr(r0, r1, rn(reg));
1286 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1287 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1290 if (r0 == r2 || r0 == r3) {
1291 reg = jit_get_reg(jit_class_gpr);
1292 mullr(rn(reg), r2, r3);
1299 mulhr_u(r1, r2, r3);
1300 if (r0 == r2 || r0 == r3) {
1307 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1308 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1311 reg = jit_get_reg(jit_class_gpr);
1313 iqmulr(r0, r1, r2, rn(reg), sign);
1318 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1321 reg = jit_get_reg(jit_class_gpr);
1323 divr(r0, r1, rn(reg));
1328 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1331 reg = jit_get_reg(jit_class_gpr);
1333 divr_u(r0, r1, rn(reg));
1338 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1339 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1341 jit_int32_t sv0, rg0;
1342 jit_int32_t sv1, rg1;
1344 if (r0 == r2 || r0 == r3) {
1345 sv0 = jit_get_reg(jit_class_gpr);
1350 if (r1 == r2 || r1 == r3) {
1351 sv1 = jit_get_reg(jit_class_gpr);
1360 divr_u(rg0, r2, r3);
1374 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1375 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1378 reg = jit_get_reg(jit_class_gpr);
1380 iqdivr(r0, r1, r2, rn(reg), sign);
1385 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1388 if (r0 == r1 || r0 == r2) {
1389 reg = jit_get_reg(jit_class_gpr);
1390 divr(rn(reg), r1, r2);
1391 mulr(rn(reg), r2, rn(reg));
1392 subr(r0, r1, rn(reg));
1403 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1406 reg = jit_get_reg(jit_class_gpr);
1408 remr(r0, r1, rn(reg));
1413 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1416 if (r0 == r1 || r0 == r2) {
1417 reg = jit_get_reg(jit_class_gpr);
1418 divr_u(rn(reg), r1, r2);
1419 mulr(rn(reg), r2, rn(reg));
1420 subr(r0, r1, rn(reg));
1431 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1434 reg = jit_get_reg(jit_class_gpr);
1436 remr_u(r0, r1, rn(reg));
1441 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1444 if (can_zero_extend_short_p(i0))
1446 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1447 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1449 reg = jit_get_reg(jit_class_gpr);
1451 AND(r0, r1, rn(reg));
1457 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1460 if (can_zero_extend_short_p(i0))
1462 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1463 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1465 reg = jit_get_reg(jit_class_gpr);
1467 OR(r0, r1, rn(reg));
1473 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1476 if (can_zero_extend_short_p(i0))
1478 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1479 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1481 reg = jit_get_reg(jit_class_gpr);
1483 XOR(r0, r1, rn(reg));
1489 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1494 # if __WORDSIZE == 32
1503 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1508 # if __WORDSIZE == 32
1517 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1522 # if __WORDSIZE == 32
1531 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1535 EXTRWI(r0, r0, 1, CR_LT);
1539 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1542 if (can_sign_extend_short_p(i0))
1545 reg = jit_get_reg(jit_class_gpr);
1551 EXTRWI(r0, r0, 1, CR_LT);
1555 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1559 EXTRWI(r0, r0, 1, CR_LT);
1563 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1566 if (can_zero_extend_short_p(i0))
1569 reg = jit_get_reg(jit_class_gpr);
1575 EXTRWI(r0, r0, 1, CR_LT);
1579 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1582 CRNOT(CR_GT, CR_GT);
1584 EXTRWI(r0, r0, 1, CR_GT);
1588 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1591 if (can_sign_extend_short_p(i0))
1594 reg = jit_get_reg(jit_class_gpr);
1599 CRNOT(CR_GT, CR_GT);
1601 EXTRWI(r0, r0, 1, CR_GT);
1605 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1608 CRNOT(CR_GT, CR_GT);
1610 EXTRWI(r0, r0, 1, CR_GT);
1614 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1617 if (can_zero_extend_short_p(i0))
1620 reg = jit_get_reg(jit_class_gpr);
1625 CRNOT(CR_GT, CR_GT);
1627 EXTRWI(r0, r0, 1, CR_GT);
1631 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1635 EXTRWI(r0, r0, 1, CR_EQ);
1639 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1642 if (can_sign_extend_short_p(i0))
1644 else if (can_zero_extend_short_p(i0))
1647 reg = jit_get_reg(jit_class_gpr);
1653 EXTRWI(r0, r0, 1, CR_EQ);
1657 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1660 CRNOT(CR_LT, CR_LT);
1662 EXTRWI(r0, r0, 1, CR_LT);
1666 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1669 if (can_sign_extend_short_p(i0))
1672 reg = jit_get_reg(jit_class_gpr);
1677 CRNOT(CR_LT, CR_LT);
1679 EXTRWI(r0, r0, 1, CR_LT);
1683 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1686 CRNOT(CR_LT, CR_LT);
1688 EXTRWI(r0, r0, 1, CR_LT);
1692 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1695 if (can_zero_extend_short_p(i0))
1698 reg = jit_get_reg(jit_class_gpr);
1703 CRNOT(CR_LT, CR_LT);
1705 EXTRWI(r0, r0, 1, CR_LT);
1709 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1713 EXTRWI(r0, r0, 1, CR_GT);
1717 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1720 if (can_sign_extend_short_p(i0))
1723 reg = jit_get_reg(jit_class_gpr);
1729 EXTRWI(r0, r0, 1, CR_GT);
1733 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1737 EXTRWI(r0, r0, 1, CR_GT);
1741 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1744 if (can_zero_extend_short_p(i0))
1747 reg = jit_get_reg(jit_class_gpr);
1753 EXTRWI(r0, r0, 1, CR_GT);
1757 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1760 CRNOT(CR_EQ, CR_EQ);
1762 EXTRWI(r0, r0, 1, CR_EQ);
1766 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1769 if (can_sign_extend_short_p(i0))
1771 else if (can_zero_extend_short_p(i0))
1774 reg = jit_get_reg(jit_class_gpr);
1779 CRNOT(CR_EQ, CR_EQ);
1781 EXTRWI(r0, r0, 1, CR_EQ);
1785 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1796 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1800 if (can_sign_extend_short_p(i1))
1803 reg = jit_get_reg(jit_class_gpr);
1815 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1826 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1830 if (can_zero_extend_short_p(i1))
1833 reg = jit_get_reg(jit_class_gpr);
1845 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1856 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1860 if (can_sign_extend_short_p(i1))
1863 reg = jit_get_reg(jit_class_gpr);
1875 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1886 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1890 if (can_zero_extend_short_p(i1))
1893 reg = jit_get_reg(jit_class_gpr);
1905 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1916 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1920 if (can_sign_extend_short_p(i1))
1922 else if (can_zero_extend_short_p(i1))
1925 reg = jit_get_reg(jit_class_gpr);
1937 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1948 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1952 if (can_sign_extend_short_p(i1))
1955 reg = jit_get_reg(jit_class_gpr);
1967 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1978 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1982 if (can_zero_extend_short_p(i1))
1985 reg = jit_get_reg(jit_class_gpr);
1997 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2008 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2012 if (can_sign_extend_short_p(i1))
2015 reg = jit_get_reg(jit_class_gpr);
2027 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2038 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2042 if (can_zero_extend_short_p(i1))
2045 reg = jit_get_reg(jit_class_gpr);
2057 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2068 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2072 if (can_sign_extend_short_p(i1))
2074 else if (can_zero_extend_short_p(i1))
2077 reg = jit_get_reg(jit_class_gpr);
2089 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2093 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2094 andr(rn(reg), r0, r1);
2095 w = bnei(i0, rn(reg), 0);
2101 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2105 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2106 andi(rn(reg), r0, i1);
2107 w = bnei(i0, rn(reg), 0);
2113 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2117 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2118 andr(rn(reg), r0, r1);
2119 w = beqi(i0, rn(reg), 0);
2125 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2129 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2130 andi(rn(reg), r0, i1);
2131 w = beqi(i0, rn(reg), 0);
2137 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2144 BGT(d); /* GT = bit 1 of XER = OV */
2149 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2153 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2155 w = boaddr(i0, r0, rn(reg));
2161 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2173 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2177 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2179 w = bxaddr(i0, r0, rn(reg));
2185 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2197 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2201 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2203 w = bosubr(i0, r0, rn(reg));
2209 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2221 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2225 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2227 w = bxsubr(i0, r0, rn(reg));
2233 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2240 BEQ(d); /* EQ = bit 2 of XER = CA */
2245 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2249 if (can_sign_extend_short_p(i1)) {
2257 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2259 w = boaddr_u(i0, r0, rn(reg));
2265 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2277 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2281 if (can_sign_extend_short_p(i1)) {
2289 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2291 w = bxaddr_u(i0, r0, rn(reg));
2297 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2304 BNE(d); /* PPC uses "carry" not "borrow" */
2309 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2313 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2315 w = bosubr_u(i0, r0, rn(reg));
2321 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2333 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2337 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2339 w = bxsubr_u(i0, r0, rn(reg));
2345 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2352 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2359 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2361 ldxr_uc(r0, r1, r2);
2366 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2368 ldxi_uc(r0, r1, i0);
2373 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2378 if (can_sign_extend_short_p(i0))
2379 LBZ(r0, _R0_REGNO, i0);
2380 else if (can_sign_extend_int_p(i0)) {
2381 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2382 lo = (jit_int16_t)(i0 - (hi << 16));
2383 reg = jit_get_reg(jit_class_gpr);
2384 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2386 LBZ(r0, rn(reg), lo);
2388 if (inv) jit_unget_reg(_R0);
2391 reg = jit_get_reg(jit_class_gpr);
2393 ldr_uc(r0, rn(reg));
2399 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2402 if (r1 == _R0_REGNO) {
2403 if (r2 != _R0_REGNO)
2406 reg = jit_get_reg(jit_class_gpr);
2408 LBZX(r0, rn(reg), r2);
2417 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2422 else if (can_sign_extend_short_p(i0)) {
2423 if (r1 == _R0_REGNO) {
2424 reg = jit_get_reg(jit_class_gpr);
2426 LBZ(r0, rn(reg), i0);
2433 reg = jit_get_reg(jit_class_gpr);
2435 ldxr_uc(r0, r1, rn(reg));
2441 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2446 if (can_sign_extend_short_p(i0))
2447 LHA(r0, _R0_REGNO, i0);
2448 else if (can_sign_extend_int_p(i0)) {
2449 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2450 lo = (jit_int16_t)(i0 - (hi << 16));
2451 reg = jit_get_reg(jit_class_gpr);
2452 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2454 LHA(r0, rn(reg), lo);
2456 if (inv) jit_unget_reg(_R0);
2459 reg = jit_get_reg(jit_class_gpr);
2467 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2470 if (r1 == _R0_REGNO) {
2471 if (r2 != _R0_REGNO)
2474 reg = jit_get_reg(jit_class_gpr);
2476 LHAX(r0, rn(reg), r2);
2485 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2490 else if (can_sign_extend_short_p(i0)) {
2491 if (r1 == _R0_REGNO) {
2492 reg = jit_get_reg(jit_class_gpr);
2494 LHA(r0, rn(reg), i0);
2501 reg = jit_get_reg(jit_class_gpr);
2503 ldxr_s(r0, r1, rn(reg));
2509 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2514 if (can_sign_extend_short_p(i0))
2515 LHZ(r0, _R0_REGNO, i0);
2516 else if (can_sign_extend_int_p(i0)) {
2517 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2518 lo = (jit_int16_t)(i0 - (hi << 16));
2519 reg = jit_get_reg(jit_class_gpr);
2520 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2522 LHZ(r0, rn(reg), lo);
2524 if (inv) jit_unget_reg(_R0);
2527 reg = jit_get_reg(jit_class_gpr);
2529 ldr_us(r0, rn(reg));
2535 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2538 if (r1 == _R0_REGNO) {
2539 if (r2 != _R0_REGNO)
2542 reg = jit_get_reg(jit_class_gpr);
2544 LHZX(r0, rn(reg), r2);
2553 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2558 else if (can_sign_extend_short_p(i0)) {
2559 if (r1 == _R0_REGNO) {
2560 reg = jit_get_reg(jit_class_gpr);
2562 LHZ(r0, rn(reg), i0);
2569 reg = jit_get_reg(jit_class_gpr);
2571 ldxr_us(r0, r1, rn(reg));
2576 # if __WORDSIZE == 32
2578 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2583 if (can_sign_extend_short_p(i0))
2584 LWZ(r0, _R0_REGNO, i0);
2585 else if (can_sign_extend_int_p(i0)) {
2586 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2587 lo = (jit_int16_t)(i0 - (hi << 16));
2588 reg = jit_get_reg(jit_class_gpr);
2589 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2591 LWZ(r0, rn(reg), lo);
2593 if (inv) jit_unget_reg(_R0);
2596 reg = jit_get_reg(jit_class_gpr);
2604 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2607 if (r1 == _R0_REGNO) {
2608 if (r2 != _R0_REGNO)
2611 reg = jit_get_reg(jit_class_gpr);
2613 LWZX(r0, rn(reg), r2);
2622 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2627 else if (can_sign_extend_short_p(i0)) {
2628 if (r1 == _R0_REGNO) {
2629 reg = jit_get_reg(jit_class_gpr);
2631 LWZ(r0, rn(reg), i0);
2638 reg = jit_get_reg(jit_class_gpr);
2640 ldxr_i(r0, r1, rn(reg));
2647 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2652 if (can_sign_extend_short_p(i0))
2653 LWA(r0, _R0_REGNO, i0);
2654 else if (can_sign_extend_int_p(i0)) {
2655 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2656 lo = (jit_int16_t)(i0 - (hi << 16));
2657 reg = jit_get_reg(jit_class_gpr);
2658 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2660 LWA(r0, rn(reg), lo);
2662 if (inv) jit_unget_reg(_R0);
2665 reg = jit_get_reg(jit_class_gpr);
2673 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2676 if (r1 == _R0_REGNO) {
2677 if (r2 != _R0_REGNO)
2680 reg = jit_get_reg(jit_class_gpr);
2682 LWAX(r0, rn(reg), r2);
2691 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2696 else if (can_sign_extend_short_p(i0)) {
2697 if (r1 == _R0_REGNO) {
2698 reg = jit_get_reg(jit_class_gpr);
2700 LWA(r0, rn(reg), i0);
2707 reg = jit_get_reg(jit_class_gpr);
2709 ldxr_i(r0, r1, rn(reg));
2715 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2720 if (can_sign_extend_short_p(i0))
2721 LWZ(r0, _R0_REGNO, i0);
2722 else if (can_sign_extend_int_p(i0)) {
2723 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2724 lo = (jit_int16_t)(i0 - (hi << 16));
2725 reg = jit_get_reg(jit_class_gpr);
2726 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2728 LWZ(r0, rn(reg), lo);
2730 if (inv) jit_unget_reg(_R0);
2733 reg = jit_get_reg(jit_class_gpr);
2735 ldr_ui(r0, rn(reg));
2741 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2744 if (r1 == _R0_REGNO) {
2745 if (r2 != _R0_REGNO)
2748 reg = jit_get_reg(jit_class_gpr);
2750 LWZX(r0, rn(reg), r2);
2759 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2764 else if (can_sign_extend_short_p(i0)) {
2765 if (r1 == _R0_REGNO) {
2766 reg = jit_get_reg(jit_class_gpr);
2768 LWZ(r0, rn(reg), i0);
2775 reg = jit_get_reg(jit_class_gpr);
2777 ldxr_ui(r0, r1, rn(reg));
2783 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2788 if (can_sign_extend_short_p(i0))
2789 LD(r0, _R0_REGNO, i0);
2790 else if (can_sign_extend_int_p(i0)) {
2791 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2792 lo = (jit_int16_t)(i0 - (hi << 16));
2793 reg = jit_get_reg(jit_class_gpr);
2794 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2796 LD(r0, rn(reg), lo);
2798 if (inv) jit_unget_reg(_R0);
2801 reg = jit_get_reg(jit_class_gpr);
2809 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2812 if (r1 == _R0_REGNO) {
2813 if (r2 != _R0_REGNO)
2816 reg = jit_get_reg(jit_class_gpr);
2818 LDX(r0, rn(reg), r2);
2827 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2832 else if (can_sign_extend_short_p(i0)) {
2833 if (r1 == _R0_REGNO) {
2834 reg = jit_get_reg(jit_class_gpr);
2836 LD(r0, rn(reg), i0);
2843 reg = jit_get_reg(jit_class_gpr);
2845 ldxr_l(r0, r1, rn(reg));
2852 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2857 if (can_sign_extend_short_p(i0))
2858 STB(r0, _R0_REGNO, i0);
2859 else if (can_sign_extend_int_p(i0)) {
2860 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2861 lo = (jit_int16_t)(i0 - (hi << 16));
2862 reg = jit_get_reg(jit_class_gpr);
2863 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2865 STB(r0, rn(reg), lo);
2867 if (inv) jit_unget_reg(_R0);
2870 reg = jit_get_reg(jit_class_gpr);
2878 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2881 if (r0 == _R0_REGNO) {
2882 if (r1 != _R0_REGNO)
2885 reg = jit_get_reg(jit_class_gpr);
2887 STBX(r2, rn(reg), r1);
2896 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2901 else if (can_sign_extend_short_p(i0)) {
2902 if (r0 == _R0_REGNO) {
2903 reg = jit_get_reg(jit_class_gpr);
2905 STB(r1, rn(reg), i0);
2912 reg = jit_get_reg(jit_class_gpr);
2914 stxr_c(rn(reg), r0, r1);
2920 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2925 if (can_sign_extend_short_p(i0))
2926 STH(r0, _R0_REGNO, i0);
2927 else if (can_sign_extend_int_p(i0)) {
2928 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2929 lo = (jit_int16_t)(i0 - (hi << 16));
2930 reg = jit_get_reg(jit_class_gpr);
2931 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2933 STH(r0, rn(reg), lo);
2935 if (inv) jit_unget_reg(_R0);
2938 reg = jit_get_reg(jit_class_gpr);
2946 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2949 if (r0 == _R0_REGNO) {
2950 if (r1 != _R0_REGNO)
2953 reg = jit_get_reg(jit_class_gpr);
2955 STHX(r2, rn(reg), r1);
2964 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2969 else if (can_sign_extend_short_p(i0)) {
2970 if (r0 == _R0_REGNO) {
2971 reg = jit_get_reg(jit_class_gpr);
2973 STH(r1, rn(reg), i0);
2980 reg = jit_get_reg(jit_class_gpr);
2982 stxr_s(rn(reg), r0, r1);
2988 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2993 if (can_sign_extend_short_p(i0))
2994 STW(r0, _R0_REGNO, i0);
2995 else if (can_sign_extend_int_p(i0)) {
2996 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2997 lo = (jit_int16_t)(i0 - (hi << 16));
2998 reg = jit_get_reg(jit_class_gpr);
2999 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3001 STW(r0, rn(reg), lo);
3003 if (inv) jit_unget_reg(_R0);
3006 reg = jit_get_reg(jit_class_gpr);
3014 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3017 if (r0 == _R0_REGNO) {
3018 if (r1 != _R0_REGNO)
3021 reg = jit_get_reg(jit_class_gpr);
3023 STWX(r2, rn(reg), r1);
3032 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3037 else if (can_sign_extend_short_p(i0)) {
3038 if (r0 == _R0_REGNO) {
3039 reg = jit_get_reg(jit_class_gpr);
3041 STW(r1, rn(reg), i0);
3048 reg = jit_get_reg(jit_class_gpr);
3050 stxr_i(rn(reg), r0, r1);
3055 # if __WORDSIZE == 64
3057 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3062 if (can_sign_extend_short_p(i0))
3063 STD(r0, _R0_REGNO, i0);
3064 else if (can_sign_extend_int_p(i0)) {
3065 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3066 lo = (jit_int16_t)(i0 - (hi << 16));
3067 reg = jit_get_reg(jit_class_gpr);
3068 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3070 STD(r0, rn(reg), lo);
3072 if (inv) jit_unget_reg(_R0);
3075 reg = jit_get_reg(jit_class_gpr);
3083 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3086 if (r0 == _R0_REGNO) {
3087 if (r1 != _R0_REGNO)
3090 reg = jit_get_reg(jit_class_gpr);
3092 STDX(r2, rn(reg), r1);
3101 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3106 else if (can_sign_extend_short_p(i0)) {
3107 if (r0 == _R0_REGNO) {
3108 reg = jit_get_reg(jit_class_gpr);
3110 STD(r1, rn(reg), i0);
3117 reg = jit_get_reg(jit_class_gpr);
3119 stxr_l(rn(reg), r0, r1);
3126 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3137 /* pc relative jump */
3139 _jmpi(jit_state_t *_jit, jit_word_t i0)
3145 if (can_sign_extend_jump_p(d))
3148 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3149 w = movi_p(rn(reg), i0);
3158 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3162 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3163 w = movi_p(rn(reg), i0);
3170 _callr(jit_state_t *_jit, jit_int32_t r0
3172 , jit_int32_t varargs
3177 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3178 /* FIXME Pretend to not know about r11? */
3179 if (r0 == _R0_REGNO) {
3180 movr(_R11_REGNO, _R0_REGNO);
3181 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3182 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3185 ldxi(_R2_REGNO, r0, sizeof(void*));
3186 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3191 /* Tell double arguments were passed in registers. */
3195 movr(_R12_REGNO, r0);
3202 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3206 /* assume fixed address or reachable address */
3208 _calli(jit_state_t *_jit, jit_word_t i0
3210 , jit_int32_t varargs
3216 d = (i0 - _jit->pc.w) & ~3;
3217 if (can_sign_extend_jump_p(d))
3222 movi(_R12_REGNO, i0);
3233 _calli_p(jit_state_t *_jit, jit_word_t i0
3235 , jit_int32_t varargs
3240 w = movi_p(_R12_REGNO, i0);
3249 /* order is not guaranteed to be sequential */
3250 static jit_int32_t save[] = {
3251 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3252 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3256 _prolog(jit_state_t *_jit, jit_node_t *node)
3258 unsigned long regno;
3261 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3262 jit_int32_t frame = -_jitc->function->frame;
3263 assert(_jitc->function->self.aoff >= frame);
3264 if (_jitc->function->assume_frame)
3266 _jitc->function->self.aoff = frame;
3268 if (_jitc->function->allocar) {
3269 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3270 _jitc->function->self.aoff &= -16;
3272 _jitc->function->stack = ((_jitc->function->self.alen +
3273 _jitc->function->self.size -
3274 _jitc->function->self.aoff) + 15) & -16;
3276 /* return address */
3279 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3280 * alloca < %r31-80 */
3283 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3285 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3287 offset = -gpr_save_area;
3288 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3289 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3290 stxi(offset, _SP_REGNO, rn(save[regno]));
3292 for (offset = 0; offset < 8; offset++) {
3293 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3294 stxi_d(-(gpr_save_area + 8 + offset * 8),
3295 _SP_REGNO, rn(_F14 + offset));
3298 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3300 movr(_FP_REGNO, _SP_REGNO);
3301 #if __WORDSIZE == 32
3302 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3304 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3307 if (_jitc->function->allocar) {
3308 regno = jit_get_reg(jit_class_gpr);
3309 movi(rn(regno), _jitc->function->self.aoff);
3310 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3311 jit_unget_reg(regno);
3315 if (_jitc->function->self.call & jit_call_varargs) {
3316 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3317 stxi(params_offset + regno * sizeof(jit_word_t),
3318 _FP_REGNO, rn(JIT_RA0 - regno));
3321 if (_jitc->function->self.call & jit_call_varargs) {
3322 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3323 stxi(_jitc->function->vaoff + first_gp_offset +
3324 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3325 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3326 stxi_d(_jitc->function->vaoff + first_fp_offset +
3327 regno * va_fp_increment, _FP_REGNO,
3328 rn(JIT_FA0 - regno));
3334 _epilog(jit_state_t *_jit, jit_node_t *node)
3336 unsigned long regno;
3339 if (_jitc->function->assume_frame)
3341 if (_jitc->function->allocar)
3342 ldr(_SP_REGNO, _SP_REGNO);
3344 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3346 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3348 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3350 offset = -gpr_save_area;
3351 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3352 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3353 ldxi(rn(save[regno]), _SP_REGNO, offset);
3355 for (offset = 0; offset < 8; offset++) {
3356 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3357 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3358 -(gpr_save_area + 8 + offset * 8));
3362 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3368 _vastart(jit_state_t *_jit, jit_int32_t r0)
3371 assert(_jitc->function->self.call & jit_call_varargs);
3372 /* Initialize stack pointer to the first stack argument. */
3373 addi(r0, _FP_REGNO, _jitc->function->self.size);
3376 assert(_jitc->function->self.call & jit_call_varargs);
3378 /* Return jit_va_list_t in the register argument */
3379 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3380 reg = jit_get_reg(jit_class_gpr);
3382 /* Initialize the gp counter. */
3383 movi(rn(reg), _jitc->function->vagp);
3384 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3386 /* Initialize the fp counter. */
3387 movi(rn(reg), _jitc->function->vafp);
3388 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3390 /* Initialize overflow pointer to the first stack argument. */
3391 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3392 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3394 /* Initialize register save area pointer. */
3395 addi(rn(reg), r0, first_gp_offset);
3396 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3403 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3406 assert(_jitc->function->self.call & jit_call_varargs);
3407 /* Load argument. */
3409 /* Update va_list. */
3410 addi(r1, r1, sizeof(jit_word_t));
3417 assert(_jitc->function->self.call & jit_call_varargs);
3419 rg0 = jit_get_reg(jit_class_gpr);
3420 rg1 = jit_get_reg(jit_class_gpr);
3422 /* Load the gp offset in save area in the first temporary. */
3423 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3425 /* Jump over if there are no remaining arguments in the save area. */
3426 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3428 /* Update the gp counter. */
3429 addi(rn(rg1), rn(rg0), 1);
3430 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3432 /* Load the save area pointer in the second temporary. */
3433 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3435 /* Load the vararg argument in the first argument. */
3436 lshi(rn(rg0), rn(rg0), va_gp_shift);
3437 ldxr(r0, rn(rg1), rn(rg0));
3439 /* Will only need one temporary register below. */
3442 /* Jump over overflow code. */
3443 lt_code = _jit->pc.w;
3446 /* Where to land if argument is in overflow area. */
3447 patch_at(ge_code, _jit->pc.w);
3449 /* Load overflow pointer. */
3450 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3452 /* Load argument. */
3455 /* Update overflow pointer. */
3456 addi(rn(rg0), rn(rg0), va_gp_increment);
3457 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3459 /* Where to land if argument is in save area. */
3460 patch_at(lt_code, _jit->pc.w);
3467 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3470 assert(_jitc->function->self.call & jit_call_varargs);
3471 /* Load argument. */
3473 /* Update va_list. */
3474 addi(r1, r1, sizeof(jit_float64_t));
3481 assert(_jitc->function->self.call & jit_call_varargs);
3483 rg0 = jit_get_reg(jit_class_gpr);
3484 rg1 = jit_get_reg(jit_class_gpr);
3486 /* Load the fp offset in save area in the first temporary. */
3487 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3489 /* Jump over if there are no remaining arguments in the save area. */
3490 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3492 /* Update the fp counter. */
3493 addi(rn(rg1), rn(rg0), 1);
3494 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3496 /* Load the save area pointer in the second temporary. */
3497 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3499 /* Load the vararg argument in the first argument. */
3500 lshi(rn(rg0), rn(rg0), 3);
3501 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3502 offsetof(jit_va_list_t, first_gp_argument));
3503 ldxr_d(r0, rn(rg1), rn(rg0));
3505 /* Jump over overflow code. */
3506 lt_code = _jit->pc.w;
3509 /* Where to land if argument is in overflow area. */
3510 patch_at(ge_code, _jit->pc.w);
3512 /* Load overflow pointer. */
3513 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3515 # if __WORDSIZE == 32
3516 /* Align if required. */
3517 andi(rn(rg1), rn(rg0), 7);
3518 addr(rn(rg0), rn(rg0), rn(rg1));
3521 /* Load argument. */
3524 /* Update overflow pointer. */
3525 addi(rn(rg0), rn(rg0), va_fp_increment);
3526 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3528 /* Where to land if argument is in save area. */
3529 patch_at(lt_code, _jit->pc.w);
3537 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3545 switch ((u.i[0] & 0xfc000000) >> 26) {
3549 if (!can_sign_extend_short_p(d)) {
3550 /* use absolute address */
3551 assert(can_sign_extend_short_p(label));
3554 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3558 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3559 /* zero is used for toc and env, so, quick check
3560 * if this is a "jmpi main" like initial jit
3562 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3563 for (d = 0; d < _jitc->prolog.offset; d++) {
3564 /* not so pretty, but hides powerpc
3565 * specific abi intrinsics and/or
3566 * implementation from user */
3567 if (_jitc->prolog.ptr[d] == label) {
3568 label += sizeof(void*) * 3;
3577 if (!can_sign_extend_jump_p(d)) {
3578 /* use absolute address */
3579 assert(can_sign_extend_jump_p(label));
3582 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3585 #if __WORDSIZE == 32
3586 # define MTCTR_OFF 2
3589 # define MTCTR_OFF 6
3593 /* movi reg label; jmpr reg */
3596 /* check for MLTR(reg) */
3597 (u.i[MTCTR_OFF] >> 26) == 31 &&
3598 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3599 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3601 u.i[BCTR_OFF] == 0x4e800020) {
3603 /* check for MTCTR(reg) */
3604 (u.i[MTCTR_OFF] >> 26) == 31 &&
3605 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3606 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3607 /* check for BCTR */
3608 u.i[BCTR_OFF] == 0x4e800420) {
3610 /* zero is used for toc and env, so, quick check
3611 * if this is a "jmpi main" like initial jit
3613 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3614 for (d = 0; d < _jitc->prolog.offset; d++) {
3615 /* not so pretty, but hides powerpc
3616 * specific abi intrinsics and/or
3617 * implementation from user */
3618 if (_jitc->prolog.ptr[d] == label) {
3619 label += sizeof(void*) * 3;
3628 #if __WORDSIZE == 32
3629 assert(!(u.i[0] & 0x1f0000));
3630 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3631 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3632 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3633 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3635 assert(!(u.i[0] & 0x1f0000));
3636 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3637 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3638 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3639 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3640 /* not fully validating SLDI */
3641 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3642 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3643 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3644 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3645 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3646 /* not fully validating SLDI */
3647 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3648 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3649 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3650 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3651 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3655 assert(!"unhandled branch opcode");