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 # if __BYTE_ORDER == __BIG_ENDIAN
525 # define htonr_us(r0,r1) extr_us(r0,r1)
526 # if __WORDSIZE == 32
527 # define htonr_ui(r0,r1) movr(r0,r1)
529 # define htonr_ui(r0,r1) extr_ui(r0,r1)
530 # define htonr_ul(r0,r1) movr(r0,r1)
533 # define htonr_us(r0,r1) _htonr_us(_jit,r0,r1)
534 static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
535 # define htonr_ui(r0,r1) _htonr_ui(_jit,r0,r1)
536 static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
537 # if __WORDSIZE == 64
538 # define htonr_ul(r0,r1) _htonr_ul(_jit,r0,r1)
539 static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
542 # define addr(r0,r1,r2) ADD(r0,r1,r2)
543 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
544 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
545 # define addcr(r0,r1,r2) ADDC(r0,r1,r2)
546 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
547 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
548 # define addxr(r0,r1,r2) ADDE(r0,r1,r2)
549 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
550 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
551 # define subr(r0,r1,r2) SUB(r0,r1,r2)
552 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
553 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
554 # define subcr(r0,r1,r2) SUBC(r0,r1,r2)
555 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
556 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
557 # define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
558 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
559 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
560 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
561 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
562 # if __WORDSIZE == 32
563 # define mulr(r0,r1,r2) MULLW(r0,r1,r2)
564 # define mullr(r0,r1,r2) MULLW(r0,r1,r2)
565 # define mulhr(r0,r1,r2) MULHW(r0,r1,r2)
566 # define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2)
568 # define mulr(r0,r1,r2) MULLD(r0,r1,r2)
569 # define mullr(r0,r1,r2) MULLD(r0,r1,r2)
570 # define mulhr(r0,r1,r2) MULHD(r0,r1,r2)
571 # define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2)
573 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
574 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
575 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
576 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
577 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
578 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
579 jit_int32_t,jit_int32_t,jit_bool_t);
580 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
581 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
582 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
583 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
584 jit_int32_t,jit_word_t,jit_bool_t);
585 # if __WORDSIZE == 32
586 # define divr(r0,r1,r2) DIVW(r0,r1,r2)
588 # define divr(r0,r1,r2) DIVD(r0,r1,r2)
590 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
591 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
592 # if __WORDSIZE == 32
593 # define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
595 # define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
597 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
598 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
599 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
600 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
601 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
602 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
603 jit_int32_t,jit_int32_t,jit_bool_t);
604 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
605 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
606 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
607 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
608 jit_int32_t,jit_word_t,jit_bool_t);
609 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
610 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
611 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
612 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
613 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
614 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
615 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
616 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
617 # define andr(r0,r1,r2) AND(r0,r1,r2)
618 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
619 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
620 # define orr(r0,r1,r2) OR(r0,r1,r2)
621 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
622 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
623 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
624 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
625 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
626 # if __WORDSIZE == 32
627 # define lshr(r0,r1,r2) SLW(r0,r1,r2)
629 # define lshr(r0,r1,r2) SLD(r0,r1,r2)
631 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
632 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
633 # if __WORDSIZE == 32
634 # define rshr(r0,r1,r2) SRAW(r0,r1,r2)
636 # define rshr(r0,r1,r2) SRAD(r0,r1,r2)
638 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
639 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
640 # if __WORDSIZE == 32
641 # define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
643 # define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
645 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
646 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
647 # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
648 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
649 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
650 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
651 # define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
652 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
653 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
654 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
655 # define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
656 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
657 # define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
658 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
659 # define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
660 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
661 # define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
662 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
663 # define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
664 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
665 # define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
666 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
667 # define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
668 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
669 # define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
670 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
671 # define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
672 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
673 # define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
674 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
675 # define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
676 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
677 # define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
678 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
679 # define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
680 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
681 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
682 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
683 # define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
684 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
685 # define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
686 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
687 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
688 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
689 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
690 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
691 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
692 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
693 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
694 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
695 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
696 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
697 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
698 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
699 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
700 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
701 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
702 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
703 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
704 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
705 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
706 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
707 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
708 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
709 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
710 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
711 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
712 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
713 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
714 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
715 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
716 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
717 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
718 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
719 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
720 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
721 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
722 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
723 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
724 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
725 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
726 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
727 #define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
728 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
729 #define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
730 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
731 #define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
732 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
733 #define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
734 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
735 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
736 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
737 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
738 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
739 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
740 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
741 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
742 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
743 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
744 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
745 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
746 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
747 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
748 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
749 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
750 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
751 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
752 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
753 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
754 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
755 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
756 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
757 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
758 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
759 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
760 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
761 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
762 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
763 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
764 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
765 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
766 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
767 # define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
768 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
769 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
770 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
771 # define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
772 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
773 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
774 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
775 # define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
776 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
777 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
778 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
779 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
780 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
781 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
782 # define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
783 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
784 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
785 # define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
786 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
787 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
788 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
789 # define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
790 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
791 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
792 # define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
793 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
794 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
795 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
796 # if __WORDSIZE == 32
797 # define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
799 # define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
801 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
802 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
803 # define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
804 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
805 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
806 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
807 # if __WORDSIZE == 64
808 # define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
809 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
810 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
811 # define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
812 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
813 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
814 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
815 # define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
816 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
817 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
818 # define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
819 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
820 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
821 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
823 # define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
824 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
825 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
826 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
827 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
828 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
829 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
830 # define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
831 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
832 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
833 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
834 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
835 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
836 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
837 # define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
838 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
839 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
840 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
841 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
842 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
843 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
844 # if __WORDSIZE == 64
845 # define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
846 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
847 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
848 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
849 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
850 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
851 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
853 # define jmpr(r0) _jmpr(_jit,r0)
854 static void _jmpr(jit_state_t*,jit_int32_t);
855 # define jmpi(i0) _jmpi(_jit,i0)
856 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
857 # define jmpi_p(i0) _jmpi_p(_jit,i0)
858 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
860 # define callr(r0,i0) _callr(_jit,r0,i0)
861 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
862 # define calli(i0,i1) _calli(_jit,i0,i1)
863 static void _calli(jit_state_t*,jit_word_t,jit_int32_t);
864 # define calli_p(i0,i1) _calli_p(_jit,i0,i1)
865 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
867 # define callr(r0) _callr(_jit,r0)
868 static void _callr(jit_state_t*,jit_int32_t);
869 # define calli(i0) _calli(_jit,i0)
870 static void _calli(jit_state_t*,jit_word_t);
871 # define calli_p(i0) _calli_p(_jit,i0)
872 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
874 # define prolog(node) _prolog(_jit, node)
875 static void _prolog(jit_state_t*, jit_node_t*);
876 # define epilog(node) _epilog(_jit, node)
877 static void _epilog(jit_state_t*, jit_node_t*);
878 # define vastart(r0) _vastart(_jit, r0)
879 static void _vastart(jit_state_t*, jit_int32_t);
880 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
881 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
882 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
883 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
884 # define patch_at(i,l) _patch_at(_jit,i,l)
885 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
889 # define _u16(v) ((v) & 0xffff)
890 # define _u26(v) ((v) & 0x3ffffff)
892 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
894 assert(!(o & ~((1 << 6) - 1)));
895 assert(!(d & ~((1 << 5) - 1)));
896 assert(!(a & ~((1 << 5) - 1)));
897 assert(!(b & ~((1 << 5) - 1)));
898 assert(!(e & ~((1 << 1) - 1)));
899 assert(!(x & ~((1 << 9) - 1)));
900 assert(!(r & ~((1 << 1) - 1)));
901 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
905 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
907 assert(!(o & ~((1 << 6) - 1)));
908 assert(!(d & ~((1 << 5) - 1)));
909 assert(!(a & ~((1 << 5) - 1)));
910 assert(can_sign_extend_short_p(s));
911 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
915 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
917 assert(!(o & ~((1 << 6) - 1)));
918 assert(!(d & ~((1 << 5) - 1)));
919 assert(!(a & ~((1 << 5) - 1)));
920 assert(can_zero_extend_short_p(s));
921 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
925 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
927 assert(!(o & ~((1 << 6) - 1)));
928 assert(!(s & ~((1 << 5) - 1)));
929 assert(!(a & ~((1 << 5) - 1)));
930 assert(!(b & ~((1 << 5) - 1)));
931 assert(!(x & ~((1 << 10) - 1)));
932 assert(!(r & ~((1 << 1) - 1)));
933 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
937 _FI(jit_state_t *_jit, int o, int t, int a, int k)
939 assert(!(o & ~(( 1 << 6) - 1)));
940 assert(!(t & 3) && can_sign_extend_jump_p(t));
941 assert(!(a & ~(( 1 << 1) - 1)));
942 assert(!(k & ~(( 1 << 1) - 1)));
943 ii((o<<26)|_u26(t)|(a<<1)|k);
947 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
949 assert(!( o & ~((1 << 6) - 1)));
950 assert(!(bo & ~((1 << 5) - 1)));
951 assert(!(bi & ~((1 << 5) - 1)));
952 assert(!(t & 3) && can_sign_extend_short_p(t));
953 assert(!(a & ~(( 1 << 1) - 1)));
954 assert(!(k & ~(( 1 << 1) - 1)));
955 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
959 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
961 assert(!( o & ~((1 << 6) - 1)));
962 assert(!(bo & ~((1 << 5) - 1)));
963 assert(!(bi & ~((1 << 5) - 1)));
964 assert(!(x & ~(( 1 << 10) - 1)));
965 assert(!(k & ~(( 1 << 1) - 1)));
966 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
970 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
972 assert(!(o & ~((1 << 6) - 1)));
973 assert(!(d & ~((1 << 3) - 1)));
974 assert(!(l & ~((1 << 1) - 1)));
975 assert(!(a & ~((1 << 5) - 1)));
976 assert(!(b & ~((1 << 5) - 1)));
977 assert(!(x & ~((1 << 10) - 1)));
978 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
982 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
984 assert(!(o & ~((1 << 6) - 1)));
985 assert(!(d & ~((1 << 3) - 1)));
986 assert(!(l & ~((1 << 1) - 1)));
987 assert(!(a & ~((1 << 5) - 1)));
988 if (o == 11) assert(can_sign_extend_short_p(s));
989 else if (o == 10) assert(can_zero_extend_short_p(s));
993 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
997 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
999 assert(!(o & ~((1 << 6) - 1)));
1000 assert(!(d & ~((1 << 5) - 1)));
1001 assert(!(x & ~((1 << 10) - 1)));
1002 assert(!(f & ~((1 << 10) - 1)));
1003 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1007 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
1009 assert(!(o & ~((1 << 6) - 1)));
1010 assert(!(s & ~((1 << 5) - 1)));
1011 assert(!(a & ~((1 << 5) - 1)));
1012 assert(!(h & ~((1 << 5) - 1)));
1013 assert(!(b & ~((1 << 5) - 1)));
1014 assert(!(e & ~((1 << 5) - 1)));
1015 assert(!(r & ~((1 << 1) - 1)));
1016 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1019 # if __WORDSIZE == 64
1021 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1023 assert(!(o & ~((1 << 6) - 1)));
1024 assert(!(s & ~((1 << 5) - 1)));
1025 assert(!(a & ~((1 << 5) - 1)));
1026 assert(!(b & ~((1 << 5) - 1)));
1027 assert(!(e & ~((1 << 6) - 1)));
1028 assert(!(x & ~((1 << 4) - 1)));
1029 assert(!(r & ~((1 << 1) - 1)));
1030 e = (e >> 5) | ((e << 1) & 63);
1031 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1035 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1037 assert(!(o & ~((1 << 6) - 1)));
1038 assert(!(s & ~((1 << 5) - 1)));
1039 assert(!(a & ~((1 << 5) - 1)));
1040 assert(!(h & ~((1 << 5) - 1)));
1041 assert(!(e & ~((1 << 6) - 1)));
1042 assert(!(x & ~((1 << 3) - 1)));
1043 assert(!(i & ~((1 << 1) - 1)));
1044 assert(!(r & ~((1 << 1) - 1)));
1045 e = (e >> 5) | ((e << 1) & 63);
1046 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1050 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1052 assert(!(o & ~((1 << 6) - 1)));
1053 assert(!(s & ~((1 << 5) - 1)));
1054 assert(!(a & ~((1 << 5) - 1)));
1055 assert(!(h & ~((1 << 5) - 1)));
1056 assert(!(x & ~((1 << 9) - 1)));
1057 assert(!(i & ~((1 << 1) - 1)));
1058 assert(!(r & ~((1 << 1) - 1)));
1059 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1065 * Use the sequence commented at
1066 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1069 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1072 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1074 MTCRF(128, rn(reg));
1075 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1082 _nop(jit_state_t *_jit, jit_int32_t i0)
1084 for (; i0 > 0; i0 -= 4)
1090 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1097 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1099 if (can_sign_extend_short_p(i0))
1102 if (can_sign_extend_int_p(i0))
1103 LIS(r0, (jit_int16_t)(i0 >> 16));
1104 else if (can_zero_extend_int_p(i0)) {
1105 if (i0 & 0xffff0000) {
1106 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1110 # if __WORDSIZE == 64
1112 movi(r0, (jit_uint32_t)(i0 >> 32));
1113 if (i0 & 0xffff0000) {
1115 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1123 ORI(r0, r0, (jit_uint16_t)i0);
1128 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1136 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1144 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1146 jit_word_t word = _jit->pc.w;
1147 # if __WORDSIZE == 32
1148 LIS(r0, (jit_int16_t)(i0 >> 16));
1149 ORI(r0, r0, (jit_uint16_t)i0);
1151 LIS(r0, (jit_int16_t)(i0 >> 48));
1152 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1154 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1156 ORI(r0, r0, (jit_uint16_t)i0);
1161 # if __BYTE_ORDER == __LITTLE_ENDIAN
1163 _htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1166 t0 = jit_get_reg(jit_class_gpr);
1167 rshi(rn(t0), r1, 8);
1169 andi(rn(t0), rn(t0), 0xff);
1171 orr(r0, r0, rn(t0));
1176 _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1179 reg = jit_get_reg(jit_class_gpr);
1180 ROTLWI(rn(reg), r1, 8);
1181 RLWIMI(rn(reg), r1, 24, 0, 7);
1182 RLWIMI(rn(reg), r1, 24, 16, 23);
1183 # if __WORDSIZE == 64
1184 CLRLDI(r0, rn(reg), 32);
1191 # if __WORDSIZE == 64
1193 _htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1196 reg = jit_get_reg(jit_class_gpr);
1197 rshi_u(rn(reg), r1, 32);
1199 htonr_ui(rn(reg), rn(reg));
1201 orr(r0, r0, rn(reg));
1208 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1211 if (can_sign_extend_short_p(i0))
1213 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1214 ADDIS(r0, r1, i0 >> 16);
1216 reg = jit_get_reg(jit_class_gpr);
1218 ADD(r0, r1, rn(reg));
1224 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1227 if (can_sign_extend_short_p(i0))
1230 reg = jit_get_reg(jit_class_gpr);
1232 ADDC(r0, r1, rn(reg));
1238 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1241 reg = jit_get_reg(jit_class_gpr);
1243 ADDE(r0, r1, rn(reg));
1248 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1251 jit_word_t ni0 = -i0;
1252 if (can_sign_extend_short_p(ni0))
1254 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1255 ADDIS(r0, r1, ni0 >> 16);
1257 reg = jit_get_reg(jit_class_gpr);
1259 SUB(r0, r1, rn(reg));
1265 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1268 reg = jit_get_reg(jit_class_gpr);
1270 SUBC(r0, r1, rn(reg));
1275 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1278 reg = jit_get_reg(jit_class_gpr);
1280 SUBE(r0, r1, rn(reg));
1285 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1292 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1295 if (can_sign_extend_short_p(i0))
1298 reg = jit_get_reg(jit_class_gpr);
1300 mulr(r0, r1, rn(reg));
1306 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1307 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1310 if (r0 == r2 || r0 == r3) {
1311 reg = jit_get_reg(jit_class_gpr);
1312 mullr(rn(reg), r2, r3);
1319 mulhr_u(r1, r2, r3);
1320 if (r0 == r2 || r0 == r3) {
1327 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1328 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1331 reg = jit_get_reg(jit_class_gpr);
1333 iqmulr(r0, r1, r2, rn(reg), sign);
1338 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1341 reg = jit_get_reg(jit_class_gpr);
1343 divr(r0, r1, rn(reg));
1348 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1351 reg = jit_get_reg(jit_class_gpr);
1353 divr_u(r0, r1, rn(reg));
1358 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1359 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1361 jit_int32_t sv0, rg0;
1362 jit_int32_t sv1, rg1;
1364 if (r0 == r2 || r0 == r3) {
1365 sv0 = jit_get_reg(jit_class_gpr);
1370 if (r1 == r2 || r1 == r3) {
1371 sv1 = jit_get_reg(jit_class_gpr);
1380 divr_u(rg0, r2, r3);
1394 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1395 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1398 reg = jit_get_reg(jit_class_gpr);
1400 iqdivr(r0, r1, r2, rn(reg), sign);
1405 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1408 if (r0 == r1 || r0 == r2) {
1409 reg = jit_get_reg(jit_class_gpr);
1410 divr(rn(reg), r1, r2);
1411 mulr(rn(reg), r2, rn(reg));
1412 subr(r0, r1, rn(reg));
1423 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1426 reg = jit_get_reg(jit_class_gpr);
1428 remr(r0, r1, rn(reg));
1433 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1436 if (r0 == r1 || r0 == r2) {
1437 reg = jit_get_reg(jit_class_gpr);
1438 divr_u(rn(reg), r1, r2);
1439 mulr(rn(reg), r2, rn(reg));
1440 subr(r0, r1, rn(reg));
1451 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1454 reg = jit_get_reg(jit_class_gpr);
1456 remr_u(r0, r1, rn(reg));
1461 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1464 if (can_zero_extend_short_p(i0))
1466 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1467 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1469 reg = jit_get_reg(jit_class_gpr);
1471 AND(r0, r1, rn(reg));
1477 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1480 if (can_zero_extend_short_p(i0))
1482 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1483 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1485 reg = jit_get_reg(jit_class_gpr);
1487 OR(r0, r1, rn(reg));
1493 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1496 if (can_zero_extend_short_p(i0))
1498 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1499 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1501 reg = jit_get_reg(jit_class_gpr);
1503 XOR(r0, r1, rn(reg));
1509 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1514 # if __WORDSIZE == 32
1523 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1528 # if __WORDSIZE == 32
1537 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1542 # if __WORDSIZE == 32
1551 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1555 EXTRWI(r0, r0, 1, CR_LT);
1559 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1562 if (can_sign_extend_short_p(i0))
1565 reg = jit_get_reg(jit_class_gpr);
1571 EXTRWI(r0, r0, 1, CR_LT);
1575 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1579 EXTRWI(r0, r0, 1, CR_LT);
1583 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1586 if (can_zero_extend_short_p(i0))
1589 reg = jit_get_reg(jit_class_gpr);
1595 EXTRWI(r0, r0, 1, CR_LT);
1599 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1602 CRNOT(CR_GT, CR_GT);
1604 EXTRWI(r0, r0, 1, CR_GT);
1608 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1611 if (can_sign_extend_short_p(i0))
1614 reg = jit_get_reg(jit_class_gpr);
1619 CRNOT(CR_GT, CR_GT);
1621 EXTRWI(r0, r0, 1, CR_GT);
1625 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1628 CRNOT(CR_GT, CR_GT);
1630 EXTRWI(r0, r0, 1, CR_GT);
1634 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1637 if (can_zero_extend_short_p(i0))
1640 reg = jit_get_reg(jit_class_gpr);
1645 CRNOT(CR_GT, CR_GT);
1647 EXTRWI(r0, r0, 1, CR_GT);
1651 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1655 EXTRWI(r0, r0, 1, CR_EQ);
1659 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1662 if (can_sign_extend_short_p(i0))
1664 else if (can_zero_extend_short_p(i0))
1667 reg = jit_get_reg(jit_class_gpr);
1673 EXTRWI(r0, r0, 1, CR_EQ);
1677 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1680 CRNOT(CR_LT, CR_LT);
1682 EXTRWI(r0, r0, 1, CR_LT);
1686 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1689 if (can_sign_extend_short_p(i0))
1692 reg = jit_get_reg(jit_class_gpr);
1697 CRNOT(CR_LT, CR_LT);
1699 EXTRWI(r0, r0, 1, CR_LT);
1703 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1706 CRNOT(CR_LT, CR_LT);
1708 EXTRWI(r0, r0, 1, CR_LT);
1712 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1715 if (can_zero_extend_short_p(i0))
1718 reg = jit_get_reg(jit_class_gpr);
1723 CRNOT(CR_LT, CR_LT);
1725 EXTRWI(r0, r0, 1, CR_LT);
1729 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1733 EXTRWI(r0, r0, 1, CR_GT);
1737 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1740 if (can_sign_extend_short_p(i0))
1743 reg = jit_get_reg(jit_class_gpr);
1749 EXTRWI(r0, r0, 1, CR_GT);
1753 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1757 EXTRWI(r0, r0, 1, CR_GT);
1761 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1764 if (can_zero_extend_short_p(i0))
1767 reg = jit_get_reg(jit_class_gpr);
1773 EXTRWI(r0, r0, 1, CR_GT);
1777 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1780 CRNOT(CR_EQ, CR_EQ);
1782 EXTRWI(r0, r0, 1, CR_EQ);
1786 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1789 if (can_sign_extend_short_p(i0))
1791 else if (can_zero_extend_short_p(i0))
1794 reg = jit_get_reg(jit_class_gpr);
1799 CRNOT(CR_EQ, CR_EQ);
1801 EXTRWI(r0, r0, 1, CR_EQ);
1805 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1816 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1820 if (can_sign_extend_short_p(i1))
1823 reg = jit_get_reg(jit_class_gpr);
1835 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1846 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1850 if (can_zero_extend_short_p(i1))
1853 reg = jit_get_reg(jit_class_gpr);
1865 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1876 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1880 if (can_sign_extend_short_p(i1))
1883 reg = jit_get_reg(jit_class_gpr);
1895 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1906 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1910 if (can_zero_extend_short_p(i1))
1913 reg = jit_get_reg(jit_class_gpr);
1925 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1936 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1940 if (can_sign_extend_short_p(i1))
1942 else if (can_zero_extend_short_p(i1))
1945 reg = jit_get_reg(jit_class_gpr);
1957 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1968 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1972 if (can_sign_extend_short_p(i1))
1975 reg = jit_get_reg(jit_class_gpr);
1987 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1998 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2002 if (can_zero_extend_short_p(i1))
2005 reg = jit_get_reg(jit_class_gpr);
2017 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2028 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2032 if (can_sign_extend_short_p(i1))
2035 reg = jit_get_reg(jit_class_gpr);
2047 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2058 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2062 if (can_zero_extend_short_p(i1))
2065 reg = jit_get_reg(jit_class_gpr);
2077 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2088 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2092 if (can_sign_extend_short_p(i1))
2094 else if (can_zero_extend_short_p(i1))
2097 reg = jit_get_reg(jit_class_gpr);
2109 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2113 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2114 andr(rn(reg), r0, r1);
2115 w = bnei(i0, rn(reg), 0);
2121 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2125 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2126 andi(rn(reg), r0, i1);
2127 w = bnei(i0, rn(reg), 0);
2133 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2137 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2138 andr(rn(reg), r0, r1);
2139 w = beqi(i0, rn(reg), 0);
2145 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2149 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2150 andi(rn(reg), r0, i1);
2151 w = beqi(i0, rn(reg), 0);
2157 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2164 BGT(d); /* GT = bit 1 of XER = OV */
2169 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2173 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2175 w = boaddr(i0, r0, rn(reg));
2181 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2193 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2197 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2199 w = bxaddr(i0, r0, rn(reg));
2205 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2217 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2221 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2223 w = bosubr(i0, r0, rn(reg));
2229 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2241 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2245 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2247 w = bxsubr(i0, r0, rn(reg));
2253 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2260 BEQ(d); /* EQ = bit 2 of XER = CA */
2265 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2269 if (can_sign_extend_short_p(i1)) {
2277 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2279 w = boaddr_u(i0, r0, rn(reg));
2285 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2297 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2301 if (can_sign_extend_short_p(i1)) {
2309 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2311 w = bxaddr_u(i0, r0, rn(reg));
2317 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2324 BNE(d); /* PPC uses "carry" not "borrow" */
2329 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2333 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2335 w = bosubr_u(i0, r0, rn(reg));
2341 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2353 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2357 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2359 w = bxsubr_u(i0, r0, rn(reg));
2365 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2372 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2379 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2381 ldxr_uc(r0, r1, r2);
2386 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2388 ldxi_uc(r0, r1, i0);
2393 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2398 if (can_sign_extend_short_p(i0))
2399 LBZ(r0, _R0_REGNO, i0);
2400 else if (can_sign_extend_int_p(i0)) {
2401 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2402 lo = (jit_int16_t)(i0 - (hi << 16));
2403 reg = jit_get_reg(jit_class_gpr);
2404 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2406 LBZ(r0, rn(reg), lo);
2408 if (inv) jit_unget_reg(_R0);
2411 reg = jit_get_reg(jit_class_gpr);
2413 ldr_uc(r0, rn(reg));
2419 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2422 if (r1 == _R0_REGNO) {
2423 if (r2 != _R0_REGNO)
2426 reg = jit_get_reg(jit_class_gpr);
2428 LBZX(r0, rn(reg), r2);
2437 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2442 else if (can_sign_extend_short_p(i0)) {
2443 if (r1 == _R0_REGNO) {
2444 reg = jit_get_reg(jit_class_gpr);
2446 LBZ(r0, rn(reg), i0);
2453 reg = jit_get_reg(jit_class_gpr);
2455 ldxr_uc(r0, r1, rn(reg));
2461 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2466 if (can_sign_extend_short_p(i0))
2467 LHA(r0, _R0_REGNO, i0);
2468 else if (can_sign_extend_int_p(i0)) {
2469 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2470 lo = (jit_int16_t)(i0 - (hi << 16));
2471 reg = jit_get_reg(jit_class_gpr);
2472 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2474 LHA(r0, rn(reg), lo);
2476 if (inv) jit_unget_reg(_R0);
2479 reg = jit_get_reg(jit_class_gpr);
2487 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2490 if (r1 == _R0_REGNO) {
2491 if (r2 != _R0_REGNO)
2494 reg = jit_get_reg(jit_class_gpr);
2496 LHAX(r0, rn(reg), r2);
2505 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2510 else if (can_sign_extend_short_p(i0)) {
2511 if (r1 == _R0_REGNO) {
2512 reg = jit_get_reg(jit_class_gpr);
2514 LHA(r0, rn(reg), i0);
2521 reg = jit_get_reg(jit_class_gpr);
2523 ldxr_s(r0, r1, rn(reg));
2529 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2534 if (can_sign_extend_short_p(i0))
2535 LHZ(r0, _R0_REGNO, i0);
2536 else if (can_sign_extend_int_p(i0)) {
2537 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2538 lo = (jit_int16_t)(i0 - (hi << 16));
2539 reg = jit_get_reg(jit_class_gpr);
2540 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2542 LHZ(r0, rn(reg), lo);
2544 if (inv) jit_unget_reg(_R0);
2547 reg = jit_get_reg(jit_class_gpr);
2549 ldr_us(r0, rn(reg));
2555 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2558 if (r1 == _R0_REGNO) {
2559 if (r2 != _R0_REGNO)
2562 reg = jit_get_reg(jit_class_gpr);
2564 LHZX(r0, rn(reg), r2);
2573 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2578 else if (can_sign_extend_short_p(i0)) {
2579 if (r1 == _R0_REGNO) {
2580 reg = jit_get_reg(jit_class_gpr);
2582 LHZ(r0, rn(reg), i0);
2589 reg = jit_get_reg(jit_class_gpr);
2591 ldxr_us(r0, r1, rn(reg));
2596 # if __WORDSIZE == 32
2598 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2603 if (can_sign_extend_short_p(i0))
2604 LWZ(r0, _R0_REGNO, i0);
2605 else if (can_sign_extend_int_p(i0)) {
2606 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2607 lo = (jit_int16_t)(i0 - (hi << 16));
2608 reg = jit_get_reg(jit_class_gpr);
2609 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2611 LWZ(r0, rn(reg), lo);
2613 if (inv) jit_unget_reg(_R0);
2616 reg = jit_get_reg(jit_class_gpr);
2624 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2627 if (r1 == _R0_REGNO) {
2628 if (r2 != _R0_REGNO)
2631 reg = jit_get_reg(jit_class_gpr);
2633 LWZX(r0, rn(reg), r2);
2642 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2647 else if (can_sign_extend_short_p(i0)) {
2648 if (r1 == _R0_REGNO) {
2649 reg = jit_get_reg(jit_class_gpr);
2651 LWZ(r0, rn(reg), i0);
2658 reg = jit_get_reg(jit_class_gpr);
2660 ldxr_i(r0, r1, rn(reg));
2667 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2672 if (can_sign_extend_short_p(i0))
2673 LWA(r0, _R0_REGNO, i0);
2674 else if (can_sign_extend_int_p(i0)) {
2675 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2676 lo = (jit_int16_t)(i0 - (hi << 16));
2677 reg = jit_get_reg(jit_class_gpr);
2678 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2680 LWA(r0, rn(reg), lo);
2682 if (inv) jit_unget_reg(_R0);
2685 reg = jit_get_reg(jit_class_gpr);
2693 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2696 if (r1 == _R0_REGNO) {
2697 if (r2 != _R0_REGNO)
2700 reg = jit_get_reg(jit_class_gpr);
2702 LWAX(r0, rn(reg), r2);
2711 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2716 else if (can_sign_extend_short_p(i0)) {
2717 if (r1 == _R0_REGNO) {
2718 reg = jit_get_reg(jit_class_gpr);
2720 LWA(r0, rn(reg), i0);
2727 reg = jit_get_reg(jit_class_gpr);
2729 ldxr_i(r0, r1, rn(reg));
2735 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2740 if (can_sign_extend_short_p(i0))
2741 LWZ(r0, _R0_REGNO, i0);
2742 else if (can_sign_extend_int_p(i0)) {
2743 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2744 lo = (jit_int16_t)(i0 - (hi << 16));
2745 reg = jit_get_reg(jit_class_gpr);
2746 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2748 LWZ(r0, rn(reg), lo);
2750 if (inv) jit_unget_reg(_R0);
2753 reg = jit_get_reg(jit_class_gpr);
2755 ldr_ui(r0, rn(reg));
2761 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2764 if (r1 == _R0_REGNO) {
2765 if (r2 != _R0_REGNO)
2768 reg = jit_get_reg(jit_class_gpr);
2770 LWZX(r0, rn(reg), r2);
2779 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2784 else if (can_sign_extend_short_p(i0)) {
2785 if (r1 == _R0_REGNO) {
2786 reg = jit_get_reg(jit_class_gpr);
2788 LWZ(r0, rn(reg), i0);
2795 reg = jit_get_reg(jit_class_gpr);
2797 ldxr_ui(r0, r1, rn(reg));
2803 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2808 if (can_sign_extend_short_p(i0))
2809 LD(r0, _R0_REGNO, i0);
2810 else if (can_sign_extend_int_p(i0)) {
2811 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2812 lo = (jit_int16_t)(i0 - (hi << 16));
2813 reg = jit_get_reg(jit_class_gpr);
2814 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2816 LD(r0, rn(reg), lo);
2818 if (inv) jit_unget_reg(_R0);
2821 reg = jit_get_reg(jit_class_gpr);
2829 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2832 if (r1 == _R0_REGNO) {
2833 if (r2 != _R0_REGNO)
2836 reg = jit_get_reg(jit_class_gpr);
2838 LDX(r0, rn(reg), r2);
2847 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2852 else if (can_sign_extend_short_p(i0)) {
2853 if (r1 == _R0_REGNO) {
2854 reg = jit_get_reg(jit_class_gpr);
2856 LD(r0, rn(reg), i0);
2863 reg = jit_get_reg(jit_class_gpr);
2865 ldxr_l(r0, r1, rn(reg));
2872 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2877 if (can_sign_extend_short_p(i0))
2878 STB(r0, _R0_REGNO, i0);
2879 else if (can_sign_extend_int_p(i0)) {
2880 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2881 lo = (jit_int16_t)(i0 - (hi << 16));
2882 reg = jit_get_reg(jit_class_gpr);
2883 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2885 STB(r0, rn(reg), lo);
2887 if (inv) jit_unget_reg(_R0);
2890 reg = jit_get_reg(jit_class_gpr);
2898 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2901 if (r0 == _R0_REGNO) {
2902 if (r1 != _R0_REGNO)
2905 reg = jit_get_reg(jit_class_gpr);
2907 STBX(r2, rn(reg), r1);
2916 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2921 else if (can_sign_extend_short_p(i0)) {
2922 if (r0 == _R0_REGNO) {
2923 reg = jit_get_reg(jit_class_gpr);
2925 STB(r1, rn(reg), i0);
2932 reg = jit_get_reg(jit_class_gpr);
2934 stxr_c(rn(reg), r0, r1);
2940 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2945 if (can_sign_extend_short_p(i0))
2946 STH(r0, _R0_REGNO, i0);
2947 else if (can_sign_extend_int_p(i0)) {
2948 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2949 lo = (jit_int16_t)(i0 - (hi << 16));
2950 reg = jit_get_reg(jit_class_gpr);
2951 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2953 STH(r0, rn(reg), lo);
2955 if (inv) jit_unget_reg(_R0);
2958 reg = jit_get_reg(jit_class_gpr);
2966 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2969 if (r0 == _R0_REGNO) {
2970 if (r1 != _R0_REGNO)
2973 reg = jit_get_reg(jit_class_gpr);
2975 STHX(r2, rn(reg), r1);
2984 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2989 else if (can_sign_extend_short_p(i0)) {
2990 if (r0 == _R0_REGNO) {
2991 reg = jit_get_reg(jit_class_gpr);
2993 STH(r1, rn(reg), i0);
3000 reg = jit_get_reg(jit_class_gpr);
3002 stxr_s(rn(reg), r0, r1);
3008 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3013 if (can_sign_extend_short_p(i0))
3014 STW(r0, _R0_REGNO, i0);
3015 else if (can_sign_extend_int_p(i0)) {
3016 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3017 lo = (jit_int16_t)(i0 - (hi << 16));
3018 reg = jit_get_reg(jit_class_gpr);
3019 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3021 STW(r0, rn(reg), lo);
3023 if (inv) jit_unget_reg(_R0);
3026 reg = jit_get_reg(jit_class_gpr);
3034 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3037 if (r0 == _R0_REGNO) {
3038 if (r1 != _R0_REGNO)
3041 reg = jit_get_reg(jit_class_gpr);
3043 STWX(r2, rn(reg), r1);
3052 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3057 else if (can_sign_extend_short_p(i0)) {
3058 if (r0 == _R0_REGNO) {
3059 reg = jit_get_reg(jit_class_gpr);
3061 STW(r1, rn(reg), i0);
3068 reg = jit_get_reg(jit_class_gpr);
3070 stxr_i(rn(reg), r0, r1);
3075 # if __WORDSIZE == 64
3077 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3082 if (can_sign_extend_short_p(i0))
3083 STD(r0, _R0_REGNO, i0);
3084 else if (can_sign_extend_int_p(i0)) {
3085 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3086 lo = (jit_int16_t)(i0 - (hi << 16));
3087 reg = jit_get_reg(jit_class_gpr);
3088 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3090 STD(r0, rn(reg), lo);
3092 if (inv) jit_unget_reg(_R0);
3095 reg = jit_get_reg(jit_class_gpr);
3103 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3106 if (r0 == _R0_REGNO) {
3107 if (r1 != _R0_REGNO)
3110 reg = jit_get_reg(jit_class_gpr);
3112 STDX(r2, rn(reg), r1);
3121 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3126 else if (can_sign_extend_short_p(i0)) {
3127 if (r0 == _R0_REGNO) {
3128 reg = jit_get_reg(jit_class_gpr);
3130 STD(r1, rn(reg), i0);
3137 reg = jit_get_reg(jit_class_gpr);
3139 stxr_l(rn(reg), r0, r1);
3146 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3157 /* pc relative jump */
3159 _jmpi(jit_state_t *_jit, jit_word_t i0)
3165 if (can_sign_extend_jump_p(d))
3168 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3169 w = movi_p(rn(reg), i0);
3178 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3182 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3183 w = movi_p(rn(reg), i0);
3190 _callr(jit_state_t *_jit, jit_int32_t r0
3192 , jit_int32_t varargs
3197 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3198 /* FIXME Pretend to not know about r11? */
3199 if (r0 == _R0_REGNO) {
3200 movr(_R11_REGNO, _R0_REGNO);
3201 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3202 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3205 ldxi(_R2_REGNO, r0, sizeof(void*));
3206 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3211 /* Tell double arguments were passed in registers. */
3215 movr(_R12_REGNO, r0);
3222 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3226 /* assume fixed address or reachable address */
3228 _calli(jit_state_t *_jit, jit_word_t i0
3230 , jit_int32_t varargs
3236 d = (i0 - _jit->pc.w) & ~3;
3237 if (can_sign_extend_jump_p(d))
3242 movi(_R12_REGNO, i0);
3253 _calli_p(jit_state_t *_jit, jit_word_t i0
3255 , jit_int32_t varargs
3260 w = movi_p(_R12_REGNO, i0);
3269 /* order is not guaranteed to be sequential */
3270 static jit_int32_t save[] = {
3271 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3272 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3276 _prolog(jit_state_t *_jit, jit_node_t *node)
3278 unsigned long regno;
3281 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3282 jit_int32_t frame = -_jitc->function->frame;
3283 assert(_jitc->function->self.aoff >= frame);
3284 if (_jitc->function->assume_frame)
3286 _jitc->function->self.aoff = frame;
3288 if (_jitc->function->allocar) {
3289 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3290 _jitc->function->self.aoff &= -16;
3292 _jitc->function->stack = ((_jitc->function->self.alen +
3293 _jitc->function->self.size -
3294 _jitc->function->self.aoff) + 15) & -16;
3296 /* return address */
3299 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3300 * alloca < %r31-80 */
3303 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3305 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3307 offset = -gpr_save_area;
3308 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3309 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3310 stxi(offset, _SP_REGNO, rn(save[regno]));
3312 for (offset = 0; offset < 8; offset++) {
3313 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3314 stxi_d(-(gpr_save_area + 8 + offset * 8),
3315 _SP_REGNO, rn(_F14 + offset));
3318 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3320 movr(_FP_REGNO, _SP_REGNO);
3321 #if __WORDSIZE == 32
3322 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3324 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3327 if (_jitc->function->allocar) {
3328 regno = jit_get_reg(jit_class_gpr);
3329 movi(rn(regno), _jitc->function->self.aoff);
3330 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3331 jit_unget_reg(regno);
3335 if (_jitc->function->self.call & jit_call_varargs) {
3336 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3337 stxi(params_offset + regno * sizeof(jit_word_t),
3338 _FP_REGNO, rn(JIT_RA0 - regno));
3341 if (_jitc->function->self.call & jit_call_varargs) {
3342 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3343 stxi(_jitc->function->vaoff + first_gp_offset +
3344 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3345 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3346 stxi_d(_jitc->function->vaoff + first_fp_offset +
3347 regno * va_fp_increment, _FP_REGNO,
3348 rn(JIT_FA0 - regno));
3354 _epilog(jit_state_t *_jit, jit_node_t *node)
3356 unsigned long regno;
3359 if (_jitc->function->assume_frame)
3361 if (_jitc->function->allocar)
3362 ldr(_SP_REGNO, _SP_REGNO);
3364 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3366 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3368 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3370 offset = -gpr_save_area;
3371 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3372 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3373 ldxi(rn(save[regno]), _SP_REGNO, offset);
3375 for (offset = 0; offset < 8; offset++) {
3376 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3377 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3378 -(gpr_save_area + 8 + offset * 8));
3382 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3388 _vastart(jit_state_t *_jit, jit_int32_t r0)
3391 assert(_jitc->function->self.call & jit_call_varargs);
3392 /* Initialize stack pointer to the first stack argument. */
3393 addi(r0, _FP_REGNO, _jitc->function->self.size);
3396 assert(_jitc->function->self.call & jit_call_varargs);
3398 /* Return jit_va_list_t in the register argument */
3399 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3400 reg = jit_get_reg(jit_class_gpr);
3402 /* Initialize the gp counter. */
3403 movi(rn(reg), _jitc->function->vagp);
3404 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3406 /* Initialize the fp counter. */
3407 movi(rn(reg), _jitc->function->vafp);
3408 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3410 /* Initialize overflow pointer to the first stack argument. */
3411 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3412 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3414 /* Initialize register save area pointer. */
3415 addi(rn(reg), r0, first_gp_offset);
3416 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3423 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3426 assert(_jitc->function->self.call & jit_call_varargs);
3427 /* Load argument. */
3429 /* Update va_list. */
3430 addi(r1, r1, sizeof(jit_word_t));
3437 assert(_jitc->function->self.call & jit_call_varargs);
3439 rg0 = jit_get_reg(jit_class_gpr);
3440 rg1 = jit_get_reg(jit_class_gpr);
3442 /* Load the gp offset in save area in the first temporary. */
3443 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3445 /* Jump over if there are no remaining arguments in the save area. */
3446 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3448 /* Update the gp counter. */
3449 addi(rn(rg1), rn(rg0), 1);
3450 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3452 /* Load the save area pointer in the second temporary. */
3453 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3455 /* Load the vararg argument in the first argument. */
3456 lshi(rn(rg0), rn(rg0), va_gp_shift);
3457 ldxr(r0, rn(rg1), rn(rg0));
3459 /* Will only need one temporary register below. */
3462 /* Jump over overflow code. */
3463 lt_code = _jit->pc.w;
3466 /* Where to land if argument is in overflow area. */
3467 patch_at(ge_code, _jit->pc.w);
3469 /* Load overflow pointer. */
3470 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3472 /* Load argument. */
3475 /* Update overflow pointer. */
3476 addi(rn(rg0), rn(rg0), va_gp_increment);
3477 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3479 /* Where to land if argument is in save area. */
3480 patch_at(lt_code, _jit->pc.w);
3487 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3490 assert(_jitc->function->self.call & jit_call_varargs);
3491 /* Load argument. */
3493 /* Update va_list. */
3494 addi(r1, r1, sizeof(jit_float64_t));
3501 assert(_jitc->function->self.call & jit_call_varargs);
3503 rg0 = jit_get_reg(jit_class_gpr);
3504 rg1 = jit_get_reg(jit_class_gpr);
3506 /* Load the fp offset in save area in the first temporary. */
3507 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3509 /* Jump over if there are no remaining arguments in the save area. */
3510 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3512 /* Update the fp counter. */
3513 addi(rn(rg1), rn(rg0), 1);
3514 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3516 /* Load the save area pointer in the second temporary. */
3517 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3519 /* Load the vararg argument in the first argument. */
3520 lshi(rn(rg0), rn(rg0), 3);
3521 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3522 offsetof(jit_va_list_t, first_gp_argument));
3523 ldxr_d(r0, rn(rg1), rn(rg0));
3525 /* Jump over overflow code. */
3526 lt_code = _jit->pc.w;
3529 /* Where to land if argument is in overflow area. */
3530 patch_at(ge_code, _jit->pc.w);
3532 /* Load overflow pointer. */
3533 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3535 # if __WORDSIZE == 32
3536 /* Align if required. */
3537 andi(rn(rg1), rn(rg0), 7);
3538 addr(rn(rg0), rn(rg0), rn(rg1));
3541 /* Load argument. */
3544 /* Update overflow pointer. */
3545 addi(rn(rg0), rn(rg0), va_fp_increment);
3546 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3548 /* Where to land if argument is in save area. */
3549 patch_at(lt_code, _jit->pc.w);
3557 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3565 switch ((u.i[0] & 0xfc000000) >> 26) {
3569 if (!can_sign_extend_short_p(d)) {
3570 /* use absolute address */
3571 assert(can_sign_extend_short_p(label));
3574 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3578 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3579 /* zero is used for toc and env, so, quick check
3580 * if this is a "jmpi main" like initial jit
3582 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3583 for (d = 0; d < _jitc->prolog.offset; d++) {
3584 /* not so pretty, but hides powerpc
3585 * specific abi intrinsics and/or
3586 * implementation from user */
3587 if (_jitc->prolog.ptr[d] == label) {
3588 label += sizeof(void*) * 3;
3597 if (!can_sign_extend_jump_p(d)) {
3598 /* use absolute address */
3599 assert(can_sign_extend_jump_p(label));
3602 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3605 #if __WORDSIZE == 32
3606 # define MTCTR_OFF 2
3609 # define MTCTR_OFF 6
3613 /* movi reg label; jmpr reg */
3616 /* check for MLTR(reg) */
3617 (u.i[MTCTR_OFF] >> 26) == 31 &&
3618 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3619 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3621 u.i[BCTR_OFF] == 0x4e800020) {
3623 /* check for MTCTR(reg) */
3624 (u.i[MTCTR_OFF] >> 26) == 31 &&
3625 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3626 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3627 /* check for BCTR */
3628 u.i[BCTR_OFF] == 0x4e800420) {
3630 /* zero is used for toc and env, so, quick check
3631 * if this is a "jmpi main" like initial jit
3633 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3634 for (d = 0; d < _jitc->prolog.offset; d++) {
3635 /* not so pretty, but hides powerpc
3636 * specific abi intrinsics and/or
3637 * implementation from user */
3638 if (_jitc->prolog.ptr[d] == label) {
3639 label += sizeof(void*) * 3;
3648 #if __WORDSIZE == 32
3649 assert(!(u.i[0] & 0x1f0000));
3650 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3651 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3652 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3653 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3655 assert(!(u.i[0] & 0x1f0000));
3656 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3657 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3658 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3659 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3660 /* not fully validating SLDI */
3661 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3662 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3663 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3664 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3665 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3666 /* not fully validating SLDI */
3667 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3668 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3669 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3670 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3671 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3675 assert(!"unhandled branch opcode");