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 CLRLDI(r0, rn(reg), 32);
1167 # if __WORDSIZE == 64
1169 _htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1172 reg = jit_get_reg(jit_class_gpr);
1173 rshi_u(rn(reg), r1, 32);
1175 htonr_ui(rn(reg), rn(reg));
1177 orr(r0, r0, rn(reg));
1184 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1187 if (can_sign_extend_short_p(i0))
1189 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1190 ADDIS(r0, r1, i0 >> 16);
1192 reg = jit_get_reg(jit_class_gpr);
1194 ADD(r0, r1, rn(reg));
1200 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1203 if (can_sign_extend_short_p(i0))
1206 reg = jit_get_reg(jit_class_gpr);
1208 ADDC(r0, r1, rn(reg));
1214 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1217 reg = jit_get_reg(jit_class_gpr);
1219 ADDE(r0, r1, rn(reg));
1224 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1227 jit_word_t ni0 = -i0;
1228 if (can_sign_extend_short_p(ni0))
1230 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1231 ADDIS(r0, r1, ni0 >> 16);
1233 reg = jit_get_reg(jit_class_gpr);
1235 SUB(r0, r1, rn(reg));
1241 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1244 reg = jit_get_reg(jit_class_gpr);
1246 SUBC(r0, r1, rn(reg));
1251 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1254 reg = jit_get_reg(jit_class_gpr);
1256 SUBE(r0, r1, rn(reg));
1261 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1268 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1271 if (can_sign_extend_short_p(i0))
1274 reg = jit_get_reg(jit_class_gpr);
1276 mulr(r0, r1, rn(reg));
1282 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1283 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1286 if (r0 == r2 || r0 == r3) {
1287 reg = jit_get_reg(jit_class_gpr);
1288 mullr(rn(reg), r2, r3);
1295 mulhr_u(r1, r2, r3);
1296 if (r0 == r2 || r0 == r3) {
1303 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1304 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1307 reg = jit_get_reg(jit_class_gpr);
1309 iqmulr(r0, r1, r2, rn(reg), sign);
1314 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1317 reg = jit_get_reg(jit_class_gpr);
1319 divr(r0, r1, rn(reg));
1324 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1327 reg = jit_get_reg(jit_class_gpr);
1329 divr_u(r0, r1, rn(reg));
1334 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1335 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1337 jit_int32_t sv0, rg0;
1338 jit_int32_t sv1, rg1;
1340 if (r0 == r2 || r0 == r3) {
1341 sv0 = jit_get_reg(jit_class_gpr);
1346 if (r1 == r2 || r1 == r3) {
1347 sv1 = jit_get_reg(jit_class_gpr);
1356 divr_u(rg0, r2, r3);
1370 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1371 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1374 reg = jit_get_reg(jit_class_gpr);
1376 iqdivr(r0, r1, r2, rn(reg), sign);
1381 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1384 if (r0 == r1 || r0 == r2) {
1385 reg = jit_get_reg(jit_class_gpr);
1386 divr(rn(reg), r1, r2);
1387 mulr(rn(reg), r2, rn(reg));
1388 subr(r0, r1, rn(reg));
1399 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1402 reg = jit_get_reg(jit_class_gpr);
1404 remr(r0, r1, rn(reg));
1409 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1412 if (r0 == r1 || r0 == r2) {
1413 reg = jit_get_reg(jit_class_gpr);
1414 divr_u(rn(reg), r1, r2);
1415 mulr(rn(reg), r2, rn(reg));
1416 subr(r0, r1, rn(reg));
1427 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1430 reg = jit_get_reg(jit_class_gpr);
1432 remr_u(r0, r1, rn(reg));
1437 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1440 if (can_zero_extend_short_p(i0))
1442 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1443 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1445 reg = jit_get_reg(jit_class_gpr);
1447 AND(r0, r1, rn(reg));
1453 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1456 if (can_zero_extend_short_p(i0))
1458 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1459 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1461 reg = jit_get_reg(jit_class_gpr);
1463 OR(r0, r1, rn(reg));
1469 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1472 if (can_zero_extend_short_p(i0))
1474 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1475 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1477 reg = jit_get_reg(jit_class_gpr);
1479 XOR(r0, r1, rn(reg));
1485 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1490 # if __WORDSIZE == 32
1499 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1504 # if __WORDSIZE == 32
1513 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1518 # if __WORDSIZE == 32
1527 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1531 EXTRWI(r0, r0, 1, CR_LT);
1535 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1538 if (can_sign_extend_short_p(i0))
1541 reg = jit_get_reg(jit_class_gpr);
1547 EXTRWI(r0, r0, 1, CR_LT);
1551 _ltr_u(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_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1562 if (can_zero_extend_short_p(i0))
1565 reg = jit_get_reg(jit_class_gpr);
1571 EXTRWI(r0, r0, 1, CR_LT);
1575 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1578 CRNOT(CR_GT, CR_GT);
1580 EXTRWI(r0, r0, 1, CR_GT);
1584 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1587 if (can_sign_extend_short_p(i0))
1590 reg = jit_get_reg(jit_class_gpr);
1595 CRNOT(CR_GT, CR_GT);
1597 EXTRWI(r0, r0, 1, CR_GT);
1601 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1604 CRNOT(CR_GT, CR_GT);
1606 EXTRWI(r0, r0, 1, CR_GT);
1610 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1613 if (can_zero_extend_short_p(i0))
1616 reg = jit_get_reg(jit_class_gpr);
1621 CRNOT(CR_GT, CR_GT);
1623 EXTRWI(r0, r0, 1, CR_GT);
1627 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1631 EXTRWI(r0, r0, 1, CR_EQ);
1635 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1638 if (can_sign_extend_short_p(i0))
1640 else if (can_zero_extend_short_p(i0))
1643 reg = jit_get_reg(jit_class_gpr);
1649 EXTRWI(r0, r0, 1, CR_EQ);
1653 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1656 CRNOT(CR_LT, CR_LT);
1658 EXTRWI(r0, r0, 1, CR_LT);
1662 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1665 if (can_sign_extend_short_p(i0))
1668 reg = jit_get_reg(jit_class_gpr);
1673 CRNOT(CR_LT, CR_LT);
1675 EXTRWI(r0, r0, 1, CR_LT);
1679 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1682 CRNOT(CR_LT, CR_LT);
1684 EXTRWI(r0, r0, 1, CR_LT);
1688 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1691 if (can_zero_extend_short_p(i0))
1694 reg = jit_get_reg(jit_class_gpr);
1699 CRNOT(CR_LT, CR_LT);
1701 EXTRWI(r0, r0, 1, CR_LT);
1705 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1709 EXTRWI(r0, r0, 1, CR_GT);
1713 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1716 if (can_sign_extend_short_p(i0))
1719 reg = jit_get_reg(jit_class_gpr);
1725 EXTRWI(r0, r0, 1, CR_GT);
1729 _gtr_u(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_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1740 if (can_zero_extend_short_p(i0))
1743 reg = jit_get_reg(jit_class_gpr);
1749 EXTRWI(r0, r0, 1, CR_GT);
1753 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1756 CRNOT(CR_EQ, CR_EQ);
1758 EXTRWI(r0, r0, 1, CR_EQ);
1762 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1765 if (can_sign_extend_short_p(i0))
1767 else if (can_zero_extend_short_p(i0))
1770 reg = jit_get_reg(jit_class_gpr);
1775 CRNOT(CR_EQ, CR_EQ);
1777 EXTRWI(r0, r0, 1, CR_EQ);
1781 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1792 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1796 if (can_sign_extend_short_p(i1))
1799 reg = jit_get_reg(jit_class_gpr);
1811 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1822 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1826 if (can_zero_extend_short_p(i1))
1829 reg = jit_get_reg(jit_class_gpr);
1841 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1852 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1856 if (can_sign_extend_short_p(i1))
1859 reg = jit_get_reg(jit_class_gpr);
1871 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1882 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1886 if (can_zero_extend_short_p(i1))
1889 reg = jit_get_reg(jit_class_gpr);
1901 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1912 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1916 if (can_sign_extend_short_p(i1))
1918 else if (can_zero_extend_short_p(i1))
1921 reg = jit_get_reg(jit_class_gpr);
1933 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1944 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1948 if (can_sign_extend_short_p(i1))
1951 reg = jit_get_reg(jit_class_gpr);
1963 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1974 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1978 if (can_zero_extend_short_p(i1))
1981 reg = jit_get_reg(jit_class_gpr);
1993 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2004 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2008 if (can_sign_extend_short_p(i1))
2011 reg = jit_get_reg(jit_class_gpr);
2023 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2034 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2038 if (can_zero_extend_short_p(i1))
2041 reg = jit_get_reg(jit_class_gpr);
2053 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2064 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2068 if (can_sign_extend_short_p(i1))
2070 else if (can_zero_extend_short_p(i1))
2073 reg = jit_get_reg(jit_class_gpr);
2085 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2089 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2090 andr(rn(reg), r0, r1);
2091 w = bnei(i0, rn(reg), 0);
2097 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2101 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2102 andi(rn(reg), r0, i1);
2103 w = bnei(i0, rn(reg), 0);
2109 _bmcr(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 = beqi(i0, rn(reg), 0);
2121 _bmci(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 = beqi(i0, rn(reg), 0);
2133 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2140 BGT(d); /* GT = bit 1 of XER = OV */
2145 _boaddi(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);
2151 w = boaddr(i0, r0, rn(reg));
2157 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2169 _bxaddi(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 = bxaddr(i0, r0, rn(reg));
2181 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2193 _bosubi(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 = bosubr(i0, r0, rn(reg));
2205 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2217 _bxsubi(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 = bxsubr(i0, r0, rn(reg));
2229 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2236 BEQ(d); /* EQ = bit 2 of XER = CA */
2241 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2245 if (can_sign_extend_short_p(i1)) {
2253 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2255 w = boaddr_u(i0, r0, rn(reg));
2261 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2273 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2277 if (can_sign_extend_short_p(i1)) {
2285 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2287 w = bxaddr_u(i0, r0, rn(reg));
2293 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2300 BNE(d); /* PPC uses "carry" not "borrow" */
2305 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2309 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2311 w = bosubr_u(i0, r0, rn(reg));
2317 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2329 _bxsubi_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 = bxsubr_u(i0, r0, rn(reg));
2341 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2348 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2355 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2357 ldxr_uc(r0, r1, r2);
2362 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2364 ldxi_uc(r0, r1, i0);
2369 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2374 if (can_sign_extend_short_p(i0))
2375 LBZ(r0, _R0_REGNO, i0);
2376 else if (can_sign_extend_int_p(i0)) {
2377 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2378 lo = (jit_int16_t)(i0 - (hi << 16));
2379 reg = jit_get_reg(jit_class_gpr);
2380 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2382 LBZ(r0, rn(reg), lo);
2384 if (inv) jit_unget_reg(_R0);
2387 reg = jit_get_reg(jit_class_gpr);
2389 ldr_uc(r0, rn(reg));
2395 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2398 if (r1 == _R0_REGNO) {
2399 if (r2 != _R0_REGNO)
2402 reg = jit_get_reg(jit_class_gpr);
2404 LBZX(r0, rn(reg), r2);
2413 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2418 else if (can_sign_extend_short_p(i0)) {
2419 if (r1 == _R0_REGNO) {
2420 reg = jit_get_reg(jit_class_gpr);
2422 LBZ(r0, rn(reg), i0);
2429 reg = jit_get_reg(jit_class_gpr);
2431 ldxr_uc(r0, r1, rn(reg));
2437 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2442 if (can_sign_extend_short_p(i0))
2443 LHA(r0, _R0_REGNO, i0);
2444 else if (can_sign_extend_int_p(i0)) {
2445 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2446 lo = (jit_int16_t)(i0 - (hi << 16));
2447 reg = jit_get_reg(jit_class_gpr);
2448 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2450 LHA(r0, rn(reg), lo);
2452 if (inv) jit_unget_reg(_R0);
2455 reg = jit_get_reg(jit_class_gpr);
2463 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2466 if (r1 == _R0_REGNO) {
2467 if (r2 != _R0_REGNO)
2470 reg = jit_get_reg(jit_class_gpr);
2472 LHAX(r0, rn(reg), r2);
2481 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2486 else if (can_sign_extend_short_p(i0)) {
2487 if (r1 == _R0_REGNO) {
2488 reg = jit_get_reg(jit_class_gpr);
2490 LHA(r0, rn(reg), i0);
2497 reg = jit_get_reg(jit_class_gpr);
2499 ldxr_s(r0, r1, rn(reg));
2505 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2510 if (can_sign_extend_short_p(i0))
2511 LHZ(r0, _R0_REGNO, i0);
2512 else if (can_sign_extend_int_p(i0)) {
2513 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2514 lo = (jit_int16_t)(i0 - (hi << 16));
2515 reg = jit_get_reg(jit_class_gpr);
2516 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2518 LHZ(r0, rn(reg), lo);
2520 if (inv) jit_unget_reg(_R0);
2523 reg = jit_get_reg(jit_class_gpr);
2525 ldr_us(r0, rn(reg));
2531 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2534 if (r1 == _R0_REGNO) {
2535 if (r2 != _R0_REGNO)
2538 reg = jit_get_reg(jit_class_gpr);
2540 LHZX(r0, rn(reg), r2);
2549 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2554 else if (can_sign_extend_short_p(i0)) {
2555 if (r1 == _R0_REGNO) {
2556 reg = jit_get_reg(jit_class_gpr);
2558 LHZ(r0, rn(reg), i0);
2565 reg = jit_get_reg(jit_class_gpr);
2567 ldxr_us(r0, r1, rn(reg));
2572 # if __WORDSIZE == 32
2574 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2579 if (can_sign_extend_short_p(i0))
2580 LWZ(r0, _R0_REGNO, i0);
2581 else if (can_sign_extend_int_p(i0)) {
2582 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2583 lo = (jit_int16_t)(i0 - (hi << 16));
2584 reg = jit_get_reg(jit_class_gpr);
2585 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2587 LWZ(r0, rn(reg), lo);
2589 if (inv) jit_unget_reg(_R0);
2592 reg = jit_get_reg(jit_class_gpr);
2600 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2603 if (r1 == _R0_REGNO) {
2604 if (r2 != _R0_REGNO)
2607 reg = jit_get_reg(jit_class_gpr);
2609 LWZX(r0, rn(reg), r2);
2618 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2623 else if (can_sign_extend_short_p(i0)) {
2624 if (r1 == _R0_REGNO) {
2625 reg = jit_get_reg(jit_class_gpr);
2627 LWZ(r0, rn(reg), i0);
2634 reg = jit_get_reg(jit_class_gpr);
2636 ldxr_i(r0, r1, rn(reg));
2643 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2648 if (can_sign_extend_short_p(i0))
2649 LWA(r0, _R0_REGNO, i0);
2650 else if (can_sign_extend_int_p(i0)) {
2651 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2652 lo = (jit_int16_t)(i0 - (hi << 16));
2653 reg = jit_get_reg(jit_class_gpr);
2654 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2656 LWA(r0, rn(reg), lo);
2658 if (inv) jit_unget_reg(_R0);
2661 reg = jit_get_reg(jit_class_gpr);
2669 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2672 if (r1 == _R0_REGNO) {
2673 if (r2 != _R0_REGNO)
2676 reg = jit_get_reg(jit_class_gpr);
2678 LWAX(r0, rn(reg), r2);
2687 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2692 else if (can_sign_extend_short_p(i0)) {
2693 if (r1 == _R0_REGNO) {
2694 reg = jit_get_reg(jit_class_gpr);
2696 LWA(r0, rn(reg), i0);
2703 reg = jit_get_reg(jit_class_gpr);
2705 ldxr_i(r0, r1, rn(reg));
2711 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2716 if (can_sign_extend_short_p(i0))
2717 LWZ(r0, _R0_REGNO, i0);
2718 else if (can_sign_extend_int_p(i0)) {
2719 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2720 lo = (jit_int16_t)(i0 - (hi << 16));
2721 reg = jit_get_reg(jit_class_gpr);
2722 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2724 LWZ(r0, rn(reg), lo);
2726 if (inv) jit_unget_reg(_R0);
2729 reg = jit_get_reg(jit_class_gpr);
2731 ldr_ui(r0, rn(reg));
2737 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2740 if (r1 == _R0_REGNO) {
2741 if (r2 != _R0_REGNO)
2744 reg = jit_get_reg(jit_class_gpr);
2746 LWZX(r0, rn(reg), r2);
2755 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2760 else if (can_sign_extend_short_p(i0)) {
2761 if (r1 == _R0_REGNO) {
2762 reg = jit_get_reg(jit_class_gpr);
2764 LWZ(r0, rn(reg), i0);
2771 reg = jit_get_reg(jit_class_gpr);
2773 ldxr_ui(r0, r1, rn(reg));
2779 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2784 if (can_sign_extend_short_p(i0))
2785 LD(r0, _R0_REGNO, i0);
2786 else if (can_sign_extend_int_p(i0)) {
2787 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2788 lo = (jit_int16_t)(i0 - (hi << 16));
2789 reg = jit_get_reg(jit_class_gpr);
2790 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2792 LD(r0, rn(reg), lo);
2794 if (inv) jit_unget_reg(_R0);
2797 reg = jit_get_reg(jit_class_gpr);
2805 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2808 if (r1 == _R0_REGNO) {
2809 if (r2 != _R0_REGNO)
2812 reg = jit_get_reg(jit_class_gpr);
2814 LDX(r0, rn(reg), r2);
2823 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2828 else if (can_sign_extend_short_p(i0)) {
2829 if (r1 == _R0_REGNO) {
2830 reg = jit_get_reg(jit_class_gpr);
2832 LD(r0, rn(reg), i0);
2839 reg = jit_get_reg(jit_class_gpr);
2841 ldxr_l(r0, r1, rn(reg));
2848 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2853 if (can_sign_extend_short_p(i0))
2854 STB(r0, _R0_REGNO, i0);
2855 else if (can_sign_extend_int_p(i0)) {
2856 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2857 lo = (jit_int16_t)(i0 - (hi << 16));
2858 reg = jit_get_reg(jit_class_gpr);
2859 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2861 STB(r0, rn(reg), lo);
2863 if (inv) jit_unget_reg(_R0);
2866 reg = jit_get_reg(jit_class_gpr);
2874 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2877 if (r0 == _R0_REGNO) {
2878 if (r1 != _R0_REGNO)
2881 reg = jit_get_reg(jit_class_gpr);
2883 STBX(r2, rn(reg), r1);
2892 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2897 else if (can_sign_extend_short_p(i0)) {
2898 if (r0 == _R0_REGNO) {
2899 reg = jit_get_reg(jit_class_gpr);
2901 STB(r1, rn(reg), i0);
2908 reg = jit_get_reg(jit_class_gpr);
2910 stxr_c(rn(reg), r0, r1);
2916 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2921 if (can_sign_extend_short_p(i0))
2922 STH(r0, _R0_REGNO, i0);
2923 else if (can_sign_extend_int_p(i0)) {
2924 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2925 lo = (jit_int16_t)(i0 - (hi << 16));
2926 reg = jit_get_reg(jit_class_gpr);
2927 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2929 STH(r0, rn(reg), lo);
2931 if (inv) jit_unget_reg(_R0);
2934 reg = jit_get_reg(jit_class_gpr);
2942 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2945 if (r0 == _R0_REGNO) {
2946 if (r1 != _R0_REGNO)
2949 reg = jit_get_reg(jit_class_gpr);
2951 STHX(r2, rn(reg), r1);
2960 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2965 else if (can_sign_extend_short_p(i0)) {
2966 if (r0 == _R0_REGNO) {
2967 reg = jit_get_reg(jit_class_gpr);
2969 STH(r1, rn(reg), i0);
2976 reg = jit_get_reg(jit_class_gpr);
2978 stxr_s(rn(reg), r0, r1);
2984 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2989 if (can_sign_extend_short_p(i0))
2990 STW(r0, _R0_REGNO, i0);
2991 else if (can_sign_extend_int_p(i0)) {
2992 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2993 lo = (jit_int16_t)(i0 - (hi << 16));
2994 reg = jit_get_reg(jit_class_gpr);
2995 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2997 STW(r0, rn(reg), lo);
2999 if (inv) jit_unget_reg(_R0);
3002 reg = jit_get_reg(jit_class_gpr);
3010 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3013 if (r0 == _R0_REGNO) {
3014 if (r1 != _R0_REGNO)
3017 reg = jit_get_reg(jit_class_gpr);
3019 STWX(r2, rn(reg), r1);
3028 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3033 else if (can_sign_extend_short_p(i0)) {
3034 if (r0 == _R0_REGNO) {
3035 reg = jit_get_reg(jit_class_gpr);
3037 STW(r1, rn(reg), i0);
3044 reg = jit_get_reg(jit_class_gpr);
3046 stxr_i(rn(reg), r0, r1);
3051 # if __WORDSIZE == 64
3053 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3058 if (can_sign_extend_short_p(i0))
3059 STD(r0, _R0_REGNO, i0);
3060 else if (can_sign_extend_int_p(i0)) {
3061 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3062 lo = (jit_int16_t)(i0 - (hi << 16));
3063 reg = jit_get_reg(jit_class_gpr);
3064 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3066 STD(r0, rn(reg), lo);
3068 if (inv) jit_unget_reg(_R0);
3071 reg = jit_get_reg(jit_class_gpr);
3079 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3082 if (r0 == _R0_REGNO) {
3083 if (r1 != _R0_REGNO)
3086 reg = jit_get_reg(jit_class_gpr);
3088 STDX(r2, rn(reg), r1);
3097 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3102 else if (can_sign_extend_short_p(i0)) {
3103 if (r0 == _R0_REGNO) {
3104 reg = jit_get_reg(jit_class_gpr);
3106 STD(r1, rn(reg), i0);
3113 reg = jit_get_reg(jit_class_gpr);
3115 stxr_l(rn(reg), r0, r1);
3122 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3133 /* pc relative jump */
3135 _jmpi(jit_state_t *_jit, jit_word_t i0)
3141 if (can_sign_extend_jump_p(d))
3144 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3145 w = movi_p(rn(reg), i0);
3154 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3158 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3159 w = movi_p(rn(reg), i0);
3166 _callr(jit_state_t *_jit, jit_int32_t r0
3168 , jit_int32_t varargs
3173 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3174 /* FIXME Pretend to not know about r11? */
3175 if (r0 == _R0_REGNO) {
3176 movr(_R11_REGNO, _R0_REGNO);
3177 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3178 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3181 ldxi(_R2_REGNO, r0, sizeof(void*));
3182 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3187 /* Tell double arguments were passed in registers. */
3191 movr(_R12_REGNO, r0);
3198 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3202 /* assume fixed address or reachable address */
3204 _calli(jit_state_t *_jit, jit_word_t i0
3206 , jit_int32_t varargs
3212 d = (i0 - _jit->pc.w) & ~3;
3213 if (can_sign_extend_jump_p(d))
3218 movi(_R12_REGNO, i0);
3229 _calli_p(jit_state_t *_jit, jit_word_t i0
3231 , jit_int32_t varargs
3236 w = movi_p(_R12_REGNO, i0);
3245 /* order is not guaranteed to be sequential */
3246 static jit_int32_t save[] = {
3247 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3248 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3252 _prolog(jit_state_t *_jit, jit_node_t *node)
3254 unsigned long regno;
3257 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3258 jit_int32_t frame = -_jitc->function->frame;
3259 assert(_jitc->function->self.aoff >= frame);
3260 if (_jitc->function->assume_frame)
3262 _jitc->function->self.aoff = frame;
3264 if (_jitc->function->allocar) {
3265 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3266 _jitc->function->self.aoff &= -16;
3268 _jitc->function->stack = ((_jitc->function->self.alen +
3269 _jitc->function->self.size -
3270 _jitc->function->self.aoff) + 15) & -16;
3272 /* return address */
3275 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3276 * alloca < %r31-80 */
3279 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3281 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3283 offset = -gpr_save_area;
3284 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3285 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3286 stxi(offset, _SP_REGNO, rn(save[regno]));
3288 for (offset = 0; offset < 8; offset++) {
3289 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3290 stxi_d(-(gpr_save_area + 8 + offset * 8),
3291 _SP_REGNO, rn(_F14 + offset));
3294 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3296 movr(_FP_REGNO, _SP_REGNO);
3297 #if __WORDSIZE == 32
3298 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3300 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3303 if (_jitc->function->allocar) {
3304 regno = jit_get_reg(jit_class_gpr);
3305 movi(rn(regno), _jitc->function->self.aoff);
3306 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3307 jit_unget_reg(regno);
3311 if (_jitc->function->self.call & jit_call_varargs) {
3312 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3313 stxi(params_offset + regno * sizeof(jit_word_t),
3314 _FP_REGNO, rn(JIT_RA0 - regno));
3317 if (_jitc->function->self.call & jit_call_varargs) {
3318 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3319 stxi(_jitc->function->vaoff + first_gp_offset +
3320 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3321 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3322 stxi_d(_jitc->function->vaoff + first_fp_offset +
3323 regno * va_fp_increment, _FP_REGNO,
3324 rn(JIT_FA0 - regno));
3330 _epilog(jit_state_t *_jit, jit_node_t *node)
3332 unsigned long regno;
3335 if (_jitc->function->assume_frame)
3337 if (_jitc->function->allocar)
3338 ldr(_SP_REGNO, _SP_REGNO);
3340 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3342 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3344 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3346 offset = -gpr_save_area;
3347 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3348 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3349 ldxi(rn(save[regno]), _SP_REGNO, offset);
3351 for (offset = 0; offset < 8; offset++) {
3352 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3353 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3354 -(gpr_save_area + 8 + offset * 8));
3358 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3364 _vastart(jit_state_t *_jit, jit_int32_t r0)
3367 assert(_jitc->function->self.call & jit_call_varargs);
3368 /* Initialize stack pointer to the first stack argument. */
3369 addi(r0, _FP_REGNO, _jitc->function->self.size);
3372 assert(_jitc->function->self.call & jit_call_varargs);
3374 /* Return jit_va_list_t in the register argument */
3375 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3376 reg = jit_get_reg(jit_class_gpr);
3378 /* Initialize the gp counter. */
3379 movi(rn(reg), _jitc->function->vagp);
3380 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3382 /* Initialize the fp counter. */
3383 movi(rn(reg), _jitc->function->vafp);
3384 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3386 /* Initialize overflow pointer to the first stack argument. */
3387 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3388 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3390 /* Initialize register save area pointer. */
3391 addi(rn(reg), r0, first_gp_offset);
3392 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3399 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3402 assert(_jitc->function->self.call & jit_call_varargs);
3403 /* Load argument. */
3405 /* Update va_list. */
3406 addi(r1, r1, sizeof(jit_word_t));
3413 assert(_jitc->function->self.call & jit_call_varargs);
3415 rg0 = jit_get_reg(jit_class_gpr);
3416 rg1 = jit_get_reg(jit_class_gpr);
3418 /* Load the gp offset in save area in the first temporary. */
3419 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3421 /* Jump over if there are no remaining arguments in the save area. */
3422 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3424 /* Update the gp counter. */
3425 addi(rn(rg1), rn(rg0), 1);
3426 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3428 /* Load the save area pointer in the second temporary. */
3429 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3431 /* Load the vararg argument in the first argument. */
3432 lshi(rn(rg0), rn(rg0), va_gp_shift);
3433 ldxr(r0, rn(rg1), rn(rg0));
3435 /* Will only need one temporary register below. */
3438 /* Jump over overflow code. */
3439 lt_code = _jit->pc.w;
3442 /* Where to land if argument is in overflow area. */
3443 patch_at(ge_code, _jit->pc.w);
3445 /* Load overflow pointer. */
3446 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3448 /* Load argument. */
3451 /* Update overflow pointer. */
3452 addi(rn(rg0), rn(rg0), va_gp_increment);
3453 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3455 /* Where to land if argument is in save area. */
3456 patch_at(lt_code, _jit->pc.w);
3463 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3466 assert(_jitc->function->self.call & jit_call_varargs);
3467 /* Load argument. */
3469 /* Update va_list. */
3470 addi(r1, r1, sizeof(jit_float64_t));
3477 assert(_jitc->function->self.call & jit_call_varargs);
3479 rg0 = jit_get_reg(jit_class_gpr);
3480 rg1 = jit_get_reg(jit_class_gpr);
3482 /* Load the fp offset in save area in the first temporary. */
3483 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3485 /* Jump over if there are no remaining arguments in the save area. */
3486 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3488 /* Update the fp counter. */
3489 addi(rn(rg1), rn(rg0), 1);
3490 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3492 /* Load the save area pointer in the second temporary. */
3493 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3495 /* Load the vararg argument in the first argument. */
3496 lshi(rn(rg0), rn(rg0), 3);
3497 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3498 offsetof(jit_va_list_t, first_gp_argument));
3499 ldxr_d(r0, rn(rg1), rn(rg0));
3501 /* Jump over overflow code. */
3502 lt_code = _jit->pc.w;
3505 /* Where to land if argument is in overflow area. */
3506 patch_at(ge_code, _jit->pc.w);
3508 /* Load overflow pointer. */
3509 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3511 # if __WORDSIZE == 32
3512 /* Align if required. */
3513 andi(rn(rg1), rn(rg0), 7);
3514 addr(rn(rg0), rn(rg0), rn(rg1));
3517 /* Load argument. */
3520 /* Update overflow pointer. */
3521 addi(rn(rg0), rn(rg0), va_fp_increment);
3522 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3524 /* Where to land if argument is in save area. */
3525 patch_at(lt_code, _jit->pc.w);
3533 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3541 switch ((u.i[0] & 0xfc000000) >> 26) {
3545 if (!can_sign_extend_short_p(d)) {
3546 /* use absolute address */
3547 assert(can_sign_extend_short_p(label));
3550 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3554 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3555 /* zero is used for toc and env, so, quick check
3556 * if this is a "jmpi main" like initial jit
3558 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3559 for (d = 0; d < _jitc->prolog.offset; d++) {
3560 /* not so pretty, but hides powerpc
3561 * specific abi intrinsics and/or
3562 * implementation from user */
3563 if (_jitc->prolog.ptr[d] == label) {
3564 label += sizeof(void*) * 3;
3573 if (!can_sign_extend_jump_p(d)) {
3574 /* use absolute address */
3575 assert(can_sign_extend_jump_p(label));
3578 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3581 #if __WORDSIZE == 32
3582 # define MTCTR_OFF 2
3585 # define MTCTR_OFF 6
3589 /* movi reg label; jmpr reg */
3592 /* check for MLTR(reg) */
3593 (u.i[MTCTR_OFF] >> 26) == 31 &&
3594 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3595 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3597 u.i[BCTR_OFF] == 0x4e800020) {
3599 /* check for MTCTR(reg) */
3600 (u.i[MTCTR_OFF] >> 26) == 31 &&
3601 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3602 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3603 /* check for BCTR */
3604 u.i[BCTR_OFF] == 0x4e800420) {
3606 /* zero is used for toc and env, so, quick check
3607 * if this is a "jmpi main" like initial jit
3609 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3610 for (d = 0; d < _jitc->prolog.offset; d++) {
3611 /* not so pretty, but hides powerpc
3612 * specific abi intrinsics and/or
3613 * implementation from user */
3614 if (_jitc->prolog.ptr[d] == label) {
3615 label += sizeof(void*) * 3;
3624 #if __WORDSIZE == 32
3625 assert(!(u.i[0] & 0x1f0000));
3626 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3627 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3628 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3629 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3631 assert(!(u.i[0] & 0x1f0000));
3632 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3633 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3634 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3635 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3636 /* not fully validating SLDI */
3637 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3638 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3639 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3640 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3641 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3642 /* not fully validating SLDI */
3643 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3644 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3645 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3646 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3647 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3651 assert(!"unhandled branch opcode");