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 ldi(r0,i0) ldi_i(r0,i0)
65 # define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0)
66 # define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2)
67 # define str(r0,r1) str_i(r0,r1)
68 # define sti(i0,r0) sti_i(i0,r0)
69 # define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
70 # define stxr(r0,r1,r2) stxr_i(r0,r1,r2)
72 # define ldr(r0,r1) ldr_l(r0,r1)
73 # define ldi(r0,i0) ldi_l(r0,i0)
74 # define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0)
75 # define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2)
76 # define str(r0,r1) str_l(r0,r1)
77 # define sti(i0,r0) sti_l(i0,r0)
78 # define stxi(i0,r0,r1) stxi_l(i0,r0,r1)
79 # define stxr(r0,r1,r2) stxr_l(r0,r1,r2)
81 # define FXO(o,d,a,b,e,x) _FXO(_jit,o,d,a,b,e,x,0)
82 # define FXO_(o,d,a,b,e,x) _FXO(_jit,o,d,a,b,e,x,1)
83 static void _FXO(jit_state_t*,int,int,int,int,int,int,int);
84 # define FDs(o,d,a,s) _FDs(_jit,o,d,a,s)
85 static void _FDs(jit_state_t*,int,int,int,int);
86 # define FDu(o,d,a,s) _FDu(_jit,o,d,a,s)
87 static void _FDu(jit_state_t*,int,int,int,int);
88 # define FX(o,d,a,b,x) _FX(_jit,o,d,a,b,x,0)
89 # define FX_(o,d,a,b,x) _FX(_jit,o,d,a,b,x,1)
90 static void _FX(jit_state_t*,int,int,int,int,int,int);
91 # define FI(o,t,a,k) _FI(_jit,o,t,a,k)
92 static void _FI(jit_state_t*,int,int,int,int);
93 # define FB(o,bo,bi,t,a,k) _FB(_jit,o,bo,bi,t,a,k)
94 static void _FB(jit_state_t*,int,int,int,int,int,int);
95 # define FXL(o,bo,bi,x) _FXL(_jit,o,bo,bi,x,0)
96 # define FXL_(o,bo,bi,x) _FXL(_jit,o,bo,bi,x,1)
97 static void _FXL(jit_state_t*,int,int,int,int,int);
98 # define FC(o,d,l,a,b,x) _FC(_jit,o,d,l,a,b,x)
99 static void _FC(jit_state_t*,int,int,int,int,int,int);
100 # define FCI(o,d,l,a,s) _FCI(_jit,o,d,l,a,s)
101 static void _FCI(jit_state_t*,int,int,int,int,int);
102 # define FXFX(o,s,x,f) _FXFX(_jit,o,s,x,f)
103 static void _FXFX(jit_state_t*,int,int,int,int);
104 # define FM(o,s,a,h,b,e,r) _FM(_jit,o,s,a,h,b,e,r)
105 static void _FM(jit_state_t*,int,int,int,int,int,int,int);
106 # if __WORDSIZE == 64
107 # define FMDS(o,s,a,b,e,x) _FMDS(_jit,o,s,a,b,e,x,0)
108 # define FMDS_(o,s,a,b,e,x) _FMDS(_jit,o,s,a,b,e,x,1)
109 static void _FMDS(jit_state_t*,int,int,int,int,int,int,int);
110 # define FMD(o,s,a,h,b,x,i) _FMD(_jit,o,s,a,h,b,x,i,0)
111 # define FMD_(o,s,a,h,b,x,i) _FMD(_jit,o,s,a,h,b,x,i,1)
112 static void _FMD(jit_state_t*,int,int,int,int,int,int,int,int);
113 # define FXS(o,d,a,h,x,i) _FXS(_jit,o,d,a,h,x,i,0)
114 # define FXS_(o,d,a,h,x,i) _FXS(_jit,o,d,a,h,x,i,1)
115 static void _FXS(jit_state_t*,int,int,int,int,int,int,int);
132 # define ADD(d,a,b) FXO(31,d,a,b,0,266)
133 # define ADD_(d,a,b) FXO_(31,d,a,b,0,266)
134 # define ADDO(d,a,b) FXO(31,d,a,b,1,266)
135 # define ADDO_(d,a,b) FXO_(31,d,a,b,1,266)
136 # define ADDC(d,a,b) FXO_(31,d,a,b,0,10)
137 # define ADDC_(d,a,b) FXO_(31,d,a,b,0,10)
138 # define ADDCO(d,a,b) FXO(31,d,a,b,1,10)
139 # define ADDCO_(d,a,b) FXO_(31,d,a,b,1,10)
140 # define ADDE(d,a,b) FXO(31,d,a,b,0,138)
141 # define ADDE_(d,a,b) FXO_(31,d,a,b,0,138)
142 # define ADDEO(d,a,b) FXO(31,d,a,b,1,138)
143 # define ADDEO_(d,a,b) FXO_(31,d,a,b,1,138)
144 # define ADDI(d,a,s) FDs(14,d,a,s)
145 # define ADDIC(d,a,s) FDs(12,d,a,s)
146 # define ADDIC_(d,a,s) FDs(13,d,a,s)
147 # define ADDIS(d,a,s) FDs(15,d,a,s)
148 # define LIS(d,s) ADDIS(d,0,s)
149 # define ADDME(d,a) FXO(31,d,a,0,0,234)
150 # define ADDME_(d,a) FXO_(31,d,a,0,0,234)
151 # define ADDMEO(d,a) FXO(31,d,a,0,1,234)
152 # define ADDMEO_(d,a) FXO_(31,d,a,0,1,234)
153 # define ADDZE(d,a) FXO(31,d,a,0,0,202)
154 # define ADDZE_(d,a) FXO_(31,d,a,0,0,202)
155 # define ADDZEO(d,a) FXO(31,d,a,0,1,202)
156 # define ADDZEO_(d,a) FXO_(31,d,a,0,1,202)
157 # define AND(d,a,b) FX(31,a,d,b,28)
158 # define ANDC(d,a,b) FXO(31,a,d,b,0,60)
159 # define ANDC_(d,a,b) FXO_(31,a,d,b,0,60)
160 # define AND_(d,a,b) FX_(31,a,b,d,28)
161 # define ANDI_(d,a,u) FDu(28,a,d,u)
162 # define ANDIS_(d,a,u) FDu(29,a,d,u)
163 # define B(t) FI(18,t,0,0)
164 # define BA(t) FI(18,t,1,0)
165 # define BL(t) FI(18,t,0,1)
166 # define BLA(t) FI(18,t,1,1)
167 # define BC(o,i,t) FB(16,o,i,t,0,0)
168 # define BCA(o,i,t) FB(16,o,i,t,1,0)
169 # define BCL(o,i,t) FB(16,o,i,t,0,1)
170 # define BCLA(o,i,t) FB(16,o,i,t,1,1)
171 # define BLT(t) BC(BCC_T,CR_LT,t)
172 # define BLE(t) BC(BCC_F,CR_GT,t)
173 # define BEQ(t) BC(BCC_T,CR_EQ,t)
174 # define BGE(t) BC(BCC_F,CR_LT,t)
175 # define BGT(t) BC(BCC_T,CR_GT,t)
176 # define BNE(t) BC(BCC_F,CR_EQ,t)
177 # define BUN(t) BC(BCC_T,CR_UN,t)
178 # define BNU(t) BC(BCC_F,CR_UN,t)
179 # define BCCTR(o,i) FXL(19,o,i,528)
180 # define BCCTRL(o,i) FXL_(19,o,i,528)
181 # define BLTCTR() BCCTR(BCC_T,CR_LT)
182 # define BLECTR() BCCTR(BCC_F,CR_GT)
183 # define BEQCTR() BCCTR(BCC_T,CR_EQ)
184 # define BGECTR() BCCTR(BCC_F,CR_LT)
185 # define BGTCTR() BCCTR(BCC_T,CR_GT)
186 # define BNECTR() BCCTR(BCC_F,CR_EQ)
187 # define BCTR() BCCTR(20,0)
188 # define BCTRL() BCCTRL(20,0)
189 # define BCLR(o,i) FXL(19,o,i,16)
190 # define BCLRL(o,i) FXL_(19,o,i,16)
191 # define BLTLR() BCLR(BCC_T,CR_LT)
192 # define BLELR() BCLR(BCC_F,CR_GT)
193 # define BEQLR() BCLR(BCC_T,CR_EQ)
194 # define BGELR() BCLR(BCC_F,CR_LT)
195 # define BGTLR() BCLR(BCC_T,CR_GT)
196 # define BNELR() BCLR(BCC_F,CR_EQ)
197 # define BLR() BCLR(20,0)
198 # define BLRL() BCLRL(20,0)
199 # define XCMP(cr,l,a,b) FC(31,cr,l,a,b,0)
200 # define CMPD(a,b) XCMP(0,1,a,b)
201 # define CMPW(a,b) XCMP(0,0,a,b)
202 # define XCMPI(cr,l,a,s) FCI(11,cr,l,a,s)
203 # define CMPDI(a,s) XCMPI(0,1,a,s)
204 # define CMPWI(a,s) XCMPI(0,0,a,s)
205 # define XCMPL(cr,l,a,b) FC(31,cr,l,a,b,32)
206 # define CMPLD(a,b) XCMPL(0,1,a,b)
207 # define CMPLW(a,b) XCMPL(0,0,a,b)
208 # define XCMPLI(cr,l,a,u) FCI(10,cr,l,a,u)
209 # define CMPLDI(a,s) XCMPLI(0,1,a,s)
210 # define CMPLWI(a,s) XCMPLI(0,0,a,s)
211 # if __WORDSIZE == 32
212 # define CMPX(a,b) CMPW(a,b)
213 # define CMPXI(a,s) CMPWI(a,s)
214 # define CMPLX(a,b) CMPLW(a,b)
215 # define CMPLXI(a,s) CMPLWI(a,s)
217 # define CMPX(a,b) CMPD(a,b)
218 # define CMPXI(a,s) CMPDI(a,s)
219 # define CMPLX(a,b) CMPLD(a,b)
220 # define CMPLXI(a,s) CMPLDI(a,s)
222 # define CNTLZW(a,s) FX(31,s,a,0,26)
223 # define CNTLZW_(a,s) FX_(31,s,a,0,26)
224 # define CNTLZD(a,s) FX(31,s,a,0,58)
225 # define CNTLZD_(a,s) FX_(31,s,a,0,58)
226 # define CRAND(d,a,b) FX(19,d,a,b,257)
227 # define CRANDC(d,a,b) FX(19,d,a,b,129)
228 # define CREQV(d,a,b) FX(19,d,a,b,289)
229 # define CRSET(d) CREQV(d,d,d)
230 # define CRNAND(d,a,b) FX(19,d,a,b,225)
231 # define CRNOR(d,a,b) FX(19,d,a,b,33)
232 # define CRNOT(d,a) CRNOR(d,a,a)
233 # define CROR(d,a,b) FX(19,d,a,b,449)
234 # define CRMOVE(d,a) CROR(d,a,a)
235 # define CRORC(d,a,b) FX(19,d,a,b,417)
236 # define CRXOR(d,a,b) FX(19,d,a,b,193)
237 # define CRCLR(d) CRXOR(d,d,d)
238 # define DCBA(a,b) FX(31,0,a,b,758)
239 # define DCBF(a,b) FX(31,0,a,b,86)
240 # define DCBI(a,b) FX(31,0,a,b,470)
241 # define DCBST(a,b) FX(31,0,a,b,54)
242 # define DCBT(a,b) FX(31,0,a,b,278)
243 # define DCBTST(a,b) FX(31,0,a,b,246)
244 # define DCBZ(a,b) FX(31,0,a,b,1014)
245 # define DIVW(d,a,b) FXO(31,d,a,b,0,491)
246 # define DIVW_(d,a,b) FXO_(31,d,a,b,0,491)
247 # define DIVWO(d,a,b) FXO(31,d,a,b,1,491)
248 # define DIVWO_(d,a,b) FXO_(31,d,a,b,1,491)
249 # define DIVWU(d,a,b) FXO(31,d,a,b,0,459)
250 # define DIVWU_(d,a,b) FXO_(31,d,a,b,0,459)
251 # define DIVWUO(d,a,b) FXO(31,d,a,b,1,459)
252 # define DIVWUO_(d,a,b) FXO_(31,d,a,b,1,459)
253 # define DIVD(d,a,b) FXO(31,d,a,b,0,489)
254 # define DIVD_(d,a,b) FXO_(31,d,a,b,0,489)
255 # define DIVDO(d,a,b) FXO(31,d,a,b,1,489)
256 # define DIVDO_(d,a,b) FXO_(31,d,a,b,1,489)
257 # define DIVDU(d,a,b) FXO(31,d,a,b,0,457)
258 # define DIVDU_(d,a,b) FXO_(31,d,a,b,0,457)
259 # define DIVDUO(d,a,b) FXO(31,d,a,b,1,457)
260 # define DIVDUO_(d,a,b) FXO_(31,d,a,b,1,457)
261 # define ECIWX(d,a,b) FX(31,d,a,b,310)
262 # define ECOWX(s,a,b) FX(31,s,a,b,438)
263 # define EIEIO() FX(31,0,0,0,854)
264 # define EQV(d,a,b) FX(31,a,d,b,284)
265 # define EQV_(d,a,b) FX_(31,a,d,b,284)
266 # define EXTSB(d,a) FX(31,a,d,0,954)
267 # define EXTSB_(d,a) FX_(31,a,d,0,954)
268 # define EXTSH(d,a) FX(31,a,d,0,922)
269 # define EXTSH_(d,a) FX_(31,a,d,0,922)
270 # define EXTSW(d,a) FX(31,a,d,0,986)
271 # define EXTSW_(d,a) FX_(31,a,d,0,986)
272 # define ICIB(a,b) FX(31,0,a,b,982)
273 # define ISYNC() FXL(19,0,0,150)
274 # define LBZ(d,a,s) FDs(34,d,a,s)
275 # define LBZU(d,a,s) FDs(35,d,a,s)
276 # define LBZUX(d,a,b) FX(31,d,a,b,119)
277 # define LBZX(d,a,b) FX(31,d,a,b,87)
278 # define LHA(d,a,s) FDs(42,d,a,s)
279 # define LHAU(d,a,s) FDs(43,d,a,s)
280 # define LHAUX(d,a,b) FX(31,d,a,b,375)
281 # define LHAX(d,a,b) FX(31,d,a,b,343)
282 # define LHBRX(d,a,b) FX(31,d,a,b,790)
283 # define LHZ(d,a,s) FDs(40,d,a,s)
284 # define LHZU(d,a,s) FDs(41,d,a,s)
285 # define LHZUX(d,a,b) FX(31,d,a,b,311)
286 # define LHZX(d,a,b) FX(31,d,a,b,279)
287 # define LA(d,a,s) ADDI(d,a,s)
288 # define LI(d,s) ADDI(d,0,s)
289 # define LMW(d,a,s) FDs(46,d,a,s)
290 # define LSWI(d,a,n) FX(31,d,a,n,597)
291 # define LSWX(d,a,b) FX(31,d,a,b,533)
292 # define LWARX(d,a,b) FX(31,d,a,b,20)
293 # define LDARX(d,a,b) FX(31,d,a,b,84)
294 # define LWBRX(d,a,b) FX(31,d,a,b,534)
295 # define LWA(d,a,s) FDs(58,d,a,s|2)
296 # define LWAUX(d,a,b) FX(31,d,a,b,373)
297 # define LWAX(d,a,b) FX(31,d,a,b,341)
298 # define LWZ(d,a,s) FDs(32,d,a,s)
299 # define LWZU(d,a,s) FDs(33,d,a,s)
300 # define LWZUX(d,a,b) FX(31,d,a,b,55)
301 # define LWZX(d,a,b) FX(31,d,a,b,23)
302 # define LD(d,a,s) FDs(58,d,a,s)
303 # define LDX(d,a,b) FX(31,d,a,b,21)
304 # define MCRF(d,s) FXL(19,((d)<<2),((s)<<2),0)
306 /* In case instruction is emulated, check the kernel can handle it.
307 Will only generate it if DEBUG is enabled.
309 Chapter 6. Optional Facilities and Instructions that are being
310 Phased Out of the Architecture
312 6.1 Move To Condition Register from XER
313 The mcrxr instruction is being phased out of the archi-
314 tecture. Its description is included here as an aid to
315 constructing operating system code to emulate it.
317 Move to Condition Register from XER
320 31 BF // /// /// 512 /
322 CR(4xBF:4xBF+3) <- XER(32:35)
324 The contents of XER(32:35) are copied to Condition Reg-
325 ister field BF. XER(32:35) are set to zero.
326 Special Registers Altered:
327 CR field BF XER(32:35)
330 Warning: This instruction has been phased out of
331 the architecture. Attempting to execute this
332 instruction will cause the system illegal instruction
333 error handler to be invoked
336 # define MCRXR(d) FX(31,((d)<<2),0,0,512)
338 # define MCRXR(cr) _MCRXR(_jit,cr);
339 static void _MCRXR(jit_state_t*, jit_int32_t);
341 # define MFCR(d) FX(31,d,0,0,19)
342 # define MFMSR(d) FX(31,d,0,0,83)
343 # define MFSPR(d,s) FXFX(31,d,((s)<<5),339)
344 # define MFXER(d) MFSPR(d,1)
345 # define MFLR(d) MFSPR(d,8)
346 # define MFCTR(d) MFSPR(d,9)
347 # define MFSR(d,s) FX(31,d,s,0,595)
348 # define MFSRIN(d,b) FX(31,d,0,b,659)
349 # define MFTB(d,x,y) FXFX(31,d,((x)|((y)<<5)),371)
350 # define MFTBL(d) MFTB(d,8,12)
351 # define MFTBU(d) MFTB(d,8,13)
352 # define MTCRF(c,s) FXFX(31,s,((c)<<1),144)
353 # define MTCR(s) MTCRF(0xff,s)
354 # define MTMSR(s) FX(31,s,0,0,146)
355 # define MTSPR(d,s) FXFX(31,d,((s)<<5),467)
356 # define MTXER(d) MTSPR(d,1)
357 # define MTLR(d) MTSPR(d,8)
358 # define MTCTR(d) MTSPR(d,9)
359 # define MTSR(r,s) FX(31,((s)<<1),r,0,210)
360 # define MTSRIN(r,b) FX(31,((r)<<1),0,b,242)
361 # define MULLI(d,a,s) FDs(07,d,a,s)
362 # define MULHW(d,a,b) FXO(31,d,a,b,0,75)
363 # define MULHW_(d,a,b) FXO_(31,d,a,b,0,75)
364 # define MULHWU(d,a,b) FXO(31,d,a,b,0,11)
365 # define MULHWU_(d,a,b) FXO_(31,d,a,b,0,11)
366 # define MULLW(d,a,b) FXO(31,d,a,b,0,235)
367 # define MULLW_(d,a,b) FXO_(31,d,a,b,0,235)
368 # define MULLWO(d,a,b) FXO(31,d,a,b,1,235)
369 # define MULLWO_(d,a,b) FXO_(31,d,a,b,1,235)
370 # define MULHD(d,a,b) FXO(31,d,a,b,0,73)
371 # define MULHD_(d,a,b) FXO_(31,d,a,b,0,73)
372 # define MULHDU(d,a,b) FXO(31,d,a,b,0,9)
373 # define MULHDU_(d,a,b) FXO_(31,d,a,b,0,9)
374 # define MULLD(d,a,b) FXO(31,d,a,b,0,233)
375 # define MULLD_(d,a,b) FXO_(31,d,a,b,0,233)
376 # define MULLDO(d,a,b) FXO(31,d,a,b,1,233)
377 # define MULLDO_(d,a,b) FXO_(31,d,a,b,1,233)
378 # define NAND(d,a,b) FX(31,a,d,b,476)
379 # define NAND_(d,a,b) FX_(31,a,d,b,476)
380 # define NEG(d,a) FXO(31,d,a,0,0,104)
381 # define NEG_(d,a) FXO_(31,d,a,0,0,104)
382 # define NEGO(d,a) FXO(31,d,a,0,1,104)
383 # define NEGO_(d,a) FXO_(31,d,a,0,1,104)
384 # define NOR(d,a,b) FX(31,a,d,b,124)
385 # define NOR_(d,a,b) FX_(31,a,d,b,124)
386 # define NOT(d,s) NOR(d,s,s)
387 # define OR(d,a,b) FX(31,a,d,b,444)
388 # define OR_(d,a,b) FX_(31,a,d,b,444)
389 # define MR(d,a) OR(d,a,a)
390 # define ORC(d,a,b) FX(31,a,d,b,412)
391 # define ORC_(d,a,b) FX_(31,a,d,b,412)
392 # define ORI(d,a,u) FDu(24,a,d,u)
393 # define NOP() ORI(0,0,0)
394 # define ORIS(d,a,u) FDu(25,a,d,u)
395 # define POPCNTB(a,s) FX(31,s,a,0,122)
396 # define RFI() FXL(19,0,0,50)
397 # define RLWIMI(d,s,h,b,e) FM(20,s,d,h,b,e,0)
398 # define RLWIMI_(d,s,h,b,e) FM(20,s,d,h,b,e,1)
399 # define INSLWI(a,s,n,b) RLWIMI(a,s,(32-(b)),b,(((b)+(n))-1))
400 # define INSRWI(a,s,n,b) RLWIMI(a,s,(32-((b)+(n))),b,(((b)+(n))-1))
401 # define RLWINM(a,s,h,b,e) FM(21,s,a,h,b,e,0)
402 # define RLWINM_(a,s,h,b,e) FM(21,s,a,h,b,e,1)
403 # define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,((n)-1))
404 # define EXTRWI(a,s,n,b) RLWINM(a,s,((b)+(n)),(32-(n)),31)
405 # define ROTLWI(a,s,n) RLWINM(a,s,n,0,31)
406 # define ROTRWI(a,s,n) RLWINM(a,s,(32-(n)),0,31)
407 # define SLWI(a,s,n) RLWINM(a,s,n,0,(31-(n)))
408 # define SRWI(a,s,n) RLWINM(a,s,(32-(n)),n,31)
409 # define CLRLWI(a,s,n) RLWINM(a,s,0,n,31)
410 # define CLRRWI(a,s,n) RLWINM(a,s,0,0,(31-(n)))
411 # define CLRLSWI(a,s,b,n) RLWINM(a,s,n,((b)-(n)),(31-(n)))
412 # define RLWNM(a,s,b,m,e) FM(23,s,a,b,m,e,0)
413 # define RLWNM_(a,s,b,m,e) FM(23,s,a,b,m,e,1)
414 # define ROTLW(a,s,b) RLWNM(a,s,b,0,31)
415 # define SC() FDu(17,0,0,2)
416 # define SLW(a,s,b) FX(31,s,a,b,24)
417 # define SLW_(a,s,b) FX_(31,s,a,b,24)
418 # define SRAW(a,s,b) FX(31,s,a,b,792)
419 # define SRAW_(a,s,b) FX_(31,s,a,b,792)
420 # define SRAWI(a,s,h) FX(31,s,a,h,824)
421 # define SRAWI_(a,s,h) FX_(31,s,a,h,824)
422 # define SRW(a,s,b) FX(31,s,a,b,536)
423 # define SRW_(a,s,b) FX_(31,s,a,b,536)
424 # if __WORDSIZE == 64
425 # define RLDICL(a,s,h,b) FMD(30,s,a,((h)&~32),b,0,((h)>>5))
426 # define RLDICL_(a,s,h,b) FMD_(30,s,a,((h)&~32),b,0,((h)>>5))
427 # define EXTRDI(x,y,n,b) RLDICL(x,y,((b)+(n)),(64-(n)))
428 # define SRDI(x,y,n) RLDICL(x,y,(64-(n)),n)
429 # define CLRLDI(x,y,n) RLDICL(x,y,0,n)
430 # define RLDICR(a,s,h,e) FMD(30,s,a,((h)&~32),e,1,((h)>>5))
431 # define RLDICR_(a,s,h,e) FMD_(30,s,a,((h)&~32),e,1,((h)>>5))
432 # define EXTLDI(x,y,n,b) RLDICR(x,y,b,((n)-1))
433 # define SLDI(x,y,n) RLDICR(x,y,n,(63-(n)))
434 # define CLRRDI(x,y,n) RLDICR(x,y,0,(63-(n)))
435 # define RLDIC(a,s,h,b) FMD(30,s,a,((h)&~32),b,2,((h)>>5))
436 # define RLDIC_(a,s,h,b) FMD_(30,s,a,((h)&~32),b,2,((h)>>5))
437 # define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,((b)-(n)))
438 # define RLDCL(a,s,h,b) FMDS(30,s,a,h,b,8)
439 # define RLDCL_(a,s,h,b) FMDS_(30,s,a,h,b,8)
440 # define ROTLD(x,y,z) RLDCL(x,y,z,0)
441 # define RLDCR(a,s,b,e) FMDS(30,s,a,b,e,0)
442 # define RLDCR_(a,s,b,e) FMDS_(30,s,a,b,e,0)
443 # define RLDIMI(a,s,h,b) FMD(30,s,a,((h)&~32),b,3,((h)>>5))
444 # define RLDIMI_(a,s,h,b) FMD_(30,s,a,((h)&~32),b,3,((h)>>5))
445 # define INSLDI(x,y,n,b) RLDIMI(x,y,(64-(b)),(((b)+(n))-1))
446 # define INSRDI(x,y,n,b) RLDIMI(x,y,(64-((b)+(n))),b)
447 # define SLD(a,s,b) FX(31,s,a,b,27)
448 # define SLD_(a,s,b) FX_(31,s,a,b,27)
449 # define SRD(a,s,b) FX(31,s,a,b,539)
450 # define SRD_(a,s,b) FX_(31,s,a,b,539)
451 # define SRADI(a,s,h) FXS(31,s,a,((h)&~32),413,((h)>>5))
452 # define SRADI_(a,s,h) FXS_(31,s,a,((h)&~32),413,((h)>>5))
453 # define SRAD(a,s,b) FX(31,s,a,b,794)
454 # define SRAD_(a,s,b) FX_(31,s,a,b,794)
456 # define STB(s,a,d) FDs(38,s,a,d)
457 # define STBU(s,a,d) FDs(39,s,a,d)
458 # define STBUX(s,a,b) FX(31,s,a,b,247)
459 # define STBX(s,a,b) FX(31,s,a,b,215)
460 # define STH(s,a,d) FDs(44,s,a,d)
461 # define STHBRX(s,a,b) FX(31,s,a,b,918)
462 # define STHU(s,a,d) FDs(45,s,a,d)
463 # define STHUX(s,a,b) FX(31,s,a,b,439)
464 # define STHX(s,a,b) FX(31,s,a,b,407)
465 # define STMW(s,a,d) FDs(47,s,a,d)
466 # define STWSI(s,a,nb) FX(31,s,a,nb,725)
467 # define STSWX(s,a,b) FX(31,s,a,b,661)
468 # define STW(s,a,d) FDs(36,s,a,d)
469 # define STWBRX(s,a,b) FX(31,s,a,b,662)
470 # define STWCX_(s,a,b) FX_(31,s,a,b,150)
471 # define STDCX_(s,a,b) FX_(31,s,a,b,214)
472 # define STWU(s,a,d) FDs(37,s,a,d)
473 # define STWUX(s,a,b) FX(31,s,a,b,183)
474 # define STWX(s,a,b) FX(31,s,a,b,151)
475 # define STD(s,a,d) FDs(62,s,a,d)
476 # define STDX(s,a,b) FX(31,s,a,b,149)
477 # define STDU(s,a,d) FDs(62,s,a,((d)|1))
478 # define STDUX(s,a,b) FX(31,s,a,b,181)
479 # define SUBF(d,a,b) FXO(31,d,a,b,0,40)
480 # define SUBF_(d,a,b) FXO_(31,d,a,b,0,40)
481 # define SUBFO(d,a,b) FXO(31,d,a,b,1,40)
482 # define SUBFO_(d,a,b) FXO_(31,d,a,b,1,40)
483 # define SUB(d,a,b) SUBF(d,b,a)
484 # define SUB_(d,a,b) SUBF_(d,b,a)
485 # define SUBO(d,a,b) SUBFO(d,b,a)
486 # define SUBO_(d,a,b) SUBFO_(d,b,a)
487 # define SUBI(d,a,s) ADDI(d,a,-(s))
488 # define SUBIS(d,a,s) ADDIS(d,a,-(s))
489 # define SUBFC(d,a,b) FXO(31,d,a,b,0,8)
490 # define SUBFC_(d,a,b) FXO_(31,d,a,b,0,8)
491 # define SUBFCO(d,a,b) FXO(31,d,a,b,1,8)
492 # define SUBFCO_(d,a,b) FXO_(31,d,a,b,1,8)
493 # define SUBC(d,a,b) SUBFC(d,b,a)
494 # define SUBIC(d,a,s) ADDIC(d,a,-(s))
495 # define SUBIC_(d,a,s) ADDIC_(d,a,-(s))
496 # define SUBFE(d,a,b) FXO(31,d,a,b,0,136)
497 # define SUBFE_(d,a,b) FXO_(31,d,a,b,0,136)
498 # define SUBFEO(d,a,b) FXO(31,d,a,b,1,136)
499 # define SUBFEO_(d,a,b) FXO_(31,d,a,b,1,136)
500 # define SUBE(d,a,b) SUBFE(d,b,a)
501 # define SUBFIC(d,a,s) FDs(8,d,a,s)
502 # define SUBFME(d,a) FXO(31,d,a,0,0,232)
503 # define SUBFME_(d,a) FXO_(31,d,a,0,0,232)
504 # define SUBFMEO(d,a) FXO(31,d,a,0,1,232)
505 # define SUBFMEO_(d,a) FXO_(31,d,a,0,1,232)
506 # define SUBFZE(d,a) FXO(31,d,a,0,0,200)
507 # define SUBFZE_(d,a) FXO_(31,d,a,0,0,200)
508 # define SUBFZEO(d,a) FXO(31,d,a,0,1,200)
509 # define SUBFZEO_(d,a) FXO_(31,d,a,0,1,200)
510 # define SYNC() FX(31,0,0,0,598)
511 # define TLBIA() FX(31,0,0,0,370)
512 # define TLBIE(b) FX(31,0,0,b,306)
513 # define TLBSYNC() FX(31,0,0,0,566)
514 # define TW(t,a,b) FX(31,t,a,b,4)
515 # define TWEQ(a,b) FX(31,4,a,b,4)
516 # define TWLGE(a,b) FX(31,5,a,b,4)
517 # define TRAP() FX(31,31,0,0,4)
518 # define TWI(t,a,s) FDs(3,t,a,s)
519 # define TWGTI(a,s) TWI(8,a,s)
520 # define TWLLEI(a,s) TWI(6,a,s)
521 # define XOR(d,a,b) FX(31,a,d,b,316)
522 # define XOR_(d,a,b) FX_(31,a,d,b,316)
523 # define XORI(s,a,u) FDu(26,a,s,u)
524 # define XORIS(s,a,u) FDu(27,a,s,u)
525 # define nop(c) _nop(_jit,c)
526 static void _nop(jit_state_t*,jit_int32_t);
527 # define movr(r0,r1) _movr(_jit,r0,r1)
528 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
529 # define movi(r0,i0) _movi(_jit,r0,i0)
530 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
531 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
532 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
533 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
534 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
535 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
536 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
537 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
538 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
539 jit_int32_t,jit_int32_t,jit_word_t);
540 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
541 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
542 # define negr(r0,r1) NEG(r0,r1)
543 # define comr(r0,r1) NOT(r0,r1)
544 # define clor(r0, r1) _clor(_jit, r0, r1)
545 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
546 # if __WORDSIZE == 32
547 # define clzr(r0, r1) CNTLZW(r0, r1)
549 # define clzr(r0, r1) CNTLZD(r0, r1)
551 # define ctor(r0, r1) _ctor(_jit, r0, r1)
552 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
553 # define ctzr(r0, r1) _ctzr(_jit, r0, r1)
554 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
555 # define popcntr(r0, r1) _popcntr(_jit, r0, r1)
556 static void _popcntr(jit_state_t*, jit_int32_t, jit_int32_t);
557 # define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1)
558 static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
559 # define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1)
560 static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
561 # define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1)
562 static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
563 # define extr_c(r0,r1) EXTSB(r0,r1)
564 # define extr_uc(r0,r1) ANDI_(r0,r1,0xff)
565 # define extr_s(r0,r1) EXTSH(r0,r1)
566 # define extr_us(r0,r1) ANDI_(r0,r1,0xffff)
567 # if __WORDSIZE == 64
568 # define extr_i(r0,r1) EXTSW(r0,r1)
569 # define extr_ui(r0,r1) CLRLDI(r0,r1,32)
571 # define bswapr_us_lh(r0,r1,no_flag) _bswapr_us(_jit,r0,r1,no_flag)
572 # define bswapr_us(r0,r1) _bswapr_us(_jit,r0,r1,0)
573 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
574 # define bswapr_ui_lw(r0,r1,no_flag) _bswapr_ui(_jit,r0,r1,no_flag)
575 # define bswapr_ui(r0,r1) _bswapr_ui(_jit,r0,r1,0)
576 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_bool_t);
577 # if __WORDSIZE == 64
578 # define bswapr_ul(r0,r1) generic_bswapr_ul(_jit,r0,r1)
580 # define addr(r0,r1,r2) ADD(r0,r1,r2)
581 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
582 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
583 # define addcr(r0,r1,r2) ADDC(r0,r1,r2)
584 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
585 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
586 # define addxr(r0,r1,r2) ADDE(r0,r1,r2)
587 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
588 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
589 # define subr(r0,r1,r2) SUB(r0,r1,r2)
590 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
591 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
592 # define subcr(r0,r1,r2) SUBC(r0,r1,r2)
593 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
594 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
595 # define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
596 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
597 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
598 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
599 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
600 # if __WORDSIZE == 32
601 # define mulr(r0,r1,r2) MULLW(r0,r1,r2)
602 # define mullr(r0,r1,r2) MULLW(r0,r1,r2)
603 # define hmulr(r0,r1,r2) MULHW(r0,r1,r2)
604 # define hmulr_u(r0,r1,r2) MULHWU(r0,r1,r2)
606 # define mulr(r0,r1,r2) MULLD(r0,r1,r2)
607 # define mullr(r0,r1,r2) MULLD(r0,r1,r2)
608 # define hmulr(r0,r1,r2) MULHD(r0,r1,r2)
609 # define hmulr_u(r0,r1,r2) MULHDU(r0,r1,r2)
611 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
612 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
613 # define hmuli(r0,r1,i0) _hmuli(_jit,r0,r1,i0)
614 static void _hmuli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
615 # define hmuli_u(r0,r1,i0) _hmuli_u(_jit,r0,r1,i0)
616 static void _hmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
617 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
618 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
619 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
620 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
621 jit_int32_t,jit_int32_t,jit_bool_t);
622 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
623 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
624 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
625 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
626 jit_int32_t,jit_word_t,jit_bool_t);
627 # if __WORDSIZE == 32
628 # define divr(r0,r1,r2) DIVW(r0,r1,r2)
630 # define divr(r0,r1,r2) DIVD(r0,r1,r2)
632 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
633 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
634 # if __WORDSIZE == 32
635 # define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
637 # define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
639 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
640 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
641 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
642 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
643 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
644 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
645 jit_int32_t,jit_int32_t,jit_bool_t);
646 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
647 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
648 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
649 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
650 jit_int32_t,jit_word_t,jit_bool_t);
651 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
652 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
653 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
654 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
655 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
656 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
657 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
658 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
659 # define andr(r0,r1,r2) AND(r0,r1,r2)
660 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
661 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
662 # define orr(r0,r1,r2) OR(r0,r1,r2)
663 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
664 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
665 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
666 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
667 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
668 # if __WORDSIZE == 32
669 # define lshr(r0,r1,r2) SLW(r0,r1,r2)
671 # define lshr(r0,r1,r2) SLD(r0,r1,r2)
673 #define qlshr(r0,r1,r2,r3) xlshr(1,r0,r1,r2,r3)
674 #define xlshr(s,r0,r1,r2,r3) _xlshr(_jit,s,r0,r1,r2,r3)
676 _xlshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
677 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
678 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
679 # define qlshi(r0, r1, r2, i0) xlshi(1, r0, r1, r2, i0)
680 # define xlshi(s, r0, r1, r2, i0) _xlshi(_jit, s, r0, r1, r2, i0)
682 _xlshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
683 # define qlshr_u(r0, r1, r2, r3) xlshr(0, r0, r1, r2, r3)
684 # define qlshi_u(r0, r1, r2, i0) xlshi(0, r0, r1, r2, i0)
685 # if __WORDSIZE == 32
686 # define rshr(r0,r1,r2) SRAW(r0,r1,r2)
688 # define rshr(r0,r1,r2) SRAD(r0,r1,r2)
690 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
691 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
692 # if __WORDSIZE == 32
693 # define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
695 # define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
697 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
698 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
699 # define qrshr(r0, r1, r2, r3) xrshr(1, r0, r1, r2, r3)
700 # define qrshr_u(r0, r1, r2, r3) xrshr(0, r0, r1, r2, r3)
701 # define xrshr(s, r0, r1, r2, r3) _xrshr(_jit, s, r0, r1, r2, r3)
703 _xrshr(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
704 # define qrshi(r0, r1, r2, i0) xrshi(1, r0, r1, r2, i0)
705 # define qrshi_u(r0, r1, r2, i0) xrshi(0, r0, r1, r2, i0)
706 # define xrshi(s, r0, r1, r2, i0) _xrshi(_jit, s, r0, r1, r2, i0)
708 _xrshi(jit_state_t*,jit_bool_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
709 # if __WORDSIZE == 32
710 # define lrotr(r0,r1,r2) ROTLW(r0,r1,r2)
712 # define lrotr(r0,r1,r2) ROTLD(r0,r1,r2)
714 # define lroti(r0,r1,i0) _lroti(_jit,r0,r1,i0)
715 static void _lroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
716 # define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2)
717 static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
718 # define rroti(r0,r1,i0) _rroti(_jit,r0,r1,i0)
719 static void _rroti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
720 # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
721 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
722 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
723 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
724 # define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
725 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
726 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
727 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
728 # define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
729 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
730 # define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
731 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
732 # define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
733 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
734 # define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
735 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
736 # define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
737 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
738 # define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
739 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
740 # define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
741 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
742 # define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
743 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
744 # define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
745 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
746 # define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
747 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
748 # define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
749 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
750 # define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
751 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
752 # define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
753 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
754 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
755 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
756 # define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
757 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
758 # define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
759 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
760 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
761 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
762 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
763 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
764 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
765 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
766 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
767 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
768 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
769 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
770 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
771 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
772 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
773 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
774 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
775 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
776 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
777 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
778 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
779 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
780 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
781 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
782 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
783 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
784 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
785 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
786 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
787 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
788 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
789 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
790 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
791 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
792 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
793 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
794 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
795 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
796 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
797 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
798 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
799 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
800 #define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
801 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
802 #define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
803 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
804 #define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
805 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
806 #define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
807 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
808 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
809 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
810 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
811 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
812 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
813 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
814 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
815 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
816 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
817 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
818 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
819 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
820 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
821 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
822 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
823 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
824 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
825 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
826 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
827 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
828 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
829 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
830 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
831 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
832 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
833 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
834 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
835 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
836 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
837 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
838 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
839 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
840 # define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
841 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
842 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
843 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
844 # define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
845 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
846 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
847 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
848 # define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
849 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
850 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
851 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
852 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
853 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
854 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
855 # define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
856 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
857 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
858 # define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
859 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
860 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
861 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
862 # define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
863 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
864 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
865 # define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
866 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
867 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
868 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
869 # if __WORDSIZE == 32
870 # define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
872 # define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
874 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
875 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
876 # define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
877 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
878 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
879 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
880 # if __WORDSIZE == 64
881 # define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
882 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
883 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
884 # define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
885 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
886 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
887 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
888 # define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
889 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
890 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
891 # define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
892 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
893 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
894 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
896 # define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
897 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
898 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
899 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
900 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
901 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
902 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
903 # define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
904 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
905 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
906 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
907 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
908 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
909 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
910 # define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
911 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
912 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
913 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
914 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
915 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
916 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
917 # if __WORDSIZE == 64
918 # define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
919 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
920 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
921 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
922 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
923 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
924 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
926 # define jmpr(r0) _jmpr(_jit,r0)
927 static void _jmpr(jit_state_t*,jit_int32_t);
928 # define jmpi(i0) _jmpi(_jit,i0)
929 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
930 # define jmpi_p(i0) _jmpi_p(_jit,i0)
931 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
933 # define callr(r0,i0) _callr(_jit,r0,i0)
934 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
935 # define calli(i0,i1) _calli(_jit,i0,i1)
936 static jit_word_t _calli(jit_state_t*,jit_word_t,jit_int32_t);
937 # define calli_p(i0,i1) _calli_p(_jit,i0,i1)
938 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
940 # define callr(r0) _callr(_jit,r0)
941 static void _callr(jit_state_t*,jit_int32_t);
942 # define calli(i0) _calli(_jit,i0)
943 static jit_word_t _calli(jit_state_t*,jit_word_t);
944 # define calli_p(i0) _calli_p(_jit,i0)
945 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
947 # define prolog(node) _prolog(_jit, node)
948 static void _prolog(jit_state_t*, jit_node_t*);
949 # define epilog(node) _epilog(_jit, node)
950 static void _epilog(jit_state_t*, jit_node_t*);
951 # define vastart(r0) _vastart(_jit, r0)
952 static void _vastart(jit_state_t*, jit_int32_t);
953 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
954 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
955 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
956 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
957 # define patch_at(i,l) _patch_at(_jit,i,l)
958 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
962 # define _u16(v) ((v) & 0xffff)
963 # define _u26(v) ((v) & 0x3ffffff)
965 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
967 assert(!(o & ~((1 << 6) - 1)));
968 assert(!(d & ~((1 << 5) - 1)));
969 assert(!(a & ~((1 << 5) - 1)));
970 assert(!(b & ~((1 << 5) - 1)));
971 assert(!(e & ~((1 << 1) - 1)));
972 assert(!(x & ~((1 << 9) - 1)));
973 assert(!(r & ~((1 << 1) - 1)));
974 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
978 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
980 assert(!(o & ~((1 << 6) - 1)));
981 assert(!(d & ~((1 << 5) - 1)));
982 assert(!(a & ~((1 << 5) - 1)));
983 assert(can_sign_extend_short_p(s));
984 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
988 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
990 assert(!(o & ~((1 << 6) - 1)));
991 assert(!(d & ~((1 << 5) - 1)));
992 assert(!(a & ~((1 << 5) - 1)));
993 assert(can_zero_extend_short_p(s));
994 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
998 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
1000 assert(!(o & ~((1 << 6) - 1)));
1001 assert(!(s & ~((1 << 5) - 1)));
1002 assert(!(a & ~((1 << 5) - 1)));
1003 assert(!(b & ~((1 << 5) - 1)));
1004 assert(!(x & ~((1 << 10) - 1)));
1005 assert(!(r & ~((1 << 1) - 1)));
1006 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
1010 _FI(jit_state_t *_jit, int o, int t, int a, int k)
1012 assert(!(o & ~(( 1 << 6) - 1)));
1013 assert(!(t & 3) && can_sign_extend_jump_p(t));
1014 assert(!(a & ~(( 1 << 1) - 1)));
1015 assert(!(k & ~(( 1 << 1) - 1)));
1016 ii((o<<26)|_u26(t)|(a<<1)|k);
1020 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
1022 assert(!( o & ~((1 << 6) - 1)));
1023 assert(!(bo & ~((1 << 5) - 1)));
1024 assert(!(bi & ~((1 << 5) - 1)));
1025 assert(!(t & 3) && can_sign_extend_short_p(t));
1026 assert(!(a & ~(( 1 << 1) - 1)));
1027 assert(!(k & ~(( 1 << 1) - 1)));
1028 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
1032 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
1034 assert(!( o & ~((1 << 6) - 1)));
1035 assert(!(bo & ~((1 << 5) - 1)));
1036 assert(!(bi & ~((1 << 5) - 1)));
1037 assert(!(x & ~(( 1 << 10) - 1)));
1038 assert(!(k & ~(( 1 << 1) - 1)));
1039 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
1043 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
1045 assert(!(o & ~((1 << 6) - 1)));
1046 assert(!(d & ~((1 << 3) - 1)));
1047 assert(!(l & ~((1 << 1) - 1)));
1048 assert(!(a & ~((1 << 5) - 1)));
1049 assert(!(b & ~((1 << 5) - 1)));
1050 assert(!(x & ~((1 << 10) - 1)));
1051 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
1055 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
1057 assert(!(o & ~((1 << 6) - 1)));
1058 assert(!(d & ~((1 << 3) - 1)));
1059 assert(!(l & ~((1 << 1) - 1)));
1060 assert(!(a & ~((1 << 5) - 1)));
1061 if (o == 11) assert(can_sign_extend_short_p(s));
1062 else if (o == 10) assert(can_zero_extend_short_p(s));
1066 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
1070 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
1072 assert(!(o & ~((1 << 6) - 1)));
1073 assert(!(d & ~((1 << 5) - 1)));
1074 assert(!(x & ~((1 << 10) - 1)));
1075 assert(!(f & ~((1 << 10) - 1)));
1076 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1080 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
1082 assert(!(o & ~((1 << 6) - 1)));
1083 assert(!(s & ~((1 << 5) - 1)));
1084 assert(!(a & ~((1 << 5) - 1)));
1085 assert(!(h & ~((1 << 5) - 1)));
1086 assert(!(b & ~((1 << 5) - 1)));
1087 assert(!(e & ~((1 << 5) - 1)));
1088 assert(!(r & ~((1 << 1) - 1)));
1089 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1092 # if __WORDSIZE == 64
1094 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1096 assert(!(o & ~((1 << 6) - 1)));
1097 assert(!(s & ~((1 << 5) - 1)));
1098 assert(!(a & ~((1 << 5) - 1)));
1099 assert(!(b & ~((1 << 5) - 1)));
1100 assert(!(e & ~((1 << 6) - 1)));
1101 assert(!(x & ~((1 << 4) - 1)));
1102 assert(!(r & ~((1 << 1) - 1)));
1103 e = (e >> 5) | ((e << 1) & 63);
1104 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1108 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1110 assert(!(o & ~((1 << 6) - 1)));
1111 assert(!(s & ~((1 << 5) - 1)));
1112 assert(!(a & ~((1 << 5) - 1)));
1113 assert(!(h & ~((1 << 5) - 1)));
1114 assert(!(e & ~((1 << 6) - 1)));
1115 assert(!(x & ~((1 << 3) - 1)));
1116 assert(!(i & ~((1 << 1) - 1)));
1117 assert(!(r & ~((1 << 1) - 1)));
1118 e = (e >> 5) | ((e << 1) & 63);
1119 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1123 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1125 assert(!(o & ~((1 << 6) - 1)));
1126 assert(!(s & ~((1 << 5) - 1)));
1127 assert(!(a & ~((1 << 5) - 1)));
1128 assert(!(h & ~((1 << 5) - 1)));
1129 assert(!(x & ~((1 << 9) - 1)));
1130 assert(!(i & ~((1 << 1) - 1)));
1131 assert(!(r & ~((1 << 1) - 1)));
1132 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1138 * Use the sequence commented at
1139 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1142 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1145 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1147 MTCRF(128, rn(reg));
1148 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1155 _nop(jit_state_t *_jit, jit_int32_t i0)
1157 for (; i0 > 0; i0 -= 4)
1163 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1170 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1172 if (can_sign_extend_short_p(i0))
1175 if (can_sign_extend_int_p(i0))
1176 LIS(r0, (jit_int16_t)(i0 >> 16));
1177 else if (can_zero_extend_int_p(i0)) {
1178 if (i0 & 0xffff0000) {
1179 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1183 # if __WORDSIZE == 64
1185 movi(r0, (jit_uint32_t)(i0 >> 32));
1186 if (i0 & 0xffff0000) {
1188 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1196 ORI(r0, r0, (jit_uint16_t)i0);
1201 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1209 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1217 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1219 jit_word_t word = _jit->pc.w;
1220 # if __WORDSIZE == 32
1221 LIS(r0, (jit_int16_t)(i0 >> 16));
1222 ORI(r0, r0, (jit_uint16_t)i0);
1224 LIS(r0, (jit_int16_t)(i0 >> 48));
1225 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1227 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1229 ORI(r0, r0, (jit_uint16_t)i0);
1235 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1236 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1238 jit_int32_t r1_reg, iscasi;
1239 jit_word_t retry, done, jump0, jump1;
1240 if ((iscasi = (r1 == _NOREG))) {
1241 r1_reg = jit_get_reg(jit_class_gpr);
1248 # if __WORDSIZE == 32
1249 LWARX(r0, _R0_REGNO, r1);
1251 LDARX(r0, _R0_REGNO, r1);
1253 jump0 = bner(_jit->pc.w, r0, r2); /* bne done r0 r2 */
1254 # if __WORDSIZE == 32
1255 STWCX_(r3, _R0_REGNO, r1);
1257 STDCX_(r3, _R0_REGNO, r1);
1260 BNE(0); /* BNE retry */
1265 EXTRWI(r0, r0, 1, CR_EQ);
1266 patch_at(jump0, done);
1267 patch_at(jump1, retry);
1269 jit_unget_reg(r1_reg);
1273 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1280 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1287 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1290 t0 = jit_get_reg(jit_class_gpr);
1291 t1 = jit_get_reg(jit_class_gpr);
1293 andr(rn(t0), rn(t0), r1);
1295 xori(rn(t1), r0, __WORDSIZE - 1);
1296 movnr(r0, rn(t1), rn(t0));
1302 _popcntr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1305 reg = jit_get_reg(jit_class_gpr);
1307 #if __WORDSIZE == 32
1308 movi(rn(reg), 0x01010101);
1310 movi(rn(reg), 0x0101010101010101);
1312 mullr(r0, r0, rn(reg));
1313 rshi_u(r0, r0, __WORDSIZE - 8);
1318 _extr(jit_state_t *_jit,
1319 jit_int32_t r0, jit_int32_t r1, jit_word_t i0 ,jit_word_t i1)
1321 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1322 if ( i1 == __WORDSIZE)
1325 # if __BYTE_ORDER == __BIG_ENDIAN
1326 i0 = __WORDSIZE - (i0 + i1);
1328 if (__WORDSIZE - (i0 + i1)) {
1329 lshi(r0, r1, __WORDSIZE - (i0 + i1));
1330 rshi(r0, r0, __WORDSIZE - i1);
1333 rshi(r0, r1, __WORDSIZE - i1);
1338 _extr_u(jit_state_t *_jit,
1339 jit_int32_t r0, jit_int32_t r1, jit_word_t i0 ,jit_word_t i1)
1341 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1342 if (i1 == __WORDSIZE)
1345 # if __BYTE_ORDER == __BIG_ENDIAN
1346 i0 = __WORDSIZE - (i0 + i1);
1348 # if __WORDSIZE == 32
1349 RLWINM(r0, r1, (32 - i0) & 0x1f, 32 - i1, 31);
1351 RLDICL(r0, r1, (64 - i0) & 0x3f, 64 - i1);
1357 _depr(jit_state_t *_jit,
1358 jit_int32_t r0, jit_int32_t r1, jit_word_t i0 ,jit_word_t i1)
1360 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
1361 if (i1 == __WORDSIZE)
1364 # if __BYTE_ORDER == __BIG_ENDIAN
1365 i0 = __WORDSIZE - (i0 + i1);
1367 #if __WORDSIZE == 32
1368 RLWIMI(r0, r1, i0, 32 - (i0 + i1), 31 - i0);
1370 RLDIMI(r0, r1, i0, 64 - (i0 + i1));
1376 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1378 jit_int32_t reg, addr_reg;
1380 /* Convert load followed by bswap to a single instruction */
1381 /* FIXME r0 and r1 do not need to be the same, only must check if
1382 * r1 was loaded in previous instruction */
1383 if (no_flag && r0 == r1) {
1384 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00022e | r0 << 21)) {
1385 /* Convert LHZX to LHBRX */
1387 LHBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1391 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0xa0000000 | r0 << 21)) {
1392 /* Convert LHZ to LHBRX */
1394 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1396 reg = jit_get_reg(jit_class_gpr);
1397 LI(rn(reg), (short)*_jit->pc.ui);
1398 LHBRX(r0, rn(reg), addr_reg);
1405 RLWIMI(r0, r0, 16, 8, 15);
1406 RLWINM(r0, r0, 24, 16, 31);
1408 RLWINM(r0, r1, 8, 16, 23);
1409 RLWIMI(r0, r1, 24, 24, 31);
1414 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_bool_t no_flag)
1416 jit_int32_t reg, addr_reg;
1418 /* Convert load followed by bswap to a single instruction */
1419 /* FIXME r0 and r1 do not need to be the same, only must check if
1420 * r1 was loaded in previous instruction */
1421 if (no_flag && r0 == r1) {
1422 if ((*(_jit->pc.ui - 1) & 0xffe007ff) == (0x7c00002e | r0 << 21)) {
1423 /* Convert LWZX to LWBRX */
1425 LWBRX(r0, (*_jit->pc.ui >> 16) & 0x1f, (*_jit->pc.ui >> 11) & 0x1f);
1429 if ((*(_jit->pc.ui - 1) & 0xffe00000) == (0x80000000 | r0 << 21)) {
1430 /* Convert LWZ to LWBRX */
1432 addr_reg = (*_jit->pc.ui >> 16) & 0x1f;
1434 reg = jit_get_reg(jit_class_gpr);
1435 LI(rn(reg), (short)*_jit->pc.ui);
1436 LWBRX(r0, rn(reg), addr_reg);
1442 reg = jit_get_reg(jit_class_gpr);
1443 ROTLWI(rn(reg), r1, 8);
1444 RLWIMI(rn(reg), r1, 24, 0, 7);
1445 RLWIMI(rn(reg), r1, 24, 16, 23);
1446 # if __WORDSIZE == 64
1447 CLRLDI(r0, rn(reg), 32);
1455 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1458 if (can_sign_extend_short_p(i0))
1460 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1461 ADDIS(r0, r1, i0 >> 16);
1463 reg = jit_get_reg(jit_class_gpr);
1465 ADD(r0, r1, rn(reg));
1471 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1474 if (can_sign_extend_short_p(i0))
1477 reg = jit_get_reg(jit_class_gpr);
1479 ADDC(r0, r1, rn(reg));
1485 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1488 reg = jit_get_reg(jit_class_gpr);
1490 ADDE(r0, r1, rn(reg));
1495 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1498 jit_word_t ni0 = -i0;
1499 if (can_sign_extend_short_p(ni0))
1501 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1502 ADDIS(r0, r1, ni0 >> 16);
1504 reg = jit_get_reg(jit_class_gpr);
1506 SUB(r0, r1, rn(reg));
1512 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1515 reg = jit_get_reg(jit_class_gpr);
1517 SUBC(r0, r1, rn(reg));
1522 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1525 reg = jit_get_reg(jit_class_gpr);
1527 SUBE(r0, r1, rn(reg));
1532 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1539 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1542 /* NOTE verified and overflow is correctly computed.
1543 * No need to check for __WORDSIZE == 32.
1544 * Documented as a 32 bit instruction. */
1545 if (can_sign_extend_short_p(i0))
1548 reg = jit_get_reg(jit_class_gpr);
1550 mulr(r0, r1, rn(reg));
1556 _hmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1559 reg = jit_get_reg(jit_class_gpr);
1561 hmulr(r0, r1, rn(reg));
1566 _hmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1569 reg = jit_get_reg(jit_class_gpr);
1571 hmulr_u(r0, r1, rn(reg));
1576 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1577 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1580 if (r0 == r2 || r0 == r3) {
1581 reg = jit_get_reg(jit_class_gpr);
1582 mullr(rn(reg), r2, r3);
1589 hmulr_u(r1, r2, r3);
1590 if (r0 == r2 || r0 == r3) {
1597 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1598 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1601 reg = jit_get_reg(jit_class_gpr);
1603 iqmulr(r0, r1, r2, rn(reg), sign);
1608 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1611 reg = jit_get_reg(jit_class_gpr);
1613 divr(r0, r1, rn(reg));
1618 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1621 reg = jit_get_reg(jit_class_gpr);
1623 divr_u(r0, r1, rn(reg));
1628 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1629 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1631 jit_int32_t sv0, rg0;
1632 jit_int32_t sv1, rg1;
1634 if (r0 == r2 || r0 == r3) {
1635 sv0 = jit_get_reg(jit_class_gpr);
1640 if (r1 == r2 || r1 == r3) {
1641 sv1 = jit_get_reg(jit_class_gpr);
1650 divr_u(rg0, r2, r3);
1664 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1665 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1668 reg = jit_get_reg(jit_class_gpr);
1670 iqdivr(r0, r1, r2, rn(reg), sign);
1675 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1678 if (r0 == r1 || r0 == r2) {
1679 reg = jit_get_reg(jit_class_gpr);
1680 divr(rn(reg), r1, r2);
1681 mulr(rn(reg), r2, rn(reg));
1682 subr(r0, r1, rn(reg));
1693 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1696 reg = jit_get_reg(jit_class_gpr);
1698 remr(r0, r1, rn(reg));
1703 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1706 if (r0 == r1 || r0 == r2) {
1707 reg = jit_get_reg(jit_class_gpr);
1708 divr_u(rn(reg), r1, r2);
1709 mulr(rn(reg), r2, rn(reg));
1710 subr(r0, r1, rn(reg));
1721 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1724 reg = jit_get_reg(jit_class_gpr);
1726 remr_u(r0, r1, rn(reg));
1730 # define is_mask(im) ((im) ? (__builtin_popcountl((im) + (1 << __builtin_ctzl(im))) <= 1) : 0)
1733 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1735 jit_int32_t reg, offt;
1736 if (can_zero_extend_short_p(i0))
1738 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1739 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1740 else if (__WORDSIZE == 32 && is_mask(i0)) {
1741 offt = __builtin_ctzl(i0);
1742 RLWINM(r0, r1, 0, 32 - offt - __builtin_popcountl(i0), 31 - offt);
1743 } else if (__WORDSIZE == 32 && is_mask(~i0)) {
1744 offt = __builtin_ctzl(~i0);
1745 RLWINM(r0, r1, 0, 32 - offt, 31 - offt - __builtin_popcountl(~i0));
1747 reg = jit_get_reg(jit_class_gpr);
1749 AND(r0, r1, rn(reg));
1755 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1758 if (can_zero_extend_short_p(i0))
1760 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1761 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1763 reg = jit_get_reg(jit_class_gpr);
1765 OR(r0, r1, rn(reg));
1771 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1774 if (can_zero_extend_short_p(i0))
1776 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1777 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1779 reg = jit_get_reg(jit_class_gpr);
1781 XOR(r0, r1, rn(reg));
1787 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1792 # if __WORDSIZE == 32
1801 _xlshr(jit_state_t *_jit, jit_bool_t sign,
1802 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1804 jit_int32_t t0, s0, t2, s2, t3, s3;
1805 jit_word_t over, zero, done, done_over;
1806 s0 = jit_get_reg(jit_class_gpr);
1808 if (r0 == r2 || r1 == r2) {
1809 s2 = jit_get_reg(jit_class_gpr);
1815 if (r0 == r3 || r1 == r3) {
1816 s3 = jit_get_reg(jit_class_gpr);
1822 rsbi(t0, t3, __WORDSIZE);
1828 zero = beqi(_jit->pc.w, t3, 0);
1829 over = beqi(_jit->pc.w, t3, __WORDSIZE);
1830 done = fallback_jmpi(_jit->pc.w);
1831 patch_at(over, _jit->pc.w);
1834 done_over = fallback_jmpi(_jit->pc.w);
1836 patch_at(zero, _jit->pc.w);
1838 rshi(r1, t2, __WORDSIZE - 1);
1841 patch_at(done, _jit->pc.w);
1842 patch_at(done_over, _jit->pc.w);
1851 _xlshi(jit_state_t *_jit, jit_bool_t sign,
1852 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1857 rshi(r1, r2, __WORDSIZE - 1);
1861 else if (i0 == __WORDSIZE) {
1866 assert((jit_uword_t)i0 <= __WORDSIZE);
1868 rshi(r1, r2, __WORDSIZE - i0);
1870 rshi_u(r1, r2, __WORDSIZE - i0);
1876 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1881 # if __WORDSIZE == 32
1890 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1895 # if __WORDSIZE == 32
1904 _xrshr(jit_state_t *_jit, jit_bool_t sign,
1905 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1907 jit_int32_t t0, s0, t2, s2, t3, s3;
1908 jit_word_t over, zero, done, done_over;
1909 s0 = jit_get_reg(jit_class_gpr);
1911 if (r0 == r2 || r1 == r2) {
1912 s2 = jit_get_reg(jit_class_gpr);
1918 if (r0 == r3 || r1 == r3) {
1919 s3 = jit_get_reg(jit_class_gpr);
1925 rsbi(t0, t3, __WORDSIZE);
1931 zero = beqi(_jit->pc.w, t3, 0);
1932 over = beqi(_jit->pc.w, t3, __WORDSIZE);
1933 done = jmpi(_jit->pc.w);
1934 patch_at(over, _jit->pc.w);
1937 rshi(r0, t2, __WORDSIZE - 1);
1940 done_over = jmpi(_jit->pc.w);
1942 patch_at(zero, _jit->pc.w);
1944 rshi(r1, t2, __WORDSIZE - 1);
1947 patch_at(done, _jit->pc.w);
1948 patch_at(done_over, _jit->pc.w);
1957 _xrshi(jit_state_t *_jit, jit_bool_t sign,
1958 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
1963 rshi(r1, r2, __WORDSIZE - 1);
1967 else if (i0 == __WORDSIZE) {
1970 rshi(r0, r2, __WORDSIZE - 1);
1975 assert((jit_uword_t)i0 <= __WORDSIZE);
1976 lshi(r1, r2, __WORDSIZE - i0);
1985 _lroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1990 # if __WORDSIZE == 32
1993 RLDICL(r0, r1, i0, 0);
1999 _rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2002 if (r0 != r1 && r0 != r2) {
2003 rsbi(r0, r2, __WORDSIZE);
2007 reg = jit_get_reg(jit_class_gpr);
2008 rsbi(rn(reg), r2, __WORDSIZE);
2009 lrotr(r0, r1, rn(reg));
2015 _rroti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2020 # if __WORDSIZE == 32
2023 RLDICL(r0, r1, 64 - i0, 0);
2029 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2033 EXTRWI(r0, r0, 1, CR_LT);
2037 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2040 if (can_sign_extend_short_p(i0))
2043 reg = jit_get_reg(jit_class_gpr);
2049 EXTRWI(r0, r0, 1, CR_LT);
2053 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2057 EXTRWI(r0, r0, 1, CR_LT);
2061 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2064 if (can_zero_extend_short_p(i0))
2067 reg = jit_get_reg(jit_class_gpr);
2073 EXTRWI(r0, r0, 1, CR_LT);
2077 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2080 CRNOT(CR_GT, CR_GT);
2082 EXTRWI(r0, r0, 1, CR_GT);
2086 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2089 if (can_sign_extend_short_p(i0))
2092 reg = jit_get_reg(jit_class_gpr);
2097 CRNOT(CR_GT, CR_GT);
2099 EXTRWI(r0, r0, 1, CR_GT);
2103 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2106 CRNOT(CR_GT, CR_GT);
2108 EXTRWI(r0, r0, 1, CR_GT);
2112 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2115 if (can_zero_extend_short_p(i0))
2118 reg = jit_get_reg(jit_class_gpr);
2123 CRNOT(CR_GT, CR_GT);
2125 EXTRWI(r0, r0, 1, CR_GT);
2129 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2133 EXTRWI(r0, r0, 1, CR_EQ);
2137 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2140 if (can_sign_extend_short_p(i0))
2142 else if (can_zero_extend_short_p(i0))
2145 reg = jit_get_reg(jit_class_gpr);
2151 EXTRWI(r0, r0, 1, CR_EQ);
2155 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2158 CRNOT(CR_LT, CR_LT);
2160 EXTRWI(r0, r0, 1, CR_LT);
2164 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2167 if (can_sign_extend_short_p(i0))
2170 reg = jit_get_reg(jit_class_gpr);
2175 CRNOT(CR_LT, CR_LT);
2177 EXTRWI(r0, r0, 1, CR_LT);
2181 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2184 CRNOT(CR_LT, CR_LT);
2186 EXTRWI(r0, r0, 1, CR_LT);
2190 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2193 if (can_zero_extend_short_p(i0))
2196 reg = jit_get_reg(jit_class_gpr);
2201 CRNOT(CR_LT, CR_LT);
2203 EXTRWI(r0, r0, 1, CR_LT);
2207 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2211 EXTRWI(r0, r0, 1, CR_GT);
2215 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2218 if (can_sign_extend_short_p(i0))
2221 reg = jit_get_reg(jit_class_gpr);
2227 EXTRWI(r0, r0, 1, CR_GT);
2231 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2235 EXTRWI(r0, r0, 1, CR_GT);
2239 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2242 if (can_zero_extend_short_p(i0))
2245 reg = jit_get_reg(jit_class_gpr);
2251 EXTRWI(r0, r0, 1, CR_GT);
2255 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2258 CRNOT(CR_EQ, CR_EQ);
2260 EXTRWI(r0, r0, 1, CR_EQ);
2264 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2267 if (can_sign_extend_short_p(i0))
2269 else if (can_zero_extend_short_p(i0))
2272 reg = jit_get_reg(jit_class_gpr);
2277 CRNOT(CR_EQ, CR_EQ);
2279 EXTRWI(r0, r0, 1, CR_EQ);
2283 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2294 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2298 if (can_sign_extend_short_p(i1))
2301 reg = jit_get_reg(jit_class_gpr);
2313 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2324 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2328 if (can_zero_extend_short_p(i1))
2331 reg = jit_get_reg(jit_class_gpr);
2343 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2354 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2358 if (can_sign_extend_short_p(i1))
2361 reg = jit_get_reg(jit_class_gpr);
2373 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2384 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2388 if (can_zero_extend_short_p(i1))
2391 reg = jit_get_reg(jit_class_gpr);
2403 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2414 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2418 if (can_sign_extend_short_p(i1))
2420 else if (can_zero_extend_short_p(i1))
2423 reg = jit_get_reg(jit_class_gpr);
2435 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2446 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2450 if (can_sign_extend_short_p(i1))
2453 reg = jit_get_reg(jit_class_gpr);
2465 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2476 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2480 if (can_zero_extend_short_p(i1))
2483 reg = jit_get_reg(jit_class_gpr);
2495 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2506 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2510 if (can_sign_extend_short_p(i1))
2513 reg = jit_get_reg(jit_class_gpr);
2525 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2536 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2540 if (can_zero_extend_short_p(i1))
2543 reg = jit_get_reg(jit_class_gpr);
2555 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2566 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2570 if (can_sign_extend_short_p(i1))
2572 else if (can_zero_extend_short_p(i1))
2575 reg = jit_get_reg(jit_class_gpr);
2587 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2591 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2592 andr(rn(reg), r0, r1);
2593 w = bnei(i0, rn(reg), 0);
2599 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2603 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2604 andi(rn(reg), r0, i1);
2605 w = bnei(i0, rn(reg), 0);
2611 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2615 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2616 andr(rn(reg), r0, r1);
2617 w = beqi(i0, rn(reg), 0);
2623 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2627 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2628 andi(rn(reg), r0, i1);
2629 w = beqi(i0, rn(reg), 0);
2635 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2642 BGT(d); /* GT = bit 1 of XER = OV */
2647 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2651 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2653 w = boaddr(i0, r0, rn(reg));
2659 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2671 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2675 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2677 w = bxaddr(i0, r0, rn(reg));
2683 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2695 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2699 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2701 w = bosubr(i0, r0, rn(reg));
2707 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2719 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2723 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2725 w = bxsubr(i0, r0, rn(reg));
2731 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2738 BEQ(d); /* EQ = bit 2 of XER = CA */
2743 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2747 if (can_sign_extend_short_p(i1)) {
2755 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2757 w = boaddr_u(i0, r0, rn(reg));
2763 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2775 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2779 if (can_sign_extend_short_p(i1)) {
2787 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2789 w = bxaddr_u(i0, r0, rn(reg));
2795 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2802 BNE(d); /* PPC uses "carry" not "borrow" */
2807 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2811 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2813 w = bosubr_u(i0, r0, rn(reg));
2819 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2831 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2835 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2837 w = bxsubr_u(i0, r0, rn(reg));
2843 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2850 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2857 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2859 ldxr_uc(r0, r1, r2);
2864 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2866 ldxi_uc(r0, r1, i0);
2871 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2876 if (can_sign_extend_short_p(i0))
2877 LBZ(r0, _R0_REGNO, i0);
2878 else if (can_sign_extend_int_p(i0)) {
2879 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2880 lo = (jit_int16_t)(i0 - (hi << 16));
2881 reg = jit_get_reg(jit_class_gpr);
2882 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2884 LBZ(r0, rn(reg), lo);
2886 if (inv) jit_unget_reg(_R0);
2889 reg = jit_get_reg(jit_class_gpr);
2891 ldr_uc(r0, rn(reg));
2897 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2900 if (r1 == _R0_REGNO) {
2901 if (r2 != _R0_REGNO)
2904 reg = jit_get_reg(jit_class_gpr);
2906 LBZX(r0, rn(reg), r2);
2915 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2920 else if (can_sign_extend_short_p(i0)) {
2921 if (r1 == _R0_REGNO) {
2922 reg = jit_get_reg(jit_class_gpr);
2924 LBZ(r0, rn(reg), i0);
2931 reg = jit_get_reg(jit_class_gpr);
2933 ldxr_uc(r0, r1, rn(reg));
2939 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2944 if (can_sign_extend_short_p(i0))
2945 LHA(r0, _R0_REGNO, i0);
2946 else if (can_sign_extend_int_p(i0)) {
2947 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2948 lo = (jit_int16_t)(i0 - (hi << 16));
2949 reg = jit_get_reg(jit_class_gpr);
2950 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2952 LHA(r0, rn(reg), lo);
2954 if (inv) jit_unget_reg(_R0);
2957 reg = jit_get_reg(jit_class_gpr);
2965 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2968 if (r1 == _R0_REGNO) {
2969 if (r2 != _R0_REGNO)
2972 reg = jit_get_reg(jit_class_gpr);
2974 LHAX(r0, rn(reg), r2);
2983 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2988 else if (can_sign_extend_short_p(i0)) {
2989 if (r1 == _R0_REGNO) {
2990 reg = jit_get_reg(jit_class_gpr);
2992 LHA(r0, rn(reg), i0);
2999 reg = jit_get_reg(jit_class_gpr);
3001 ldxr_s(r0, r1, rn(reg));
3007 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3012 if (can_sign_extend_short_p(i0))
3013 LHZ(r0, _R0_REGNO, i0);
3014 else if (can_sign_extend_int_p(i0)) {
3015 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3016 lo = (jit_int16_t)(i0 - (hi << 16));
3017 reg = jit_get_reg(jit_class_gpr);
3018 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3020 LHZ(r0, rn(reg), lo);
3022 if (inv) jit_unget_reg(_R0);
3025 reg = jit_get_reg(jit_class_gpr);
3027 ldr_us(r0, rn(reg));
3033 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3036 if (r1 == _R0_REGNO) {
3037 if (r2 != _R0_REGNO)
3040 reg = jit_get_reg(jit_class_gpr);
3042 LHZX(r0, rn(reg), r2);
3051 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3056 else if (can_sign_extend_short_p(i0)) {
3057 if (r1 == _R0_REGNO) {
3058 reg = jit_get_reg(jit_class_gpr);
3060 LHZ(r0, rn(reg), i0);
3067 reg = jit_get_reg(jit_class_gpr);
3069 ldxr_us(r0, r1, rn(reg));
3074 # if __WORDSIZE == 32
3076 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3081 if (can_sign_extend_short_p(i0))
3082 LWZ(r0, _R0_REGNO, i0);
3083 else if (can_sign_extend_int_p(i0)) {
3084 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3085 lo = (jit_int16_t)(i0 - (hi << 16));
3086 reg = jit_get_reg(jit_class_gpr);
3087 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3089 LWZ(r0, rn(reg), lo);
3091 if (inv) jit_unget_reg(_R0);
3094 reg = jit_get_reg(jit_class_gpr);
3102 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3105 if (r1 == _R0_REGNO) {
3106 if (r2 != _R0_REGNO)
3109 reg = jit_get_reg(jit_class_gpr);
3111 LWZX(r0, rn(reg), r2);
3120 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3125 else if (can_sign_extend_short_p(i0)) {
3126 if (r1 == _R0_REGNO) {
3127 reg = jit_get_reg(jit_class_gpr);
3129 LWZ(r0, rn(reg), i0);
3136 reg = jit_get_reg(jit_class_gpr);
3138 ldxr_i(r0, r1, rn(reg));
3145 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3150 if (can_sign_extend_short_p(i0) && !(i0 & 3))
3151 LWA(r0, _R0_REGNO, i0);
3152 else if (can_sign_extend_int_p(i0) && !(i0 & 3)) {
3153 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3154 lo = (jit_int16_t)(i0 - (hi << 16));
3155 reg = jit_get_reg(jit_class_gpr);
3156 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3158 LWA(r0, rn(reg), lo);
3160 if (inv) jit_unget_reg(_R0);
3163 reg = jit_get_reg(jit_class_gpr);
3171 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3174 if (r1 == _R0_REGNO) {
3175 if (r2 != _R0_REGNO)
3178 reg = jit_get_reg(jit_class_gpr);
3180 LWAX(r0, rn(reg), r2);
3189 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3194 else if (can_sign_extend_short_p(i0) && !(i0 & 3)) {
3195 if (r1 == _R0_REGNO) {
3196 reg = jit_get_reg(jit_class_gpr);
3198 LWA(r0, rn(reg), i0);
3205 reg = jit_get_reg(jit_class_gpr);
3207 ldxr_i(r0, r1, rn(reg));
3213 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3218 if (can_sign_extend_short_p(i0))
3219 LWZ(r0, _R0_REGNO, i0);
3220 else if (can_sign_extend_int_p(i0)) {
3221 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3222 lo = (jit_int16_t)(i0 - (hi << 16));
3223 reg = jit_get_reg(jit_class_gpr);
3224 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3226 LWZ(r0, rn(reg), lo);
3228 if (inv) jit_unget_reg(_R0);
3231 reg = jit_get_reg(jit_class_gpr);
3233 ldr_ui(r0, rn(reg));
3239 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3242 if (r1 == _R0_REGNO) {
3243 if (r2 != _R0_REGNO)
3246 reg = jit_get_reg(jit_class_gpr);
3248 LWZX(r0, rn(reg), r2);
3257 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3262 else if (can_sign_extend_short_p(i0)) {
3263 if (r1 == _R0_REGNO) {
3264 reg = jit_get_reg(jit_class_gpr);
3266 LWZ(r0, rn(reg), i0);
3273 reg = jit_get_reg(jit_class_gpr);
3275 ldxr_ui(r0, r1, rn(reg));
3281 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3286 if (can_sign_extend_short_p(i0) && !(i0 & 3))
3287 LD(r0, _R0_REGNO, i0);
3288 else if (can_sign_extend_int_p(i0) && !(i0 & 3)) {
3289 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3290 lo = (jit_int16_t)(i0 - (hi << 16));
3291 reg = jit_get_reg(jit_class_gpr);
3292 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3294 LD(r0, rn(reg), lo);
3296 if (inv) jit_unget_reg(_R0);
3299 reg = jit_get_reg(jit_class_gpr);
3307 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3310 if (r1 == _R0_REGNO) {
3311 if (r2 != _R0_REGNO)
3314 reg = jit_get_reg(jit_class_gpr);
3316 LDX(r0, rn(reg), r2);
3325 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3330 else if (can_sign_extend_short_p(i0) && !(i0 & 3)) {
3331 if (r1 == _R0_REGNO) {
3332 reg = jit_get_reg(jit_class_gpr);
3334 LD(r0, rn(reg), i0);
3341 reg = jit_get_reg(jit_class_gpr);
3343 ldxr_l(r0, r1, rn(reg));
3350 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3355 if (can_sign_extend_short_p(i0))
3356 STB(r0, _R0_REGNO, i0);
3357 else if (can_sign_extend_int_p(i0)) {
3358 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3359 lo = (jit_int16_t)(i0 - (hi << 16));
3360 reg = jit_get_reg(jit_class_gpr);
3361 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3363 STB(r0, rn(reg), lo);
3365 if (inv) jit_unget_reg(_R0);
3368 reg = jit_get_reg(jit_class_gpr);
3376 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3379 if (r0 == _R0_REGNO) {
3380 if (r1 != _R0_REGNO)
3383 reg = jit_get_reg(jit_class_gpr);
3385 STBX(r2, rn(reg), r1);
3394 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3399 else if (can_sign_extend_short_p(i0)) {
3400 if (r0 == _R0_REGNO) {
3401 reg = jit_get_reg(jit_class_gpr);
3403 STB(r1, rn(reg), i0);
3410 reg = jit_get_reg(jit_class_gpr);
3412 stxr_c(rn(reg), r0, r1);
3418 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3423 if (can_sign_extend_short_p(i0))
3424 STH(r0, _R0_REGNO, i0);
3425 else if (can_sign_extend_int_p(i0)) {
3426 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3427 lo = (jit_int16_t)(i0 - (hi << 16));
3428 reg = jit_get_reg(jit_class_gpr);
3429 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3431 STH(r0, rn(reg), lo);
3433 if (inv) jit_unget_reg(_R0);
3436 reg = jit_get_reg(jit_class_gpr);
3444 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3447 if (r0 == _R0_REGNO) {
3448 if (r1 != _R0_REGNO)
3451 reg = jit_get_reg(jit_class_gpr);
3453 STHX(r2, rn(reg), r1);
3462 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3467 else if (can_sign_extend_short_p(i0)) {
3468 if (r0 == _R0_REGNO) {
3469 reg = jit_get_reg(jit_class_gpr);
3471 STH(r1, rn(reg), i0);
3478 reg = jit_get_reg(jit_class_gpr);
3480 stxr_s(rn(reg), r0, r1);
3486 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3491 if (can_sign_extend_short_p(i0))
3492 STW(r0, _R0_REGNO, i0);
3493 else if (can_sign_extend_int_p(i0)) {
3494 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3495 lo = (jit_int16_t)(i0 - (hi << 16));
3496 reg = jit_get_reg(jit_class_gpr);
3497 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3499 STW(r0, rn(reg), lo);
3501 if (inv) jit_unget_reg(_R0);
3504 reg = jit_get_reg(jit_class_gpr);
3512 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3515 if (r0 == _R0_REGNO) {
3516 if (r1 != _R0_REGNO)
3519 reg = jit_get_reg(jit_class_gpr);
3521 STWX(r2, rn(reg), r1);
3530 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3535 else if (can_sign_extend_short_p(i0)) {
3536 if (r0 == _R0_REGNO) {
3537 reg = jit_get_reg(jit_class_gpr);
3539 STW(r1, rn(reg), i0);
3546 reg = jit_get_reg(jit_class_gpr);
3548 stxr_i(rn(reg), r0, r1);
3553 # if __WORDSIZE == 64
3555 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3560 if (can_sign_extend_short_p(i0) && !(i0 & 3))
3561 STD(r0, _R0_REGNO, i0);
3562 else if (can_sign_extend_int_p(i0) && !(i0 & 3)) {
3563 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3564 lo = (jit_int16_t)(i0 - (hi << 16));
3565 reg = jit_get_reg(jit_class_gpr);
3566 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3568 STD(r0, rn(reg), lo);
3570 if (inv) jit_unget_reg(_R0);
3573 reg = jit_get_reg(jit_class_gpr);
3581 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3584 if (r0 == _R0_REGNO) {
3585 if (r1 != _R0_REGNO)
3588 reg = jit_get_reg(jit_class_gpr);
3590 STDX(r2, rn(reg), r1);
3599 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3604 else if (can_sign_extend_short_p(i0) && !(i0 & 3)) {
3605 if (r0 == _R0_REGNO) {
3606 reg = jit_get_reg(jit_class_gpr);
3608 STD(r1, rn(reg), i0);
3615 reg = jit_get_reg(jit_class_gpr);
3617 stxr_l(rn(reg), r0, r1);
3624 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3635 /* pc relative jump */
3637 _jmpi(jit_state_t *_jit, jit_word_t i0)
3643 if (can_sign_extend_jump_p(d))
3646 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3647 w = movi_p(rn(reg), i0);
3656 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3660 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3661 w = movi_p(rn(reg), i0);
3668 _callr(jit_state_t *_jit, jit_int32_t r0
3670 , jit_int32_t varargs
3675 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3676 /* FIXME Pretend to not know about r11? */
3677 if (r0 == _R0_REGNO) {
3678 movr(_R11_REGNO, _R0_REGNO);
3679 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3680 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3683 ldxi(_R2_REGNO, r0, sizeof(void*));
3684 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3689 /* Tell double arguments were passed in registers. */
3693 movr(_R12_REGNO, r0);
3700 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3704 /* assume fixed address or reachable address */
3706 _calli(jit_state_t *_jit, jit_word_t i0
3708 , jit_int32_t varargs
3715 d = (i0 - _jit->pc.w - !!varargs * 4) & ~3;
3716 if (can_sign_extend_jump_p(d)) {
3717 /* Tell double arguments were passed in registers. */
3727 movi(_R12_REGNO, i0);
3739 _calli_p(jit_state_t *_jit, jit_word_t i0
3741 , jit_int32_t varargs
3746 w = movi_p(_R12_REGNO, i0);
3756 _prolog(jit_state_t *_jit, jit_node_t *node)
3761 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3762 jit_int32_t frame = -_jitc->function->frame;
3764 assert(_jitc->function->self.aoff >= frame);
3765 if (_jitc->function->assume_frame)
3767 _jitc->function->self.aoff = frame;
3769 if (_jitc->function->allocar) {
3770 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3771 _jitc->function->self.aoff &= -16;
3773 _jitc->function->stack = ((_jitc->function->self.alen +
3774 _jitc->function->self.size -
3775 _jitc->function->self.aoff) + 15) & -16;
3777 if (_jitc->function->need_frame)
3778 _jitc->function->need_stack = _jitc->function->need_return = 1;
3780 if (!_jitc->function->need_stack) {
3781 for (regno = 0; regno < jit_size(iregs); regno++) {
3782 if (jit_regset_tstbit(&_jitc->function->regset, iregs[regno])) {
3783 _jitc->function->need_stack =
3784 _jitc->function->need_return = 1;
3788 if (!_jitc->function->need_stack) {
3789 for (offset = 0; offset < jit_size(fregs); offset++) {
3790 if (jit_regset_tstbit(&_jitc->function->regset, fregs[offset])) {
3791 _jitc->function->need_stack =
3792 _jitc->function->need_return = 1;
3799 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3800 * alloca < %r31-80 */
3802 /* return address */
3803 if (_jitc->function->need_return) {
3806 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3808 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3812 if (_jitc->function->need_stack) {
3813 offset = -gpr_save_area;
3814 for (regno = 0; regno < jit_size(iregs);
3815 regno++, offset += sizeof(void*)) {
3816 if (jit_regset_tstbit(&_jitc->function->regset, iregs[regno]))
3817 stxi(offset, _SP_REGNO, rn(iregs[regno]));
3819 for (offset = 0; offset < jit_size(fregs); offset++) {
3820 if (jit_regset_tstbit(&_jitc->function->regset, fregs[offset]))
3821 stxi_d(-(gpr_save_area + 8 + offset * 8),
3822 _SP_REGNO, rn(fregs[offset]));
3826 if (_jitc->function->need_frame) {
3827 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3828 movr(_FP_REGNO, _SP_REGNO);
3830 if (_jitc->function->need_stack) {
3831 #if __WORDSIZE == 32
3832 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3834 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3838 if (_jitc->function->allocar) {
3839 regno = jit_get_reg(jit_class_gpr);
3840 movi(rn(regno), _jitc->function->self.aoff);
3841 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3842 jit_unget_reg(regno);
3846 if (_jitc->function->self.call & jit_call_varargs) {
3847 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3848 stxi(params_offset + regno * sizeof(jit_word_t),
3849 _FP_REGNO, rn(JIT_RA0 - regno));
3852 if (_jitc->function->self.call & jit_call_varargs) {
3853 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3854 stxi(_jitc->function->vaoff + first_gp_offset +
3855 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3856 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3857 stxi_d(_jitc->function->vaoff + first_fp_offset +
3858 regno * va_fp_increment, _FP_REGNO,
3859 rn(JIT_FA0 - regno));
3865 _epilog(jit_state_t *_jit, jit_node_t *node)
3870 if (_jitc->function->assume_frame)
3872 if (_jitc->function->need_stack) {
3873 if (_jitc->function->allocar)
3874 ldr(_SP_REGNO, _SP_REGNO);
3876 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3879 if (_jitc->function->need_return) {
3881 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3883 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3887 if (_jitc->function->need_stack) {
3888 offset = -gpr_save_area;
3889 for (regno = 0; regno < jit_size(iregs);
3890 regno++, offset += sizeof(void*)) {
3891 if (jit_regset_tstbit(&_jitc->function->regset, iregs[regno]))
3892 ldxi(rn(iregs[regno]), _SP_REGNO, offset);
3894 for (offset = 0; offset < 8; offset++) {
3895 if (jit_regset_tstbit(&_jitc->function->regset, fregs[offset]))
3896 ldxi_d(rn(fregs[offset]), _SP_REGNO,
3897 -(gpr_save_area + 8 + offset * 8));
3901 if (_jitc->function->need_return)
3903 if (_jitc->function->need_frame)
3904 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3910 _vastart(jit_state_t *_jit, jit_int32_t r0)
3913 assert(_jitc->function->self.call & jit_call_varargs);
3914 /* Initialize stack pointer to the first stack argument. */
3915 addi(r0, _FP_REGNO, _jitc->function->self.size);
3918 assert(_jitc->function->self.call & jit_call_varargs);
3920 /* Return jit_va_list_t in the register argument */
3921 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3922 reg = jit_get_reg(jit_class_gpr);
3924 /* Initialize the gp counter. */
3925 movi(rn(reg), _jitc->function->vagp);
3926 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3928 /* Initialize the fp counter. */
3929 movi(rn(reg), _jitc->function->vafp);
3930 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3932 /* Initialize overflow pointer to the first stack argument. */
3933 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3934 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3936 /* Initialize register save area pointer. */
3937 addi(rn(reg), r0, first_gp_offset);
3938 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3945 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3948 assert(_jitc->function->self.call & jit_call_varargs);
3949 /* Load argument. */
3951 /* Update va_list. */
3952 addi(r1, r1, sizeof(jit_word_t));
3959 assert(_jitc->function->self.call & jit_call_varargs);
3961 rg0 = jit_get_reg(jit_class_gpr);
3962 rg1 = jit_get_reg(jit_class_gpr);
3964 /* Load the gp offset in save area in the first temporary. */
3965 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3967 /* Jump over if there are no remaining arguments in the save area. */
3968 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3970 /* Update the gp counter. */
3971 addi(rn(rg1), rn(rg0), 1);
3972 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3974 /* Load the save area pointer in the second temporary. */
3975 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3977 /* Load the vararg argument in the first argument. */
3978 lshi(rn(rg0), rn(rg0), va_gp_shift);
3979 ldxr(r0, rn(rg1), rn(rg0));
3981 /* Will only need one temporary register below. */
3984 /* Jump over overflow code. */
3985 lt_code = _jit->pc.w;
3988 /* Where to land if argument is in overflow area. */
3989 patch_at(ge_code, _jit->pc.w);
3991 /* Load overflow pointer. */
3992 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3994 /* Load argument. */
3997 /* Update overflow pointer. */
3998 addi(rn(rg0), rn(rg0), va_gp_increment);
3999 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
4001 /* Where to land if argument is in save area. */
4002 patch_at(lt_code, _jit->pc.w);
4009 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
4012 assert(_jitc->function->self.call & jit_call_varargs);
4013 /* Load argument. */
4015 /* Update va_list. */
4016 addi(r1, r1, sizeof(jit_float64_t));
4023 assert(_jitc->function->self.call & jit_call_varargs);
4025 rg0 = jit_get_reg(jit_class_gpr);
4026 rg1 = jit_get_reg(jit_class_gpr);
4028 /* Load the fp offset in save area in the first temporary. */
4029 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
4031 /* Jump over if there are no remaining arguments in the save area. */
4032 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
4034 /* Update the fp counter. */
4035 addi(rn(rg1), rn(rg0), 1);
4036 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
4038 /* Load the save area pointer in the second temporary. */
4039 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
4041 /* Load the vararg argument in the first argument. */
4042 lshi(rn(rg0), rn(rg0), 3);
4043 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
4044 offsetof(jit_va_list_t, first_gp_argument));
4045 ldxr_d(r0, rn(rg1), rn(rg0));
4047 /* Jump over overflow code. */
4048 lt_code = _jit->pc.w;
4051 /* Where to land if argument is in overflow area. */
4052 patch_at(ge_code, _jit->pc.w);
4054 /* Load overflow pointer. */
4055 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
4057 # if __WORDSIZE == 32
4058 /* Align if required. */
4059 andi(rn(rg1), rn(rg0), 7);
4060 addr(rn(rg0), rn(rg0), rn(rg1));
4063 /* Load argument. */
4066 /* Update overflow pointer. */
4067 addi(rn(rg0), rn(rg0), va_fp_increment);
4068 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
4070 /* Where to land if argument is in save area. */
4071 patch_at(lt_code, _jit->pc.w);
4079 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
4087 switch ((u.i[0] & 0xfc000000) >> 26) {
4091 if (!can_sign_extend_short_p(d)) {
4092 /* use absolute address */
4093 assert(can_sign_extend_short_p(label));
4096 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
4100 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
4101 /* zero is used for toc and env, so, quick check
4102 * if this is a "jmpi main" like initial jit
4104 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
4105 for (d = 0; d < _jitc->prolog.offset; d++) {
4106 /* not so pretty, but hides powerpc
4107 * specific abi intrinsics and/or
4108 * implementation from user */
4109 if (_jitc->prolog.ptr[d] == label) {
4110 label += sizeof(void*) * 3;
4119 if (!can_sign_extend_jump_p(d)) {
4120 /* use absolute address */
4121 assert(can_sign_extend_jump_p(label));
4124 u.i[0] = (u.i[0] & ~0x3fffffc) | (d & 0x3fffffd);
4127 #if __WORDSIZE == 32
4128 # define MTCTR_OFF 2
4131 # define MTCTR_OFF 6
4135 /* movi reg label; jmpr reg */
4138 /* check for MLTR(reg) */
4139 (u.i[MTCTR_OFF] >> 26) == 31 &&
4140 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
4141 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
4143 u.i[BCTR_OFF] == 0x4e800020) {
4145 /* check for MTCTR(reg) */
4146 (u.i[MTCTR_OFF] >> 26) == 31 &&
4147 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
4148 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
4149 /* check for BCTR */
4150 u.i[BCTR_OFF] == 0x4e800420) {
4152 /* zero is used for toc and env, so, quick check
4153 * if this is a "jmpi main" like initial jit
4155 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
4156 for (d = 0; d < _jitc->prolog.offset; d++) {
4157 /* not so pretty, but hides powerpc
4158 * specific abi intrinsics and/or
4159 * implementation from user */
4160 if (_jitc->prolog.ptr[d] == label) {
4161 label += sizeof(void*) * 3;
4170 #if __WORDSIZE == 32
4171 assert(!(u.i[0] & 0x1f0000));
4172 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
4173 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
4174 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
4175 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
4177 assert(!(u.i[0] & 0x1f0000));
4178 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
4179 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
4180 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
4181 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
4182 /* not fully validating SLDI */
4183 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
4184 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
4185 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
4186 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
4187 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
4188 /* not fully validating SLDI */
4189 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
4190 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
4191 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
4192 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
4193 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
4197 assert(!"unhandled branch opcode");