2 * Copyright (C) 2012-2023 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 # if __WORDSIZE == 32
206 # define CMPX(a,b) CMPW(a,b)
207 # define CMPXI(a,s) CMPWI(a,s)
208 # define CMPLX(a,b) CMPLW(a,b)
209 # define CMPLXI(a,s) CMPLWI(a,s)
211 # define CMPX(a,b) CMPD(a,b)
212 # define CMPXI(a,s) CMPDI(a,s)
213 # define CMPLX(a,b) CMPLD(a,b)
214 # define CMPLXI(a,s) CMPLDI(a,s)
216 # define CNTLZW(a,s) FX(31,s,a,0,26)
217 # define CNTLZW_(a,s) FX_(31,s,a,0,26)
218 # define CNTLZD(a,s) FX(31,s,a,0,58)
219 # define CNTLZD_(a,s) FX_(31,s,a,0,58)
220 # define CRAND(d,a,b) FX(19,d,a,b,257)
221 # define CRANDC(d,a,b) FX(19,d,a,b,129)
222 # define CREQV(d,a,b) FX(19,d,a,b,289)
223 # define CRSET(d) CREQV(d,d,d)
224 # define CRNAND(d,a,b) FX(19,d,a,b,225)
225 # define CRNOR(d,a,b) FX(19,d,a,b,33)
226 # define CRNOT(d,a) CRNOR(d,a,a)
227 # define CROR(d,a,b) FX(19,d,a,b,449)
228 # define CRMOVE(d,a) CROR(d,a,a)
229 # define CRORC(d,a,b) FX(19,d,a,b,417)
230 # define CRXOR(d,a,b) FX(19,d,a,b,193)
231 # define CRCLR(d) CRXOR(d,d,d)
232 # define DCBA(a,b) FX(31,0,a,b,758)
233 # define DCBF(a,b) FX(31,0,a,b,86)
234 # define DCBI(a,b) FX(31,0,a,b,470)
235 # define DCBST(a,b) FX(31,0,a,b,54)
236 # define DCBT(a,b) FX(31,0,a,b,278)
237 # define DCBTST(a,b) FX(31,0,a,b,246)
238 # define DCBZ(a,b) FX(31,0,a,b,1014)
239 # define DIVW(d,a,b) FXO(31,d,a,b,0,491)
240 # define DIVW_(d,a,b) FXO_(31,d,a,b,0,491)
241 # define DIVWO(d,a,b) FXO(31,d,a,b,1,491)
242 # define DIVWO_(d,a,b) FXO_(31,d,a,b,1,491)
243 # define DIVWU(d,a,b) FXO(31,d,a,b,0,459)
244 # define DIVWU_(d,a,b) FXO_(31,d,a,b,0,459)
245 # define DIVWUO(d,a,b) FXO(31,d,a,b,1,459)
246 # define DIVWUO_(d,a,b) FXO_(31,d,a,b,1,459)
247 # define DIVD(d,a,b) FXO(31,d,a,b,0,489)
248 # define DIVD_(d,a,b) FXO_(31,d,a,b,0,489)
249 # define DIVDO(d,a,b) FXO(31,d,a,b,1,489)
250 # define DIVDO_(d,a,b) FXO_(31,d,a,b,1,489)
251 # define DIVDU(d,a,b) FXO(31,d,a,b,0,457)
252 # define DIVDU_(d,a,b) FXO_(31,d,a,b,0,457)
253 # define DIVDUO(d,a,b) FXO(31,d,a,b,1,457)
254 # define DIVDUO_(d,a,b) FXO_(31,d,a,b,1,457)
255 # define ECIWX(d,a,b) FX(31,d,a,b,310)
256 # define ECOWX(s,a,b) FX(31,s,a,b,438)
257 # define EIEIO() FX(31,0,0,0,854)
258 # define EQV(d,a,b) FX(31,a,d,b,284)
259 # define EQV_(d,a,b) FX_(31,a,d,b,284)
260 # define EXTSB(d,a) FX(31,a,d,0,954)
261 # define EXTSB_(d,a) FX_(31,a,d,0,954)
262 # define EXTSH(d,a) FX(31,a,d,0,922)
263 # define EXTSH_(d,a) FX_(31,a,d,0,922)
264 # define EXTSW(d,a) FX(31,a,d,0,986)
265 # define EXTSW_(d,a) FX_(31,a,d,0,986)
266 # define ICIB(a,b) FX(31,0,a,b,982)
267 # define ISYNC() FXL(19,0,0,150)
268 # define LBZ(d,a,s) FDs(34,d,a,s)
269 # define LBZU(d,a,s) FDs(35,d,a,s)
270 # define LBZUX(d,a,b) FX(31,d,a,b,119)
271 # define LBZX(d,a,b) FX(31,d,a,b,87)
272 # define LHA(d,a,s) FDs(42,d,a,s)
273 # define LHAU(d,a,s) FDs(43,d,a,s)
274 # define LHAUX(d,a,b) FX(31,d,a,b,375)
275 # define LHAX(d,a,b) FX(31,d,a,b,343)
276 # define LHBRX(d,a,b) FX(31,d,a,b,790)
277 # define LHZ(d,a,s) FDs(40,d,a,s)
278 # define LHZU(d,a,s) FDs(41,d,a,s)
279 # define LHZUX(d,a,b) FX(31,d,a,b,311)
280 # define LHZX(d,a,b) FX(31,d,a,b,279)
281 # define LA(d,a,s) ADDI(d,a,s)
282 # define LI(d,s) ADDI(d,0,s)
283 # define LMW(d,a,s) FDs(46,d,a,s)
284 # define LSWI(d,a,n) FX(31,d,a,n,597)
285 # define LSWX(d,a,b) FX(31,d,a,b,533)
286 # define LWARX(d,a,b) FX(31,d,a,b,20)
287 # define LDARX(d,a,b) FX(31,d,a,b,84)
288 # define LWBRX(d,a,b) FX(31,d,a,b,534)
289 # define LWA(d,a,s) FDs(58,d,a,s|2)
290 # define LWAUX(d,a,b) FX(31,d,a,b,373)
291 # define LWAX(d,a,b) FX(31,d,a,b,341)
292 # define LWZ(d,a,s) FDs(32,d,a,s)
293 # define LWZU(d,a,s) FDs(33,d,a,s)
294 # define LWZUX(d,a,b) FX(31,d,a,b,55)
295 # define LWZX(d,a,b) FX(31,d,a,b,23)
296 # define LD(d,a,s) FDs(58,d,a,s)
297 # define LDX(d,a,b) FX(31,d,a,b,21)
298 # define MCRF(d,s) FXL(19,d<<2,(s)<<2,0)
300 /* In case instruction is emulated, check the kernel can handle it.
301 Will only generate it if DEBUG is enabled.
303 Chapter 6. Optional Facilities and Instructions that are being
304 Phased Out of the Architecture
306 6.1 Move To Condition Register from XER
307 The mcrxr instruction is being phased out of the archi-
308 tecture. Its description is included here as an aid to
309 constructing operating system code to emulate it.
311 Move to Condition Register from XER
314 31 BF // /// /// 512 /
316 CR(4xBF:4xBF+3) <- XER(32:35)
318 The contents of XER(32:35) are copied to Condition Reg-
319 ister field BF. XER(32:35) are set to zero.
320 Special Registers Altered:
321 CR field BF XER(32:35)
324 Warning: This instruction has been phased out of
325 the architecture. Attempting to execute this
326 instruction will cause the system illegal instruction
327 error handler to be invoked
330 # define MCRXR(d) FX(31,d<<2,0,0,512)
332 # define MCRXR(cr) _MCRXR(_jit,cr);
333 static void _MCRXR(jit_state_t*, jit_int32_t);
335 # define MFCR(d) FX(31,d,0,0,19)
336 # define MFMSR(d) FX(31,d,0,0,83)
337 # define MFSPR(d,s) FXFX(31,d,s<<5,339)
338 # define MFXER(d) MFSPR(d,1)
339 # define MFLR(d) MFSPR(d,8)
340 # define MFCTR(d) MFSPR(d,9)
341 # define MFSR(d,s) FX(31,d,s,0,595)
342 # define MFSRIN(d,b) FX(31,d,0,b,659)
343 # define MFTB(d,x,y) FXFX(31,d,(x)|((y)<<5),371)
344 # define MFTBL(d) MFTB(d,8,12)
345 # define MFTBU(d) MFTB(d,8,13)
346 # define MTCRF(c,s) FXFX(31,s,c<<1,144)
347 # define MTCR(s) MTCRF(0xff,s)
348 # define MTMSR(s) FX(31,s,0,0,146)
349 # define MTSPR(d,s) FXFX(31,d,s<<5,467)
350 # define MTXER(d) MTSPR(d,1)
351 # define MTLR(d) MTSPR(d,8)
352 # define MTCTR(d) MTSPR(d,9)
353 # define MTSR(r,s) FX(31,s<<1,r,0,210)
354 # define MTSRIN(r,b) FX(31,r<<1,0,b,242)
355 # define MULLI(d,a,s) FDs(07,d,a,s)
356 # define MULHW(d,a,b) FXO(31,d,a,b,0,75)
357 # define MULHW_(d,a,b) FXO_(31,d,a,b,0,75)
358 # define MULHWU(d,a,b) FXO(31,d,a,b,0,11)
359 # define MULHWU_(d,a,b) FXO_(31,d,a,b,0,11)
360 # define MULLW(d,a,b) FXO(31,d,a,b,0,235)
361 # define MULLW_(d,a,b) FXO_(31,d,a,b,0,235)
362 # define MULLWO(d,a,b) FXO(31,d,a,b,1,235)
363 # define MULLWO_(d,a,b) FXO_(31,d,a,b,1,235)
364 # define MULHD(d,a,b) FXO(31,d,a,b,0,73)
365 # define MULHD_(d,a,b) FXO_(31,d,a,b,0,73)
366 # define MULHDU(d,a,b) FXO(31,d,a,b,0,9)
367 # define MULHDU_(d,a,b) FXO_(31,d,a,b,0,9)
368 # define MULLD(d,a,b) FXO(31,d,a,b,0,233)
369 # define MULLD_(d,a,b) FXO_(31,d,a,b,0,233)
370 # define MULLDO(d,a,b) FXO(31,d,a,b,1,233)
371 # define MULLDO_(d,a,b) FXO_(31,d,a,b,1,233)
372 # define NAND(d,a,b) FX(31,a,d,b,476)
373 # define NAND_(d,a,b) FX_(31,a,d,b,476)
374 # define NEG(d,a) FXO(31,d,a,0,0,104)
375 # define NEG_(d,a) FXO_(31,d,a,0,0,104)
376 # define NEGO(d,a) FXO(31,d,a,0,1,104)
377 # define NEGO_(d,a) FXO_(31,d,a,0,1,104)
378 # define NOR(d,a,b) FX(31,a,d,b,124)
379 # define NOR_(d,a,b) FX_(31,a,d,b,124)
380 # define NOT(d,s) NOR(d,s,s)
381 # define OR(d,a,b) FX(31,a,d,b,444)
382 # define OR_(d,a,b) FX_(31,a,d,b,444)
383 # define MR(d,a) OR(d,a,a)
384 # define ORC(d,a,b) FX(31,a,d,b,412)
385 # define ORC_(d,a,b) FX_(31,a,d,b,412)
386 # define ORI(d,a,u) FDu(24,a,d,u)
387 # define NOP() ORI(0,0,0)
388 # define ORIS(d,a,u) FDu(25,a,d,u)
389 # define RFI() FXL(19,0,0,50)
390 # define RLWIMI(d,s,h,b,e) FM(20,s,d,h,b,e,0)
391 # define RLWIMI_(d,s,h,b,e) FM(20,s,d,h,b,e,1)
392 # define INSLWI(a,s,n,b) RLWIMI(a,s,32-b,b,b+n-1)
393 # define INSRWI(a,s,n,b) RLWIMI(a,s,32-(b+n),b,(b+n)-1)
394 # define RLWINM(a,s,h,b,e) FM(21,s,a,h,b,e,0)
395 # define RLWINM_(a,s,h,b,e) FM(21,s,a,h,b,e,1)
396 # define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,n-1)
397 # define EXTRWI(a,s,n,b) RLWINM(a,s,b+n,32-n,31)
398 # define ROTLWI(a,s,n) RLWINM(a,s,n,0,31)
399 # define ROTRWI(a,s,n) RLWINM(a,s,32-n,0,31)
400 # define SLWI(a,s,n) RLWINM(a,s,n,0,31-n)
401 # define SRWI(a,s,n) RLWINM(a,s,32-n,n,31)
402 # define CLRLWI(a,s,n) RLWINM(a,s,0,n,31)
403 # define CLRRWI(a,s,n) RLWINM(a,s,0,0,31-n)
404 # define CLRLSWI(a,s,b,n) RLWINM(a,s,n,b-n,31-n)
405 # define RLWNM(a,s,b,m,e) FM(23,s,a,b,m,e,0)
406 # define RLWNM_(a,s,b,m,e) FM(23,s,a,b,m,e,1)
407 # define ROTLW(a,s,b) RLWNM(a,s,b,0,31)
408 # define SC() FDu(17,0,0,2)
409 # define SLW(a,s,b) FX(31,s,a,b,24)
410 # define SLW_(a,s,b) FX_(31,s,a,b,24)
411 # define SRAW(a,s,b) FX(31,s,a,b,792)
412 # define SRAW_(a,s,b) FX_(31,s,a,b,792)
413 # define SRAWI(a,s,h) FX(31,s,a,h,824)
414 # define SRAWI_(a,s,h) FX_(31,s,a,h,824)
415 # define SRW(a,s,b) FX(31,s,a,b,536)
416 # define SRW_(a,s,b) FX_(31,s,a,b,536)
417 # if __WORDSIZE == 64
418 # define RLDICL(a,s,h,b) FMD(30,s,a,h&~32,b,0,h>>5)
419 # define RLDICL_(a,s,h,b) FMD_(30,s,a,h&~32,b,0,h>>5)
420 # define EXTRDI(x,y,n,b) RLDICL(x,y,(b+n),(64-n))
421 # define SRDI(x,y,n) RLDICL(x,y,(64-n),n)
422 # define CLRLDI(x,y,n) RLDICL(x,y,0,n)
423 # define RLDICR(a,s,h,e) FMD(30,s,a,h&~32,e,1,h>>5)
424 # define RLDICR_(a,s,h,e) FMD_(30,s,a,h&~32,e,1,h>>5)
425 # define EXTRLI(x,y,n,b) RLDICR(x,y,b,(n-1))
426 # define SLDI(x,y,n) RLDICR(x,y,n,(63-n))
427 # define CLRRDI(x,y,n) RLDICR(x,y,0,(63-n))
428 # define RLDIC(a,s,h,b) FMD(30,s,a,h&~32,b,2,h>>5)
429 # define RLDIC_(a,s,h,b) FMD_(30,s,a,h&~32,b,2,h>>5)
430 # define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,(b-n))
431 # define RLDCL(a,s,h,b) FMDS(30,s,a,h,b,8)
432 # define RLDCL_(a,s,h,b) FMDS_(30,s,a,h,b,8)
433 # define ROTLD(x,y,z) RLDCL(x,y,z,0)
434 # define RLDCR(a,s,b,e) FMDS(30,s,a,b,e,0)
435 # define RLDCR_(a,s,b,e) FMDS_(30,s,a,b,e,0)
436 # define RLDIMI(a,s,h,b) FMD(30,s,a,h&~32,b,3,h>>5)
437 # define RLDIMI_(a,s,h,b) FMD_(30,s,a,h&~32,b,3,h>>5)
438 # define INSRDI(x,y,n,b) RLDIMI(x,y,(64-(b+n)),b)
439 # define SLD(a,s,b) FX(31,s,a,b,27)
440 # define SLD_(a,s,b) FX_(31,s,a,b,27)
441 # define SRD(a,s,b) FX(31,s,a,b,539)
442 # define SRD_(a,s,b) FX_(31,s,a,b,539)
443 # define SRADI(a,s,h) FXS(31,s,a,h&~32,413,h>>5)
444 # define SRADI_(a,s,h) FXS_(31,s,a,h&~32,413,h>>5)
445 # define SRAD(a,s,b) FX(31,s,a,b,794)
446 # define SRAD_(a,s,b) FX_(31,s,a,b,794)
448 # define STB(s,a,d) FDs(38,s,a,d)
449 # define STBU(s,a,d) FDs(39,s,a,d)
450 # define STBUX(s,a,b) FX(31,s,a,b,247)
451 # define STBX(s,a,b) FX(31,s,a,b,215)
452 # define STH(s,a,d) FDs(44,s,a,d)
453 # define STHBRX(s,a,b) FX(31,s,a,b,918)
454 # define STHU(s,a,d) FDs(45,s,a,d)
455 # define STHUX(s,a,b) FX(31,s,a,b,439)
456 # define STHX(s,a,b) FX(31,s,a,b,407)
457 # define STMW(s,a,d) FDs(47,s,a,d)
458 # define STWSI(s,a,nb) FX(31,s,a,nb,725)
459 # define STSWX(s,a,b) FX(31,s,a,b,661)
460 # define STW(s,a,d) FDs(36,s,a,d)
461 # define STWBRX(s,a,b) FX(31,s,a,b,662)
462 # define STWCX_(s,a,b) FX_(31,s,a,b,150)
463 # define STDCX_(s,a,b) FX_(31,s,a,b,214)
464 # define STWU(s,a,d) FDs(37,s,a,d)
465 # define STWUX(s,a,b) FX(31,s,a,b,183)
466 # define STWX(s,a,b) FX(31,s,a,b,151)
467 # define STD(s,a,d) FDs(62,s,a,d)
468 # define STDX(s,a,b) FX(31,s,a,b,149)
469 # define STDU(s,a,d) FDs(62,s,a,d|1)
470 # define STDUX(s,a,b) FX(31,s,a,b,181)
471 # define SUBF(d,a,b) FXO(31,d,a,b,0,40)
472 # define SUBF_(d,a,b) FXO_(31,d,a,b,0,40)
473 # define SUBFO(d,a,b) FXO(31,d,a,b,1,40)
474 # define SUBFO_(d,a,b) FXO_(31,d,a,b,1,40)
475 # define SUB(d,a,b) SUBF(d,b,a)
476 # define SUB_(d,a,b) SUBF_(d,b,a)
477 # define SUBO(d,a,b) SUBFO(d,b,a)
478 # define SUBO_(d,a,b) SUBFO_(d,b,a)
479 # define SUBI(d,a,s) ADDI(d,a,-s)
480 # define SUBIS(d,a,s) ADDIS(d,a,-s)
481 # define SUBFC(d,a,b) FXO(31,d,a,b,0,8)
482 # define SUBFC_(d,a,b) FXO_(31,d,a,b,0,8)
483 # define SUBFCO(d,a,b) FXO(31,d,a,b,1,8)
484 # define SUBFCO_(d,a,b) FXO_(31,d,a,b,1,8)
485 # define SUBC(d,a,b) SUBFC(d,b,a)
486 # define SUBIC(d,a,s) ADDIC(d,a,-s)
487 # define SUBIC_(d,a,s) ADDIC_(d,a,-s)
488 # define SUBFE(d,a,b) FXO(31,d,a,b,0,136)
489 # define SUBFE_(d,a,b) FXO_(31,d,a,b,0,136)
490 # define SUBFEO(d,a,b) FXO(31,d,a,b,1,136)
491 # define SUBFEO_(d,a,b) FXO_(31,d,a,b,1,136)
492 # define SUBE(d,a,b) SUBFE(d,b,a)
493 # define SUBFIC(d,a,s) FDs(8,d,a,s)
494 # define SUBFME(d,a) FXO(31,d,a,0,0,232)
495 # define SUBFME_(d,a) FXO_(31,d,a,0,0,232)
496 # define SUBFMEO(d,a) FXO(31,d,a,0,1,232)
497 # define SUBFMEO_(d,a) FXO_(31,d,a,0,1,232)
498 # define SUBFZE(d,a) FXO(31,d,a,0,0,200)
499 # define SUBFZE_(d,a) FXO_(31,d,a,0,0,200)
500 # define SUBFZEO(d,a) FXO(31,d,a,0,1,200)
501 # define SUBFZEO_(d,a) FXO_(31,d,a,0,1,200)
502 # define SYNC() FX(31,0,0,0,598)
503 # define TLBIA() FX(31,0,0,0,370)
504 # define TLBIE(b) FX(31,0,0,b,306)
505 # define TLBSYNC() FX(31,0,0,0,566)
506 # define TW(t,a,b) FX(31,t,a,b,4)
507 # define TWEQ(a,b) FX(31,4,a,b,4)
508 # define TWLGE(a,b) FX(31,5,a,b,4)
509 # define TRAP() FX(31,31,0,0,4)
510 # define TWI(t,a,s) FDs(3,t,a,s)
511 # define TWGTI(a,s) TWI(8,a,s)
512 # define TWLLEI(a,s) TWI(6,a,s)
513 # define XOR(d,a,b) FX(31,a,d,b,316)
514 # define XOR_(d,a,b) FX_(31,a,d,b,316)
515 # define XORI(s,a,u) FDu(26,a,s,u)
516 # define XORIS(s,a,u) FDu(27,a,s,u)
517 # define nop(c) _nop(_jit,c)
518 static void _nop(jit_state_t*,jit_int32_t);
519 # define movr(r0,r1) _movr(_jit,r0,r1)
520 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
521 # define movi(r0,i0) _movi(_jit,r0,i0)
522 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
523 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
524 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
525 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
526 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
527 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
528 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
529 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
530 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
531 jit_int32_t,jit_int32_t,jit_word_t);
532 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
533 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
534 # define negr(r0,r1) NEG(r0,r1)
535 # define comr(r0,r1) NOT(r0,r1)
536 # define bitswap(r0, r1) _bitswap(_jit, r0, r1)
537 static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t);
538 # define clor(r0, r1) _clor(_jit, r0, r1)
539 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
540 # if __WORDSIZE == 32
541 # define clzr(r0, r1) CNTLZW(r0, r1)
543 # define clzr(r0, r1) CNTLZD(r0, r1)
545 # define ctor(r0, r1) _ctor(_jit, r0, r1)
546 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
547 # define ctzr(r0, r1) _ctzr(_jit, r0, r1)
548 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
549 # define extr_c(r0,r1) EXTSB(r0,r1)
550 # define extr_uc(r0,r1) ANDI_(r0,r1,0xff)
551 # define extr_s(r0,r1) EXTSH(r0,r1)
552 # define extr_us(r0,r1) ANDI_(r0,r1,0xffff)
553 # if __WORDSIZE == 64
554 # define extr_i(r0,r1) EXTSW(r0,r1)
555 # define extr_ui(r0,r1) CLRLDI(r0,r1,32)
557 # define bswapr_us_lh(r0,r1,no_flag) _bswapr_us(_jit,r0,r1,no_flag)
558 # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1,0)
559 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
560 # define bswapr_ui_lw(r0,r1,no_flag) _bswapr_ui(_jit,r0,r1,no_flag)
561 # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1,0)
562 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
563 # if __WORDSIZE == 64
564 # define bswapr_ul(r0,r1) generic_bswapr_ul(_jit,r0,r1)
566 # define addr(r0,r1,r2) ADD(r0,r1,r2)
567 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
568 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
569 # define addcr(r0,r1,r2) ADDC(r0,r1,r2)
570 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
571 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
572 # define addxr(r0,r1,r2) ADDE(r0,r1,r2)
573 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
574 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
575 # define subr(r0,r1,r2) SUB(r0,r1,r2)
576 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
577 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
578 # define subcr(r0,r1,r2) SUBC(r0,r1,r2)
579 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
580 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
581 # define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
582 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
583 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
584 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
585 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
586 # if __WORDSIZE == 32
587 # define mulr(r0,r1,r2) MULLW(r0,r1,r2)
588 # define mullr(r0,r1,r2) MULLW(r0,r1,r2)
589 # define mulhr(r0,r1,r2) MULHW(r0,r1,r2)
590 # define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2)
592 # define mulr(r0,r1,r2) MULLD(r0,r1,r2)
593 # define mullr(r0,r1,r2) MULLD(r0,r1,r2)
594 # define mulhr(r0,r1,r2) MULHD(r0,r1,r2)
595 # define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2)
597 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
598 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
599 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
600 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
601 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
602 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
603 jit_int32_t,jit_int32_t,jit_bool_t);
604 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
605 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
606 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
607 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
608 jit_int32_t,jit_word_t,jit_bool_t);
609 # if __WORDSIZE == 32
610 # define divr(r0,r1,r2) DIVW(r0,r1,r2)
612 # define divr(r0,r1,r2) DIVD(r0,r1,r2)
614 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
615 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
616 # if __WORDSIZE == 32
617 # define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
619 # define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
621 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
622 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
623 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
624 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
625 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
626 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
627 jit_int32_t,jit_int32_t,jit_bool_t);
628 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
629 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
630 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
631 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
632 jit_int32_t,jit_word_t,jit_bool_t);
633 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
634 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
635 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
636 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
637 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
638 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
639 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
640 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
641 # define andr(r0,r1,r2) AND(r0,r1,r2)
642 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
643 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
644 # define orr(r0,r1,r2) OR(r0,r1,r2)
645 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
646 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
647 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
648 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
649 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
650 # if __WORDSIZE == 32
651 # define lshr(r0,r1,r2) SLW(r0,r1,r2)
653 # define lshr(r0,r1,r2) SLD(r0,r1,r2)
655 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
656 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
657 # if __WORDSIZE == 32
658 # define rshr(r0,r1,r2) SRAW(r0,r1,r2)
660 # define rshr(r0,r1,r2) SRAD(r0,r1,r2)
662 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
663 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
664 # if __WORDSIZE == 32
665 # define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
667 # define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
669 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
670 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
671 # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
672 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
673 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
674 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
675 # define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
676 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
677 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
678 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
679 # define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
680 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
681 # define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
682 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
683 # define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
684 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
685 # define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
686 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
687 # define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
688 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
689 # define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
690 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
691 # define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
692 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
693 # define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
694 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
695 # define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
696 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
697 # define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
698 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
699 # define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
700 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
701 # define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
702 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
703 # define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
704 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
705 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
706 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
707 # define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
708 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
709 # define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
710 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
711 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
712 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
713 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
714 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
715 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
716 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
717 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
718 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
719 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
720 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
721 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
722 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
723 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
724 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
725 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
726 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
727 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
728 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
729 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
730 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
731 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
732 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
733 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
734 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
735 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
736 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
737 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
738 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
739 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
740 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
741 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
742 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
743 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
744 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
745 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
746 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
747 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
748 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
749 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
750 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
751 #define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
752 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
753 #define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
754 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
755 #define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
756 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
757 #define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
758 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
759 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
760 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
761 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
762 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
763 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
764 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
765 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
766 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
767 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
768 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
769 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
770 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
771 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
772 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
773 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
774 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
775 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
776 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
777 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
778 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
779 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
780 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
781 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
782 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
783 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
784 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
785 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
786 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
787 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
788 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
789 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
790 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
791 # define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
792 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
793 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
794 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
795 # define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
796 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
797 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
798 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
799 # define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
800 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
801 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
802 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
803 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
804 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
805 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
806 # define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
807 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
808 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
809 # define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
810 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
811 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
812 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
813 # define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
814 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
815 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
816 # define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
817 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
818 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
819 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
820 # if __WORDSIZE == 32
821 # define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
823 # define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
825 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
826 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
827 # define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
828 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
829 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
830 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
831 # if __WORDSIZE == 64
832 # define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
833 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
834 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
835 # define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
836 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
837 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
838 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
839 # define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
840 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
841 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
842 # define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
843 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
844 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
845 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
847 # define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
848 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
849 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
850 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
851 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
852 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
853 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
854 # define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
855 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
856 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
857 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
858 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
859 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
860 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
861 # define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
862 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
863 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
864 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
865 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
866 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
867 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
868 # if __WORDSIZE == 64
869 # define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
870 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
871 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
872 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
873 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
874 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
875 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
877 # define jmpr(r0) _jmpr(_jit,r0)
878 static void _jmpr(jit_state_t*,jit_int32_t);
879 # define jmpi(i0) _jmpi(_jit,i0)
880 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
881 # define jmpi_p(i0) _jmpi_p(_jit,i0)
882 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
884 # define callr(r0,i0) _callr(_jit,r0,i0)
885 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
886 # define calli(i0,i1) _calli(_jit,i0,i1)
887 static jit_word_t _calli(jit_state_t*,jit_word_t,jit_int32_t);
888 # define calli_p(i0,i1) _calli_p(_jit,i0,i1)
889 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
891 # define callr(r0) _callr(_jit,r0)
892 static void _callr(jit_state_t*,jit_int32_t);
893 # define calli(i0) _calli(_jit,i0)
894 static jit_word_t _calli(jit_state_t*,jit_word_t);
895 # define calli_p(i0) _calli_p(_jit,i0)
896 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
898 # define prolog(node) _prolog(_jit, node)
899 static void _prolog(jit_state_t*, jit_node_t*);
900 # define epilog(node) _epilog(_jit, node)
901 static void _epilog(jit_state_t*, jit_node_t*);
902 # define vastart(r0) _vastart(_jit, r0)
903 static void _vastart(jit_state_t*, jit_int32_t);
904 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
905 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
906 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
907 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
908 # define patch_at(i,l) _patch_at(_jit,i,l)
909 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
913 # define _u16(v) ((v) & 0xffff)
914 # define _u26(v) ((v) & 0x3ffffff)
916 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
918 assert(!(o & ~((1 << 6) - 1)));
919 assert(!(d & ~((1 << 5) - 1)));
920 assert(!(a & ~((1 << 5) - 1)));
921 assert(!(b & ~((1 << 5) - 1)));
922 assert(!(e & ~((1 << 1) - 1)));
923 assert(!(x & ~((1 << 9) - 1)));
924 assert(!(r & ~((1 << 1) - 1)));
925 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
929 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
931 assert(!(o & ~((1 << 6) - 1)));
932 assert(!(d & ~((1 << 5) - 1)));
933 assert(!(a & ~((1 << 5) - 1)));
934 assert(can_sign_extend_short_p(s));
935 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
939 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
941 assert(!(o & ~((1 << 6) - 1)));
942 assert(!(d & ~((1 << 5) - 1)));
943 assert(!(a & ~((1 << 5) - 1)));
944 assert(can_zero_extend_short_p(s));
945 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
949 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
951 assert(!(o & ~((1 << 6) - 1)));
952 assert(!(s & ~((1 << 5) - 1)));
953 assert(!(a & ~((1 << 5) - 1)));
954 assert(!(b & ~((1 << 5) - 1)));
955 assert(!(x & ~((1 << 10) - 1)));
956 assert(!(r & ~((1 << 1) - 1)));
957 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
961 _FI(jit_state_t *_jit, int o, int t, int a, int k)
963 assert(!(o & ~(( 1 << 6) - 1)));
964 assert(!(t & 3) && can_sign_extend_jump_p(t));
965 assert(!(a & ~(( 1 << 1) - 1)));
966 assert(!(k & ~(( 1 << 1) - 1)));
967 ii((o<<26)|_u26(t)|(a<<1)|k);
971 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
973 assert(!( o & ~((1 << 6) - 1)));
974 assert(!(bo & ~((1 << 5) - 1)));
975 assert(!(bi & ~((1 << 5) - 1)));
976 assert(!(t & 3) && can_sign_extend_short_p(t));
977 assert(!(a & ~(( 1 << 1) - 1)));
978 assert(!(k & ~(( 1 << 1) - 1)));
979 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
983 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
985 assert(!( o & ~((1 << 6) - 1)));
986 assert(!(bo & ~((1 << 5) - 1)));
987 assert(!(bi & ~((1 << 5) - 1)));
988 assert(!(x & ~(( 1 << 10) - 1)));
989 assert(!(k & ~(( 1 << 1) - 1)));
990 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
994 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
996 assert(!(o & ~((1 << 6) - 1)));
997 assert(!(d & ~((1 << 3) - 1)));
998 assert(!(l & ~((1 << 1) - 1)));
999 assert(!(a & ~((1 << 5) - 1)));
1000 assert(!(b & ~((1 << 5) - 1)));
1001 assert(!(x & ~((1 << 10) - 1)));
1002 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
1006 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
1008 assert(!(o & ~((1 << 6) - 1)));
1009 assert(!(d & ~((1 << 3) - 1)));
1010 assert(!(l & ~((1 << 1) - 1)));
1011 assert(!(a & ~((1 << 5) - 1)));
1012 if (o == 11) assert(can_sign_extend_short_p(s));
1013 else if (o == 10) assert(can_zero_extend_short_p(s));
1017 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
1021 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
1023 assert(!(o & ~((1 << 6) - 1)));
1024 assert(!(d & ~((1 << 5) - 1)));
1025 assert(!(x & ~((1 << 10) - 1)));
1026 assert(!(f & ~((1 << 10) - 1)));
1027 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1031 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, 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(!(b & ~((1 << 5) - 1)));
1038 assert(!(e & ~((1 << 5) - 1)));
1039 assert(!(r & ~((1 << 1) - 1)));
1040 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1043 # if __WORDSIZE == 64
1045 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1047 assert(!(o & ~((1 << 6) - 1)));
1048 assert(!(s & ~((1 << 5) - 1)));
1049 assert(!(a & ~((1 << 5) - 1)));
1050 assert(!(b & ~((1 << 5) - 1)));
1051 assert(!(e & ~((1 << 6) - 1)));
1052 assert(!(x & ~((1 << 4) - 1)));
1053 assert(!(r & ~((1 << 1) - 1)));
1054 e = (e >> 5) | ((e << 1) & 63);
1055 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1059 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1061 assert(!(o & ~((1 << 6) - 1)));
1062 assert(!(s & ~((1 << 5) - 1)));
1063 assert(!(a & ~((1 << 5) - 1)));
1064 assert(!(h & ~((1 << 5) - 1)));
1065 assert(!(e & ~((1 << 6) - 1)));
1066 assert(!(x & ~((1 << 3) - 1)));
1067 assert(!(i & ~((1 << 1) - 1)));
1068 assert(!(r & ~((1 << 1) - 1)));
1069 e = (e >> 5) | ((e << 1) & 63);
1070 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1074 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1076 assert(!(o & ~((1 << 6) - 1)));
1077 assert(!(s & ~((1 << 5) - 1)));
1078 assert(!(a & ~((1 << 5) - 1)));
1079 assert(!(h & ~((1 << 5) - 1)));
1080 assert(!(x & ~((1 << 9) - 1)));
1081 assert(!(i & ~((1 << 1) - 1)));
1082 assert(!(r & ~((1 << 1) - 1)));
1083 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1089 * Use the sequence commented at
1090 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1093 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1096 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1098 MTCRF(128, rn(reg));
1099 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1106 _nop(jit_state_t *_jit, jit_int32_t i0)
1108 for (; i0 > 0; i0 -= 4)
1114 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1121 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1123 if (can_sign_extend_short_p(i0))
1126 if (can_sign_extend_int_p(i0))
1127 LIS(r0, (jit_int16_t)(i0 >> 16));
1128 else if (can_zero_extend_int_p(i0)) {
1129 if (i0 & 0xffff0000) {
1130 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1134 # if __WORDSIZE == 64
1136 movi(r0, (jit_uint32_t)(i0 >> 32));
1137 if (i0 & 0xffff0000) {
1139 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1147 ORI(r0, r0, (jit_uint16_t)i0);
1152 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1160 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1168 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1170 jit_word_t word = _jit->pc.w;
1171 # if __WORDSIZE == 32
1172 LIS(r0, (jit_int16_t)(i0 >> 16));
1173 ORI(r0, r0, (jit_uint16_t)i0);
1175 LIS(r0, (jit_int16_t)(i0 >> 48));
1176 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1178 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1180 ORI(r0, r0, (jit_uint16_t)i0);
1186 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1187 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1189 jit_int32_t r1_reg, iscasi;
1190 jit_word_t retry, done, jump0, jump1;
1191 if ((iscasi = (r1 == _NOREG))) {
1192 r1_reg = jit_get_reg(jit_class_gpr);
1199 # if __WORDSIZE == 32
1200 LWARX(r0, _R0_REGNO, r1);
1202 LDARX(r0, _R0_REGNO, r1);
1204 jump0 = bner(_jit->pc.w, r0, r2); /* bne done r0 r2 */
1205 # if __WORDSIZE == 32
1206 STWCX_(r3, _R0_REGNO, r1);
1208 STDCX_(r3, _R0_REGNO, r1);
1211 BNE(0); /* BNE retry */
1216 EXTRWI(r0, r0, 1, CR_EQ);
1217 patch_at(jump0, done);
1218 patch_at(jump1, retry);
1220 jit_unget_reg(r1_reg);
1223 /* http://graphics.stanford.edu/~seander/bithacks.html#ReverseParallel */
1225 unsigned int v; // 32-bit word to reverse bit order
1227 // swap odd and even bits
1228 v = ((v >> 1) & 0x55555555) | ((v & 0x55555555) << 1);
1229 // swap consecutive pairs
1230 v = ((v >> 2) & 0x33333333) | ((v & 0x33333333) << 2);
1232 v = ((v >> 4) & 0x0F0F0F0F) | ((v & 0x0F0F0F0F) << 4);
1234 v = ((v >> 8) & 0x00FF00FF) | ((v & 0x00FF00FF) << 8);
1235 // swap 2-byte long pairs
1236 v = ( v >> 16 ) | ( v << 16);
1239 _bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1241 jit_int32_t t0, t1, t2, t3, t4;
1243 t0 = jit_get_reg(jit_class_gpr);
1244 t1 = jit_get_reg(jit_class_gpr);
1245 t2 = jit_get_reg(jit_class_gpr);
1246 movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L);
1247 rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */
1248 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1249 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1250 lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */
1251 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1252 movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L);
1253 rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */
1254 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1255 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1256 lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */
1257 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1258 movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL);
1259 rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */
1260 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1261 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1262 lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */
1263 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1264 movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL);
1265 rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */
1266 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1267 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1268 lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */
1269 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1270 # if __WORDSIZE == 32
1271 rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */
1272 lshi(rn(t2), r0, 16); /* t2 = v << 16 */
1273 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1275 movi(rn(t0), 0x0000ffff0000ffffL);
1276 rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */
1277 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1278 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1279 lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */
1280 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1281 rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */
1282 lshi(rn(t2), r0, 32); /* t2 = v << 32 */
1283 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1291 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1298 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1305 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1312 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1314 jit_int32_t reg, addr_reg;
1316 /* Convert load followed by bswap to a single instruction */
1317 /* FIXME r0 and r1 do not need to be the same, only must check if
1318 * r1 was loaded in previous instruction */
1319 if (no_flag && r0 == r1) {
1320 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00022e | r0 << 21)) {
1321 /* Convert LHZX to LHBRX */
1323 LHBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1327 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0xa0000000 | r0 << 21)) {
1328 /* Convert LHZ to LHBRX */
1330 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1332 reg = jit_get_reg(jit_class_gpr);
1333 LI(rn(reg), (short)*_jit->pc.ui);
1334 LHBRX(r0, rn(reg), addr_reg);
1341 RLWIMI(r0, r0, 16, 8, 15);
1342 RLWINM(r0, r0, 24, 16, 31);
1344 RLWINM(r0, r1, 8, 16, 23);
1345 RLWIMI(r0, r1, 24, 24, 31);
1350 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1352 jit_int32_t reg, addr_reg;
1354 /* Convert load followed by bswap to a single instruction */
1355 /* FIXME r0 and r1 do not need to be the same, only must check if
1356 * r1 was loaded in previous instruction */
1357 if (no_flag && r0 == r1) {
1358 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00002e | r0 << 21)) {
1359 /* Convert LWZX to LWBRX */
1361 LWBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1365 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0x80000000 | r0 << 21)) {
1366 /* Convert LWZ to LWBRX */
1368 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1370 reg = jit_get_reg(jit_class_gpr);
1371 LI(rn(reg), (short)*_jit->pc.ui);
1372 LWBRX(r0, rn(reg), addr_reg);
1378 reg = jit_get_reg(jit_class_gpr);
1379 ROTLWI(rn(reg), r1, 8);
1380 RLWIMI(rn(reg), r1, 24, 0, 7);
1381 RLWIMI(rn(reg), r1, 24, 16, 23);
1382 # if __WORDSIZE == 64
1383 CLRLDI(r0, rn(reg), 32);
1391 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1394 if (can_sign_extend_short_p(i0))
1396 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1397 ADDIS(r0, r1, i0 >> 16);
1399 reg = jit_get_reg(jit_class_gpr);
1401 ADD(r0, r1, rn(reg));
1407 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1410 if (can_sign_extend_short_p(i0))
1413 reg = jit_get_reg(jit_class_gpr);
1415 ADDC(r0, r1, rn(reg));
1421 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1424 reg = jit_get_reg(jit_class_gpr);
1426 ADDE(r0, r1, rn(reg));
1431 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1434 jit_word_t ni0 = -i0;
1435 if (can_sign_extend_short_p(ni0))
1437 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1438 ADDIS(r0, r1, ni0 >> 16);
1440 reg = jit_get_reg(jit_class_gpr);
1442 SUB(r0, r1, rn(reg));
1448 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1451 reg = jit_get_reg(jit_class_gpr);
1453 SUBC(r0, r1, rn(reg));
1458 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1461 reg = jit_get_reg(jit_class_gpr);
1463 SUBE(r0, r1, rn(reg));
1468 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1475 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1478 if (can_sign_extend_short_p(i0))
1481 reg = jit_get_reg(jit_class_gpr);
1483 mulr(r0, r1, rn(reg));
1489 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1490 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1493 if (r0 == r2 || r0 == r3) {
1494 reg = jit_get_reg(jit_class_gpr);
1495 mullr(rn(reg), r2, r3);
1502 mulhr_u(r1, r2, r3);
1503 if (r0 == r2 || r0 == r3) {
1510 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1511 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1514 reg = jit_get_reg(jit_class_gpr);
1516 iqmulr(r0, r1, r2, rn(reg), sign);
1521 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1524 reg = jit_get_reg(jit_class_gpr);
1526 divr(r0, r1, rn(reg));
1531 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1534 reg = jit_get_reg(jit_class_gpr);
1536 divr_u(r0, r1, rn(reg));
1541 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1542 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1544 jit_int32_t sv0, rg0;
1545 jit_int32_t sv1, rg1;
1547 if (r0 == r2 || r0 == r3) {
1548 sv0 = jit_get_reg(jit_class_gpr);
1553 if (r1 == r2 || r1 == r3) {
1554 sv1 = jit_get_reg(jit_class_gpr);
1563 divr_u(rg0, r2, r3);
1577 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1578 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1581 reg = jit_get_reg(jit_class_gpr);
1583 iqdivr(r0, r1, r2, rn(reg), sign);
1588 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1591 if (r0 == r1 || r0 == r2) {
1592 reg = jit_get_reg(jit_class_gpr);
1593 divr(rn(reg), r1, r2);
1594 mulr(rn(reg), r2, rn(reg));
1595 subr(r0, r1, rn(reg));
1606 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1609 reg = jit_get_reg(jit_class_gpr);
1611 remr(r0, r1, rn(reg));
1616 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1619 if (r0 == r1 || r0 == r2) {
1620 reg = jit_get_reg(jit_class_gpr);
1621 divr_u(rn(reg), r1, r2);
1622 mulr(rn(reg), r2, rn(reg));
1623 subr(r0, r1, rn(reg));
1634 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1637 reg = jit_get_reg(jit_class_gpr);
1639 remr_u(r0, r1, rn(reg));
1643 # define is_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
1646 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1648 jit_int32_t reg, offt;
1649 if (can_zero_extend_short_p(i0))
1651 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1652 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1653 else if (__WORDSIZE == 32 && is_mask(i0)) {
1654 offt = __builtin_ctzl(i0);
1655 RLWINM(r0, r1, 0, 32 - offt - __builtin_popcountl(i0), 31 - offt);
1656 } else if (__WORDSIZE == 32 && is_mask(~i0)) {
1657 offt = __builtin_ctzl(~i0);
1658 RLWINM(r0, r1, 0, 32 - offt, 31 - offt - __builtin_popcountl(~i0));
1660 reg = jit_get_reg(jit_class_gpr);
1662 AND(r0, r1, rn(reg));
1668 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1671 if (can_zero_extend_short_p(i0))
1673 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1674 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1676 reg = jit_get_reg(jit_class_gpr);
1678 OR(r0, r1, rn(reg));
1684 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1687 if (can_zero_extend_short_p(i0))
1689 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1690 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1692 reg = jit_get_reg(jit_class_gpr);
1694 XOR(r0, r1, rn(reg));
1700 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1705 # if __WORDSIZE == 32
1714 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1719 # if __WORDSIZE == 32
1728 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1733 # if __WORDSIZE == 32
1742 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1746 EXTRWI(r0, r0, 1, CR_LT);
1750 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1753 if (can_sign_extend_short_p(i0))
1756 reg = jit_get_reg(jit_class_gpr);
1762 EXTRWI(r0, r0, 1, CR_LT);
1766 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1770 EXTRWI(r0, r0, 1, CR_LT);
1774 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1777 if (can_zero_extend_short_p(i0))
1780 reg = jit_get_reg(jit_class_gpr);
1786 EXTRWI(r0, r0, 1, CR_LT);
1790 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1793 CRNOT(CR_GT, CR_GT);
1795 EXTRWI(r0, r0, 1, CR_GT);
1799 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1802 if (can_sign_extend_short_p(i0))
1805 reg = jit_get_reg(jit_class_gpr);
1810 CRNOT(CR_GT, CR_GT);
1812 EXTRWI(r0, r0, 1, CR_GT);
1816 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1819 CRNOT(CR_GT, CR_GT);
1821 EXTRWI(r0, r0, 1, CR_GT);
1825 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1828 if (can_zero_extend_short_p(i0))
1831 reg = jit_get_reg(jit_class_gpr);
1836 CRNOT(CR_GT, CR_GT);
1838 EXTRWI(r0, r0, 1, CR_GT);
1842 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1846 EXTRWI(r0, r0, 1, CR_EQ);
1850 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1853 if (can_sign_extend_short_p(i0))
1855 else if (can_zero_extend_short_p(i0))
1858 reg = jit_get_reg(jit_class_gpr);
1864 EXTRWI(r0, r0, 1, CR_EQ);
1868 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1871 CRNOT(CR_LT, CR_LT);
1873 EXTRWI(r0, r0, 1, CR_LT);
1877 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1880 if (can_sign_extend_short_p(i0))
1883 reg = jit_get_reg(jit_class_gpr);
1888 CRNOT(CR_LT, CR_LT);
1890 EXTRWI(r0, r0, 1, CR_LT);
1894 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1897 CRNOT(CR_LT, CR_LT);
1899 EXTRWI(r0, r0, 1, CR_LT);
1903 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1906 if (can_zero_extend_short_p(i0))
1909 reg = jit_get_reg(jit_class_gpr);
1914 CRNOT(CR_LT, CR_LT);
1916 EXTRWI(r0, r0, 1, CR_LT);
1920 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1924 EXTRWI(r0, r0, 1, CR_GT);
1928 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1931 if (can_sign_extend_short_p(i0))
1934 reg = jit_get_reg(jit_class_gpr);
1940 EXTRWI(r0, r0, 1, CR_GT);
1944 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1948 EXTRWI(r0, r0, 1, CR_GT);
1952 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1955 if (can_zero_extend_short_p(i0))
1958 reg = jit_get_reg(jit_class_gpr);
1964 EXTRWI(r0, r0, 1, CR_GT);
1968 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1971 CRNOT(CR_EQ, CR_EQ);
1973 EXTRWI(r0, r0, 1, CR_EQ);
1977 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1980 if (can_sign_extend_short_p(i0))
1982 else if (can_zero_extend_short_p(i0))
1985 reg = jit_get_reg(jit_class_gpr);
1990 CRNOT(CR_EQ, CR_EQ);
1992 EXTRWI(r0, r0, 1, CR_EQ);
1996 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2007 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2011 if (can_sign_extend_short_p(i1))
2014 reg = jit_get_reg(jit_class_gpr);
2026 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2037 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2041 if (can_zero_extend_short_p(i1))
2044 reg = jit_get_reg(jit_class_gpr);
2056 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2067 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2071 if (can_sign_extend_short_p(i1))
2074 reg = jit_get_reg(jit_class_gpr);
2086 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2097 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2101 if (can_zero_extend_short_p(i1))
2104 reg = jit_get_reg(jit_class_gpr);
2116 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2127 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2131 if (can_sign_extend_short_p(i1))
2133 else if (can_zero_extend_short_p(i1))
2136 reg = jit_get_reg(jit_class_gpr);
2148 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2159 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2163 if (can_sign_extend_short_p(i1))
2166 reg = jit_get_reg(jit_class_gpr);
2178 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2189 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2193 if (can_zero_extend_short_p(i1))
2196 reg = jit_get_reg(jit_class_gpr);
2208 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2219 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2223 if (can_sign_extend_short_p(i1))
2226 reg = jit_get_reg(jit_class_gpr);
2238 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2249 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2253 if (can_zero_extend_short_p(i1))
2256 reg = jit_get_reg(jit_class_gpr);
2268 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2279 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2283 if (can_sign_extend_short_p(i1))
2285 else if (can_zero_extend_short_p(i1))
2288 reg = jit_get_reg(jit_class_gpr);
2300 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2304 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2305 andr(rn(reg), r0, r1);
2306 w = bnei(i0, rn(reg), 0);
2312 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2316 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2317 andi(rn(reg), r0, i1);
2318 w = bnei(i0, rn(reg), 0);
2324 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2328 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2329 andr(rn(reg), r0, r1);
2330 w = beqi(i0, rn(reg), 0);
2336 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2340 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2341 andi(rn(reg), r0, i1);
2342 w = beqi(i0, rn(reg), 0);
2348 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2355 BGT(d); /* GT = bit 1 of XER = OV */
2360 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2364 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2366 w = boaddr(i0, r0, rn(reg));
2372 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2384 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2388 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2390 w = bxaddr(i0, r0, rn(reg));
2396 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2408 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2412 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2414 w = bosubr(i0, r0, rn(reg));
2420 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2432 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2436 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2438 w = bxsubr(i0, r0, rn(reg));
2444 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2451 BEQ(d); /* EQ = bit 2 of XER = CA */
2456 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2460 if (can_sign_extend_short_p(i1)) {
2468 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2470 w = boaddr_u(i0, r0, rn(reg));
2476 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2488 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2492 if (can_sign_extend_short_p(i1)) {
2500 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2502 w = bxaddr_u(i0, r0, rn(reg));
2508 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2515 BNE(d); /* PPC uses "carry" not "borrow" */
2520 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2524 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2526 w = bosubr_u(i0, r0, rn(reg));
2532 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2544 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2548 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2550 w = bxsubr_u(i0, r0, rn(reg));
2556 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2563 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2570 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2572 ldxr_uc(r0, r1, r2);
2577 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2579 ldxi_uc(r0, r1, i0);
2584 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2589 if (can_sign_extend_short_p(i0))
2590 LBZ(r0, _R0_REGNO, i0);
2591 else if (can_sign_extend_int_p(i0)) {
2592 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2593 lo = (jit_int16_t)(i0 - (hi << 16));
2594 reg = jit_get_reg(jit_class_gpr);
2595 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2597 LBZ(r0, rn(reg), lo);
2599 if (inv) jit_unget_reg(_R0);
2602 reg = jit_get_reg(jit_class_gpr);
2604 ldr_uc(r0, rn(reg));
2610 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2613 if (r1 == _R0_REGNO) {
2614 if (r2 != _R0_REGNO)
2617 reg = jit_get_reg(jit_class_gpr);
2619 LBZX(r0, rn(reg), r2);
2628 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2633 else if (can_sign_extend_short_p(i0)) {
2634 if (r1 == _R0_REGNO) {
2635 reg = jit_get_reg(jit_class_gpr);
2637 LBZ(r0, rn(reg), i0);
2644 reg = jit_get_reg(jit_class_gpr);
2646 ldxr_uc(r0, r1, rn(reg));
2652 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2657 if (can_sign_extend_short_p(i0))
2658 LHA(r0, _R0_REGNO, i0);
2659 else if (can_sign_extend_int_p(i0)) {
2660 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2661 lo = (jit_int16_t)(i0 - (hi << 16));
2662 reg = jit_get_reg(jit_class_gpr);
2663 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2665 LHA(r0, rn(reg), lo);
2667 if (inv) jit_unget_reg(_R0);
2670 reg = jit_get_reg(jit_class_gpr);
2678 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2681 if (r1 == _R0_REGNO) {
2682 if (r2 != _R0_REGNO)
2685 reg = jit_get_reg(jit_class_gpr);
2687 LHAX(r0, rn(reg), r2);
2696 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2701 else if (can_sign_extend_short_p(i0)) {
2702 if (r1 == _R0_REGNO) {
2703 reg = jit_get_reg(jit_class_gpr);
2705 LHA(r0, rn(reg), i0);
2712 reg = jit_get_reg(jit_class_gpr);
2714 ldxr_s(r0, r1, rn(reg));
2720 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2725 if (can_sign_extend_short_p(i0))
2726 LHZ(r0, _R0_REGNO, i0);
2727 else if (can_sign_extend_int_p(i0)) {
2728 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2729 lo = (jit_int16_t)(i0 - (hi << 16));
2730 reg = jit_get_reg(jit_class_gpr);
2731 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2733 LHZ(r0, rn(reg), lo);
2735 if (inv) jit_unget_reg(_R0);
2738 reg = jit_get_reg(jit_class_gpr);
2740 ldr_us(r0, rn(reg));
2746 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2749 if (r1 == _R0_REGNO) {
2750 if (r2 != _R0_REGNO)
2753 reg = jit_get_reg(jit_class_gpr);
2755 LHZX(r0, rn(reg), r2);
2764 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2769 else if (can_sign_extend_short_p(i0)) {
2770 if (r1 == _R0_REGNO) {
2771 reg = jit_get_reg(jit_class_gpr);
2773 LHZ(r0, rn(reg), i0);
2780 reg = jit_get_reg(jit_class_gpr);
2782 ldxr_us(r0, r1, rn(reg));
2787 # if __WORDSIZE == 32
2789 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2794 if (can_sign_extend_short_p(i0))
2795 LWZ(r0, _R0_REGNO, i0);
2796 else if (can_sign_extend_int_p(i0)) {
2797 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2798 lo = (jit_int16_t)(i0 - (hi << 16));
2799 reg = jit_get_reg(jit_class_gpr);
2800 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2802 LWZ(r0, rn(reg), lo);
2804 if (inv) jit_unget_reg(_R0);
2807 reg = jit_get_reg(jit_class_gpr);
2815 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2818 if (r1 == _R0_REGNO) {
2819 if (r2 != _R0_REGNO)
2822 reg = jit_get_reg(jit_class_gpr);
2824 LWZX(r0, rn(reg), r2);
2833 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2838 else if (can_sign_extend_short_p(i0)) {
2839 if (r1 == _R0_REGNO) {
2840 reg = jit_get_reg(jit_class_gpr);
2842 LWZ(r0, rn(reg), i0);
2849 reg = jit_get_reg(jit_class_gpr);
2851 ldxr_i(r0, r1, rn(reg));
2858 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2863 if (can_sign_extend_short_p(i0))
2864 LWA(r0, _R0_REGNO, i0);
2865 else if (can_sign_extend_int_p(i0)) {
2866 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2867 lo = (jit_int16_t)(i0 - (hi << 16));
2868 reg = jit_get_reg(jit_class_gpr);
2869 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2871 LWA(r0, rn(reg), lo);
2873 if (inv) jit_unget_reg(_R0);
2876 reg = jit_get_reg(jit_class_gpr);
2884 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2887 if (r1 == _R0_REGNO) {
2888 if (r2 != _R0_REGNO)
2891 reg = jit_get_reg(jit_class_gpr);
2893 LWAX(r0, rn(reg), r2);
2902 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2907 else if (can_sign_extend_short_p(i0)) {
2908 if (r1 == _R0_REGNO) {
2909 reg = jit_get_reg(jit_class_gpr);
2911 LWA(r0, rn(reg), i0);
2918 reg = jit_get_reg(jit_class_gpr);
2920 ldxr_i(r0, r1, rn(reg));
2926 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2931 if (can_sign_extend_short_p(i0))
2932 LWZ(r0, _R0_REGNO, i0);
2933 else if (can_sign_extend_int_p(i0)) {
2934 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2935 lo = (jit_int16_t)(i0 - (hi << 16));
2936 reg = jit_get_reg(jit_class_gpr);
2937 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2939 LWZ(r0, rn(reg), lo);
2941 if (inv) jit_unget_reg(_R0);
2944 reg = jit_get_reg(jit_class_gpr);
2946 ldr_ui(r0, rn(reg));
2952 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2955 if (r1 == _R0_REGNO) {
2956 if (r2 != _R0_REGNO)
2959 reg = jit_get_reg(jit_class_gpr);
2961 LWZX(r0, rn(reg), r2);
2970 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2975 else if (can_sign_extend_short_p(i0)) {
2976 if (r1 == _R0_REGNO) {
2977 reg = jit_get_reg(jit_class_gpr);
2979 LWZ(r0, rn(reg), i0);
2986 reg = jit_get_reg(jit_class_gpr);
2988 ldxr_ui(r0, r1, rn(reg));
2994 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2999 if (can_sign_extend_short_p(i0))
3000 LD(r0, _R0_REGNO, i0);
3001 else if (can_sign_extend_int_p(i0)) {
3002 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3003 lo = (jit_int16_t)(i0 - (hi << 16));
3004 reg = jit_get_reg(jit_class_gpr);
3005 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3007 LD(r0, rn(reg), lo);
3009 if (inv) jit_unget_reg(_R0);
3012 reg = jit_get_reg(jit_class_gpr);
3020 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3023 if (r1 == _R0_REGNO) {
3024 if (r2 != _R0_REGNO)
3027 reg = jit_get_reg(jit_class_gpr);
3029 LDX(r0, rn(reg), r2);
3038 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3043 else if (can_sign_extend_short_p(i0)) {
3044 if (r1 == _R0_REGNO) {
3045 reg = jit_get_reg(jit_class_gpr);
3047 LD(r0, rn(reg), i0);
3054 reg = jit_get_reg(jit_class_gpr);
3056 ldxr_l(r0, r1, rn(reg));
3063 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3068 if (can_sign_extend_short_p(i0))
3069 STB(r0, _R0_REGNO, i0);
3070 else if (can_sign_extend_int_p(i0)) {
3071 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3072 lo = (jit_int16_t)(i0 - (hi << 16));
3073 reg = jit_get_reg(jit_class_gpr);
3074 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3076 STB(r0, rn(reg), lo);
3078 if (inv) jit_unget_reg(_R0);
3081 reg = jit_get_reg(jit_class_gpr);
3089 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3092 if (r0 == _R0_REGNO) {
3093 if (r1 != _R0_REGNO)
3096 reg = jit_get_reg(jit_class_gpr);
3098 STBX(r2, rn(reg), r1);
3107 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3112 else if (can_sign_extend_short_p(i0)) {
3113 if (r0 == _R0_REGNO) {
3114 reg = jit_get_reg(jit_class_gpr);
3116 STB(r1, rn(reg), i0);
3123 reg = jit_get_reg(jit_class_gpr);
3125 stxr_c(rn(reg), r0, r1);
3131 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3136 if (can_sign_extend_short_p(i0))
3137 STH(r0, _R0_REGNO, i0);
3138 else if (can_sign_extend_int_p(i0)) {
3139 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3140 lo = (jit_int16_t)(i0 - (hi << 16));
3141 reg = jit_get_reg(jit_class_gpr);
3142 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3144 STH(r0, rn(reg), lo);
3146 if (inv) jit_unget_reg(_R0);
3149 reg = jit_get_reg(jit_class_gpr);
3157 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3160 if (r0 == _R0_REGNO) {
3161 if (r1 != _R0_REGNO)
3164 reg = jit_get_reg(jit_class_gpr);
3166 STHX(r2, rn(reg), r1);
3175 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3180 else if (can_sign_extend_short_p(i0)) {
3181 if (r0 == _R0_REGNO) {
3182 reg = jit_get_reg(jit_class_gpr);
3184 STH(r1, rn(reg), i0);
3191 reg = jit_get_reg(jit_class_gpr);
3193 stxr_s(rn(reg), r0, r1);
3199 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3204 if (can_sign_extend_short_p(i0))
3205 STW(r0, _R0_REGNO, i0);
3206 else if (can_sign_extend_int_p(i0)) {
3207 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3208 lo = (jit_int16_t)(i0 - (hi << 16));
3209 reg = jit_get_reg(jit_class_gpr);
3210 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3212 STW(r0, rn(reg), lo);
3214 if (inv) jit_unget_reg(_R0);
3217 reg = jit_get_reg(jit_class_gpr);
3225 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3228 if (r0 == _R0_REGNO) {
3229 if (r1 != _R0_REGNO)
3232 reg = jit_get_reg(jit_class_gpr);
3234 STWX(r2, rn(reg), r1);
3243 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3248 else if (can_sign_extend_short_p(i0)) {
3249 if (r0 == _R0_REGNO) {
3250 reg = jit_get_reg(jit_class_gpr);
3252 STW(r1, rn(reg), i0);
3259 reg = jit_get_reg(jit_class_gpr);
3261 stxr_i(rn(reg), r0, r1);
3266 # if __WORDSIZE == 64
3268 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3273 if (can_sign_extend_short_p(i0))
3274 STD(r0, _R0_REGNO, i0);
3275 else if (can_sign_extend_int_p(i0)) {
3276 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3277 lo = (jit_int16_t)(i0 - (hi << 16));
3278 reg = jit_get_reg(jit_class_gpr);
3279 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3281 STD(r0, rn(reg), lo);
3283 if (inv) jit_unget_reg(_R0);
3286 reg = jit_get_reg(jit_class_gpr);
3294 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3297 if (r0 == _R0_REGNO) {
3298 if (r1 != _R0_REGNO)
3301 reg = jit_get_reg(jit_class_gpr);
3303 STDX(r2, rn(reg), r1);
3312 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3317 else if (can_sign_extend_short_p(i0)) {
3318 if (r0 == _R0_REGNO) {
3319 reg = jit_get_reg(jit_class_gpr);
3321 STD(r1, rn(reg), i0);
3328 reg = jit_get_reg(jit_class_gpr);
3330 stxr_l(rn(reg), r0, r1);
3337 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3348 /* pc relative jump */
3350 _jmpi(jit_state_t *_jit, jit_word_t i0)
3356 if (can_sign_extend_jump_p(d))
3359 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3360 w = movi_p(rn(reg), i0);
3369 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3373 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3374 w = movi_p(rn(reg), i0);
3381 _callr(jit_state_t *_jit, jit_int32_t r0
3383 , jit_int32_t varargs
3388 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3389 /* FIXME Pretend to not know about r11? */
3390 if (r0 == _R0_REGNO) {
3391 movr(_R11_REGNO, _R0_REGNO);
3392 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3393 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3396 ldxi(_R2_REGNO, r0, sizeof(void*));
3397 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3402 /* Tell double arguments were passed in registers. */
3406 movr(_R12_REGNO, r0);
3413 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3417 /* assume fixed address or reachable address */
3419 _calli(jit_state_t *_jit, jit_word_t i0
3421 , jit_int32_t varargs
3428 d = (i0 - _jit->pc.w - !!varargs * 4) & ~3;
3429 if (can_sign_extend_jump_p(d)) {
3430 /* Tell double arguments were passed in registers. */
3440 movi(_R12_REGNO, i0);
3452 _calli_p(jit_state_t *_jit, jit_word_t i0
3454 , jit_int32_t varargs
3459 w = movi_p(_R12_REGNO, i0);
3468 /* order is not guaranteed to be sequential */
3469 static jit_int32_t save[] = {
3470 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3471 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3475 _prolog(jit_state_t *_jit, jit_node_t *node)
3477 unsigned long regno;
3480 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3481 jit_int32_t frame = -_jitc->function->frame;
3482 assert(_jitc->function->self.aoff >= frame);
3483 if (_jitc->function->assume_frame)
3485 _jitc->function->self.aoff = frame;
3487 if (_jitc->function->allocar) {
3488 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3489 _jitc->function->self.aoff &= -16;
3491 _jitc->function->stack = ((_jitc->function->self.alen +
3492 _jitc->function->self.size -
3493 _jitc->function->self.aoff) + 15) & -16;
3495 /* return address */
3498 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3499 * alloca < %r31-80 */
3502 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3504 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3506 offset = -gpr_save_area;
3507 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3508 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3509 stxi(offset, _SP_REGNO, rn(save[regno]));
3511 for (offset = 0; offset < 8; offset++) {
3512 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3513 stxi_d(-(gpr_save_area + 8 + offset * 8),
3514 _SP_REGNO, rn(_F14 + offset));
3517 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3519 movr(_FP_REGNO, _SP_REGNO);
3520 #if __WORDSIZE == 32
3521 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3523 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3526 if (_jitc->function->allocar) {
3527 regno = jit_get_reg(jit_class_gpr);
3528 movi(rn(regno), _jitc->function->self.aoff);
3529 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3530 jit_unget_reg(regno);
3534 if (_jitc->function->self.call & jit_call_varargs) {
3535 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3536 stxi(params_offset + regno * sizeof(jit_word_t),
3537 _FP_REGNO, rn(JIT_RA0 - regno));
3540 if (_jitc->function->self.call & jit_call_varargs) {
3541 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3542 stxi(_jitc->function->vaoff + first_gp_offset +
3543 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3544 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3545 stxi_d(_jitc->function->vaoff + first_fp_offset +
3546 regno * va_fp_increment, _FP_REGNO,
3547 rn(JIT_FA0 - regno));
3553 _epilog(jit_state_t *_jit, jit_node_t *node)
3555 unsigned long regno;
3558 if (_jitc->function->assume_frame)
3560 if (_jitc->function->allocar)
3561 ldr(_SP_REGNO, _SP_REGNO);
3563 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3565 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3567 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3569 offset = -gpr_save_area;
3570 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3571 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3572 ldxi(rn(save[regno]), _SP_REGNO, offset);
3574 for (offset = 0; offset < 8; offset++) {
3575 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3576 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3577 -(gpr_save_area + 8 + offset * 8));
3581 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3587 _vastart(jit_state_t *_jit, jit_int32_t r0)
3590 assert(_jitc->function->self.call & jit_call_varargs);
3591 /* Initialize stack pointer to the first stack argument. */
3592 addi(r0, _FP_REGNO, _jitc->function->self.size);
3595 assert(_jitc->function->self.call & jit_call_varargs);
3597 /* Return jit_va_list_t in the register argument */
3598 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3599 reg = jit_get_reg(jit_class_gpr);
3601 /* Initialize the gp counter. */
3602 movi(rn(reg), _jitc->function->vagp);
3603 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3605 /* Initialize the fp counter. */
3606 movi(rn(reg), _jitc->function->vafp);
3607 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3609 /* Initialize overflow pointer to the first stack argument. */
3610 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3611 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3613 /* Initialize register save area pointer. */
3614 addi(rn(reg), r0, first_gp_offset);
3615 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3622 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3625 assert(_jitc->function->self.call & jit_call_varargs);
3626 /* Load argument. */
3628 /* Update va_list. */
3629 addi(r1, r1, sizeof(jit_word_t));
3636 assert(_jitc->function->self.call & jit_call_varargs);
3638 rg0 = jit_get_reg(jit_class_gpr);
3639 rg1 = jit_get_reg(jit_class_gpr);
3641 /* Load the gp offset in save area in the first temporary. */
3642 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3644 /* Jump over if there are no remaining arguments in the save area. */
3645 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3647 /* Update the gp counter. */
3648 addi(rn(rg1), rn(rg0), 1);
3649 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3651 /* Load the save area pointer in the second temporary. */
3652 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3654 /* Load the vararg argument in the first argument. */
3655 lshi(rn(rg0), rn(rg0), va_gp_shift);
3656 ldxr(r0, rn(rg1), rn(rg0));
3658 /* Will only need one temporary register below. */
3661 /* Jump over overflow code. */
3662 lt_code = _jit->pc.w;
3665 /* Where to land if argument is in overflow area. */
3666 patch_at(ge_code, _jit->pc.w);
3668 /* Load overflow pointer. */
3669 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3671 /* Load argument. */
3674 /* Update overflow pointer. */
3675 addi(rn(rg0), rn(rg0), va_gp_increment);
3676 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3678 /* Where to land if argument is in save area. */
3679 patch_at(lt_code, _jit->pc.w);
3686 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3689 assert(_jitc->function->self.call & jit_call_varargs);
3690 /* Load argument. */
3692 /* Update va_list. */
3693 addi(r1, r1, sizeof(jit_float64_t));
3700 assert(_jitc->function->self.call & jit_call_varargs);
3702 rg0 = jit_get_reg(jit_class_gpr);
3703 rg1 = jit_get_reg(jit_class_gpr);
3705 /* Load the fp offset in save area in the first temporary. */
3706 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3708 /* Jump over if there are no remaining arguments in the save area. */
3709 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3711 /* Update the fp counter. */
3712 addi(rn(rg1), rn(rg0), 1);
3713 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3715 /* Load the save area pointer in the second temporary. */
3716 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3718 /* Load the vararg argument in the first argument. */
3719 lshi(rn(rg0), rn(rg0), 3);
3720 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3721 offsetof(jit_va_list_t, first_gp_argument));
3722 ldxr_d(r0, rn(rg1), rn(rg0));
3724 /* Jump over overflow code. */
3725 lt_code = _jit->pc.w;
3728 /* Where to land if argument is in overflow area. */
3729 patch_at(ge_code, _jit->pc.w);
3731 /* Load overflow pointer. */
3732 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3734 # if __WORDSIZE == 32
3735 /* Align if required. */
3736 andi(rn(rg1), rn(rg0), 7);
3737 addr(rn(rg0), rn(rg0), rn(rg1));
3740 /* Load argument. */
3743 /* Update overflow pointer. */
3744 addi(rn(rg0), rn(rg0), va_fp_increment);
3745 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3747 /* Where to land if argument is in save area. */
3748 patch_at(lt_code, _jit->pc.w);
3756 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3764 switch ((u.i[0] & 0xfc000000) >> 26) {
3768 if (!can_sign_extend_short_p(d)) {
3769 /* use absolute address */
3770 assert(can_sign_extend_short_p(label));
3773 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3777 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3778 /* zero is used for toc and env, so, quick check
3779 * if this is a "jmpi main" like initial jit
3781 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3782 for (d = 0; d < _jitc->prolog.offset; d++) {
3783 /* not so pretty, but hides powerpc
3784 * specific abi intrinsics and/or
3785 * implementation from user */
3786 if (_jitc->prolog.ptr[d] == label) {
3787 label += sizeof(void*) * 3;
3796 if (!can_sign_extend_jump_p(d)) {
3797 /* use absolute address */
3798 assert(can_sign_extend_jump_p(label));
3801 u.i[0] = (u.i[0] & ~0x3fffffc) | (d & 0x3fffffd);
3804 #if __WORDSIZE == 32
3805 # define MTCTR_OFF 2
3808 # define MTCTR_OFF 6
3812 /* movi reg label; jmpr reg */
3815 /* check for MLTR(reg) */
3816 (u.i[MTCTR_OFF] >> 26) == 31 &&
3817 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3818 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3820 u.i[BCTR_OFF] == 0x4e800020) {
3822 /* check for MTCTR(reg) */
3823 (u.i[MTCTR_OFF] >> 26) == 31 &&
3824 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3825 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3826 /* check for BCTR */
3827 u.i[BCTR_OFF] == 0x4e800420) {
3829 /* zero is used for toc and env, so, quick check
3830 * if this is a "jmpi main" like initial jit
3832 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3833 for (d = 0; d < _jitc->prolog.offset; d++) {
3834 /* not so pretty, but hides powerpc
3835 * specific abi intrinsics and/or
3836 * implementation from user */
3837 if (_jitc->prolog.ptr[d] == label) {
3838 label += sizeof(void*) * 3;
3847 #if __WORDSIZE == 32
3848 assert(!(u.i[0] & 0x1f0000));
3849 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3850 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3851 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3852 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3854 assert(!(u.i[0] & 0x1f0000));
3855 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3856 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3857 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3858 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3859 /* not fully validating SLDI */
3860 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3861 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3862 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3863 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3864 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3865 /* not fully validating SLDI */
3866 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3867 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3868 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3869 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3870 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3874 assert(!"unhandled branch opcode");