1 /*
2 * Copyright (C) 2012-2019 Free Software Foundation, Inc.
3 *
4 * This file is part of GNU lightning.
5 *
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)
9 * any later version.
10 *
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.
15 *
16 * Authors:
17 * Paulo Cesar Pereira de Andrade
18 */
19
20 #if PROTO
21 # if __WORDSIZE == 32
22 # define gpr_save_area 72 /* r14~r31 = 18 * 4 */
23 # if _CALL_SYSV
24 # define params_offset (sizeof(jit_word_t) << 1)
25 # else
26 # define params_offset 24
27 # endif
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
31 # else
32 # define gpr_save_area 144 /* r14~r31 = 18 * 8 */
33 # if _CALL_ELF == 2
34 # define params_offset 32
35 # else
36 # define params_offset 48
37 # endif
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)
44 # endif
45 # define fpr_save_area 64
46 # define alloca_offset -(gpr_save_area + fpr_save_area)
47 # define ii(i) *_jit->pc.ui++ = i
48 # if __WORDSIZE == 32
49 # define iw(i) *_jit->pc.ui++ = i
50 # else
51 # define iw(i) *_jit->pc.ul++ = i
52 # endif
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)
56 # define _R0_REGNO 0
57 # define _SP_REGNO 1
58 # define _R2_REGNO 2
59 # define _R11_REGNO 11
60 # define _R12_REGNO 12
61 # define _FP_REGNO 31
62 # if __WORDSIZE == 32
63 # define ldr(r0,r1) ldr_i(r0,r1)
64 # define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0)
65 # define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2)
66 # define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
67 # define stxr(r0,r1,r2) stxr_i(r0,r1,r2)
68 # else
69 # define ldr(r0,r1) ldr_l(r0,r1)
70 # define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0)
71 # define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2)
72 # define stxi(i0,r0,r1) stxi_l(i0,r0,r1)
73 # define stxr(r0,r1,r2) stxr_l(r0,r1,r2)
74 # endif
75 # define FXO(o,d,a,b,e,x) _FXO(_jit,o,d,a,b,e,x,0)
76 # define FXO_(o,d,a,b,e,x) _FXO(_jit,o,d,a,b,e,x,1)
77 static void _FXO(jit_state_t*,int,int,int,int,int,int,int);
78 # define FDs(o,d,a,s) _FDs(_jit,o,d,a,s)
79 static void _FDs(jit_state_t*,int,int,int,int);
80 # define FDu(o,d,a,s) _FDu(_jit,o,d,a,s)
81 static void _FDu(jit_state_t*,int,int,int,int);
82 # define FX(o,d,a,b,x) _FX(_jit,o,d,a,b,x,0)
83 # define FX_(o,d,a,b,x) _FX(_jit,o,d,a,b,x,1)
84 static void _FX(jit_state_t*,int,int,int,int,int,int);
85 # define FI(o,t,a,k) _FI(_jit,o,t,a,k)
86 static void _FI(jit_state_t*,int,int,int,int);
87 # define FB(o,bo,bi,t,a,k) _FB(_jit,o,bo,bi,t,a,k)
88 static void _FB(jit_state_t*,int,int,int,int,int,int);
89 # define FXL(o,bo,bi,x) _FXL(_jit,o,bo,bi,x,0)
90 # define FXL_(o,bo,bi,x) _FXL(_jit,o,bo,bi,x,1)
91 static void _FXL(jit_state_t*,int,int,int,int,int);
92 # define FC(o,d,l,a,b,x) _FC(_jit,o,d,l,a,b,x)
93 static void _FC(jit_state_t*,int,int,int,int,int,int);
94 # define FCI(o,d,l,a,s) _FCI(_jit,o,d,l,a,s)
95 static void _FCI(jit_state_t*,int,int,int,int,int);
96 # define FXFX(o,s,x,f) _FXFX(_jit,o,s,x,f)
97 static void _FXFX(jit_state_t*,int,int,int,int);
98 # define FM(o,s,a,h,b,e,r) _FM(_jit,o,s,a,h,b,e,r)
99 static void _FM(jit_state_t*,int,int,int,int,int,int,int);
100 # if __WORDSIZE == 64
101 # define FMDS(o,s,a,b,e,x) _FMDS(_jit,o,s,a,b,e,x,0)
102 # define FMDS_(o,s,a,b,e,x) _FMDS(_jit,o,s,a,b,e,x,1)
103 static void _FMDS(jit_state_t*,int,int,int,int,int,int,int);
104 # define FMD(o,s,a,h,b,x,i) _FMD(_jit,o,s,a,h,b,x,i,0)
105 # define FMD_(o,s,a,h,b,x,i) _FMD(_jit,o,s,a,h,b,x,i,1)
106 static void _FMD(jit_state_t*,int,int,int,int,int,int,int,int);
107 # define FXS(o,d,a,h,x,i) _FXS(_jit,o,d,a,h,x,i,0)
108 # define FXS_(o,d,a,h,x,i) _FXS(_jit,o,d,a,h,x,i,1)
109 static void _FXS(jit_state_t*,int,int,int,int,int,int,int);
110 # endif
111 # define CR_0 0
112 # define CR_1 1
113 # define CR_2 2
114 # define CR_3 3
115 # define CR_4 4
116 # define CR_5 5
117 # define CR_6 6
118 # define CR_7 7
119 # define CR_LT 0
120 # define CR_GT 1
121 # define CR_EQ 2
122 # define CR_SO 3
123 # define CR_UN 3
124 # define BCC_F 4
125 # define BCC_T 12
126 # define ADD(d,a,b) FXO(31,d,a,b,0,266)
127 # define ADD_(d,a,b) FXO_(31,d,a,b,0,266)
128 # define ADDO(d,a,b) FXO(31,d,a,b,1,266)
129 # define ADDO_(d,a,b) FXO_(31,d,a,b,1,266)
130 # define ADDC(d,a,b) FXO_(31,d,a,b,0,10)
131 # define ADDC_(d,a,b) FXO_(31,d,a,b,0,10)
132 # define ADDCO(d,a,b) FXO(31,d,a,b,1,10)
133 # define ADDCO_(d,a,b) FXO_(31,d,a,b,1,10)
134 # define ADDE(d,a,b) FXO(31,d,a,b,0,138)
135 # define ADDE_(d,a,b) FXO_(31,d,a,b,0,138)
136 # define ADDEO(d,a,b) FXO(31,d,a,b,1,138)
137 # define ADDEO_(d,a,b) FXO_(31,d,a,b,1,138)
138 # define ADDI(d,a,s) FDs(14,d,a,s)
139 # define ADDIC(d,a,s) FDs(12,d,a,s)
140 # define ADDIC_(d,a,s) FDs(13,d,a,s)
141 # define ADDIS(d,a,s) FDs(15,d,a,s)
142 # define LIS(d,s) ADDIS(d,0,s)
143 # define ADDME(d,a) FXO(31,d,a,0,0,234)
144 # define ADDME_(d,a) FXO_(31,d,a,0,0,234)
145 # define ADDMEO(d,a) FXO(31,d,a,0,1,234)
146 # define ADDMEO_(d,a) FXO_(31,d,a,0,1,234)
147 # define ADDZE(d,a) FXO(31,d,a,0,0,202)
148 # define ADDZE_(d,a) FXO_(31,d,a,0,0,202)
149 # define ADDZEO(d,a) FXO(31,d,a,0,1,202)
150 # define ADDZEO_(d,a) FXO_(31,d,a,0,1,202)
151 # define AND(d,a,b) FX(31,a,d,b,28)
152 # define ANDC(d,a,b) FXO(31,a,d,b,0,60)
153 # define ANDC_(d,a,b) FXO_(31,a,d,b,0,60)
154 # define AND_(d,a,b) FX_(31,a,b,d,28)
155 # define ANDI_(d,a,u) FDu(28,a,d,u)
156 # define ANDIS_(d,a,u) FDu(29,a,d,u)
157 # define B(t) FI(18,t,0,0)
158 # define BA(t) FI(18,t,1,0)
159 # define BL(t) FI(18,t,0,1)
160 # define BLA(t) FI(18,t,1,1)
161 # define BC(o,i,t) FB(16,o,i,t,0,0)
162 # define BCA(o,i,t) FB(16,o,i,t,1,0)
163 # define BCL(o,i,t) FB(16,o,i,t,0,1)
164 # define BCLA(o,i,t) FB(16,o,i,t,1,1)
165 # define BLT(t) BC(BCC_T,CR_LT,t)
166 # define BLE(t) BC(BCC_F,CR_GT,t)
167 # define BEQ(t) BC(BCC_T,CR_EQ,t)
168 # define BGE(t) BC(BCC_F,CR_LT,t)
169 # define BGT(t) BC(BCC_T,CR_GT,t)
170 # define BNE(t) BC(BCC_F,CR_EQ,t)
171 # define BUN(t) BC(BCC_T,CR_UN,t)
172 # define BNU(t) BC(BCC_F,CR_UN,t)
173 # define BCCTR(o,i) FXL(19,o,i,528)
174 # define BCCTRL(o,i) FXL_(19,o,i,528)
175 # define BLTCTR() BCCTR(BCC_T,CR_LT)
176 # define BLECTR() BCCTR(BCC_F,CR_GT)
177 # define BEQCTR() BCCTR(BCC_T,CR_EQ)
178 # define BGECTR() BCCTR(BCC_F,CR_LT)
179 # define BGTCTR() BCCTR(BCC_T,CR_GT)
180 # define BNECTR() BCCTR(BCC_F,CR_EQ)
181 # define BCTR() BCCTR(20,0)
182 # define BCTRL() BCCTRL(20,0)
183 # define BCLR(o,i) FXL(19,o,i,16)
184 # define BCLRL(o,i) FXL_(19,o,i,16)
185 # define BLTLR() BCLR(BCC_T,CR_LT)
186 # define BLELR() BCLR(BCC_F,CR_GT)
187 # define BEQLR() BCLR(BCC_T,CR_EQ)
188 # define BGELR() BCLR(BCC_F,CR_LT)
189 # define BGTLR() BCLR(BCC_T,CR_GT)
190 # define BNELR() BCLR(BCC_F,CR_EQ)
191 # define BLR() BCLR(20,0)
192 # define BLRL() BCLRL(20,0)
193 # define XCMP(cr,l,a,b) FC(31,cr,l,a,b,0)
194 # define CMPD(a,b) XCMP(0,1,a,b)
195 # define CMPW(a,b) XCMP(0,0,a,b)
196 # define XCMPI(cr,l,a,s) FCI(11,cr,l,a,s)
197 # define CMPDI(a,s) XCMPI(0,1,a,s)
198 # define CMPWI(a,s) XCMPI(0,0,a,s)
199 # define XCMPL(cr,l,a,b) FC(31,cr,l,a,b,32)
200 # define CMPLD(a,b) XCMPL(0,1,a,b)
201 # define CMPLW(a,b) XCMPL(0,0,a,b)
202 # define XCMPLI(cr,l,a,u) FCI(10,cr,l,a,u)
203 # define CMPLDI(a,s) XCMPLI(0,1,a,s)
204 # define CMPLWI(a,s) XCMPLI(0,0,a,s)
205 # define CNTLZW(a,s) FX(31,s,a,0,26)
206 # define CNTLZW_(a,s) FX_(31,s,a,0,26)
207 # define CRAND(d,a,b) FX(19,d,a,b,257)
208 # define CRANDC(d,a,b) FX(19,d,a,b,129)
209 # define CREQV(d,a,b) FX(19,d,a,b,289)
210 # define CRSET(d) CREQV(d,d,d)
211 # define CRNAND(d,a,b) FX(19,d,a,b,225)
212 # define CRNOR(d,a,b) FX(19,d,a,b,33)
213 # define CRNOT(d,a) CRNOR(d,a,a)
214 # define CROR(d,a,b) FX(19,d,a,b,449)
215 # define CRMOVE(d,a) CROR(d,a,a)
216 # define CRORC(d,a,b) FX(19,d,a,b,417)
217 # define CRXOR(d,a,b) FX(19,d,a,b,193)
218 # define CRCLR(d) CRXOR(d,d,d)
219 # define DCBA(a,b) FX(31,0,a,b,758)
220 # define DCBF(a,b) FX(31,0,a,b,86)
221 # define DCBI(a,b) FX(31,0,a,b,470)
222 # define DCBST(a,b) FX(31,0,a,b,54)
223 # define DCBT(a,b) FX(31,0,a,b,278)
224 # define DCBTST(a,b) FX(31,0,a,b,246)
225 # define DCBZ(a,b) FX(31,0,a,b,1014)
226 # define DIVW(d,a,b) FXO(31,d,a,b,0,491)
227 # define DIVW_(d,a,b) FXO_(31,d,a,b,0,491)
228 # define DIVWO(d,a,b) FXO(31,d,a,b,1,491)
229 # define DIVWO_(d,a,b) FXO_(31,d,a,b,1,491)
230 # define DIVWU(d,a,b) FXO(31,d,a,b,0,459)
231 # define DIVWU_(d,a,b) FXO_(31,d,a,b,0,459)
232 # define DIVWUO(d,a,b) FXO(31,d,a,b,1,459)
233 # define DIVWUO_(d,a,b) FXO_(31,d,a,b,1,459)
234 # define DIVD(d,a,b) FXO(31,d,a,b,0,489)
235 # define DIVD_(d,a,b) FXO_(31,d,a,b,0,489)
236 # define DIVDO(d,a,b) FXO(31,d,a,b,1,489)
237 # define DIVDO_(d,a,b) FXO_(31,d,a,b,1,489)
238 # define DIVDU(d,a,b) FXO(31,d,a,b,0,457)
239 # define DIVDU_(d,a,b) FXO_(31,d,a,b,0,457)
240 # define DIVDUO(d,a,b) FXO(31,d,a,b,1,457)
241 # define DIVDUO_(d,a,b) FXO_(31,d,a,b,1,457)
242 # define ECIWX(d,a,b) FX(31,d,a,b,310)
243 # define ECOWX(s,a,b) FX(31,s,a,b,438)
244 # define EIEIO() FX(31,0,0,0,854)
245 # define EQV(d,a,b) FX(31,a,d,b,284)
246 # define EQV_(d,a,b) FX_(31,a,d,b,284)
247 # define EXTSB(d,a) FX(31,a,d,0,954)
248 # define EXTSB_(d,a) FX_(31,a,d,0,954)
249 # define EXTSH(d,a) FX(31,a,d,0,922)
250 # define EXTSH_(d,a) FX_(31,a,d,0,922)
251 # define EXTSW(d,a) FX(31,a,d,0,986)
252 # define EXTSW_(d,a) FX_(31,a,d,0,986)
253 # define ICIB(a,b) FX(31,0,a,b,982)
254 # define ISYNC() FXL(19,0,0,150)
255 # define LBZ(d,a,s) FDs(34,d,a,s)
256 # define LBZU(d,a,s) FDs(35,d,a,s)
257 # define LBZUX(d,a,b) FX(31,d,a,b,119)
258 # define LBZX(d,a,b) FX(31,d,a,b,87)
259 # define LHA(d,a,s) FDs(42,d,a,s)
260 # define LHAU(d,a,s) FDs(43,d,a,s)
261 # define LHAUX(d,a,b) FX(31,d,a,b,375)
262 # define LHAX(d,a,b) FX(31,d,a,b,343)
263 # define LHRBX(d,a,b) FX(31,d,a,b,790)
264 # define LHZ(d,a,s) FDs(40,d,a,s)
265 # define LHZU(d,a,s) FDs(41,d,a,s)
266 # define LHZUX(d,a,b) FX(31,d,a,b,311)
267 # define LHZX(d,a,b) FX(31,d,a,b,279)
268 # define LA(d,a,s) ADDI(d,a,s)
269 # define LI(d,s) ADDI(d,0,s)
270 # define LMW(d,a,s) FDs(46,d,a,s)
271 # define LSWI(d,a,n) FX(31,d,a,n,597)
272 # define LSWX(d,a,b) FX(31,d,a,b,533)
273 # define LWARX(d,a,b) FX(31,d,a,b,20)
274 # define LWBRX(d,a,b) FX(31,d,a,b,534)
275 # define LWA(d,a,s) FDs(58,d,a,s|2)
276 # define LWAUX(d,a,b) FX(31,d,a,b,373)
277 # define LWAX(d,a,b) FX(31,d,a,b,341)
278 # define LWZ(d,a,s) FDs(32,d,a,s)
279 # define LWZU(d,a,s) FDs(33,d,a,s)
280 # define LWZUX(d,a,b) FX(31,d,a,b,55)
281 # define LWZX(d,a,b) FX(31,d,a,b,23)
282 # define LD(d,a,s) FDs(58,d,a,s)
283 # define LDX(d,a,b) FX(31,d,a,b,21)
284 # define MCRF(d,s) FXL(19,d<<2,(s)<<2,0)
285 # if DEBUG
286 /* In case instruction is emulated, check the kernel can handle it.
287 Will only generate it if DEBUG is enabled.
288 """
289 Chapter 6. Optional Facilities and Instructions that are being
290 Phased Out of the Architecture
291 ...
292 6.1 Move To Condition Register from XER
293 The mcrxr instruction is being phased out of the archi-
294 tecture. Its description is included here as an aid to
295 constructing operating system code to emulate it.
296
297 Move to Condition Register from XER
298 X-form
299 mcrxr BF
300 31 BF // /// /// 512 /
301 0 6 9 11 16 21 31
302 CR(4xBF:4xBF+3) <- XER(32:35)
303 XER(32:35) <- 0b0000
304 The contents of XER(32:35) are copied to Condition Reg-
305 ister field BF. XER(32:35) are set to zero.
306 Special Registers Altered:
307 CR field BF XER(32:35)
308
309 Programming Note
310 Warning: This instruction has been phased out of
311 the architecture. Attempting to execute this
312 instruction will cause the system illegal instruction
313 error handler to be invoked
314 """
315 */
316 # define MCRXR(d) FX(31,d<<2,0,0,512)
317 # else
318 # define MCRXR(cr) _MCRXR(_jit,cr);
319 static void _MCRXR(jit_state_t*, jit_int32_t);
320 # endif
321 # define MFCR(d) FX(31,d,0,0,19)
322 # define MFMSR(d) FX(31,d,0,0,83)
323 # define MFSPR(d,s) FXFX(31,d,s<<5,339)
324 # define MFXER(d) MFSPR(d,1)
325 # define MFLR(d) MFSPR(d,8)
326 # define MFCTR(d) MFSPR(d,9)
327 # define MFSR(d,s) FX(31,d,s,0,595)
328 # define MFSRIN(d,b) FX(31,d,0,b,659)
329 # define MFTB(d,x,y) FXFX(31,d,(x)|((y)<<5),371)
330 # define MFTBL(d) MFTB(d,8,12)
331 # define MFTBU(d) MFTB(d,8,13)
332 # define MTCRF(c,s) FXFX(31,s,c<<1,144)
333 # define MTCR(s) MTCRF(0xff,s)
334 # define MTMSR(s) FX(31,s,0,0,146)
335 # define MTSPR(d,s) FXFX(31,d,s<<5,467)
336 # define MTXER(d) MTSPR(d,1)
337 # define MTLR(d) MTSPR(d,8)
338 # define MTCTR(d) MTSPR(d,9)
339 # define MTSR(r,s) FX(31,s<<1,r,0,210)
340 # define MTSRIN(r,b) FX(31,r<<1,0,b,242)
341 # define MULLI(d,a,s) FDs(07,d,a,s)
342 # define MULHW(d,a,b) FXO(31,d,a,b,0,75)
343 # define MULHW_(d,a,b) FXO_(31,d,a,b,0,75)
344 # define MULHWU(d,a,b) FXO(31,d,a,b,0,11)
345 # define MULHWU_(d,a,b) FXO_(31,d,a,b,0,11)
346 # define MULLW(d,a,b) FXO(31,d,a,b,0,235)
347 # define MULLW_(d,a,b) FXO_(31,d,a,b,0,235)
348 # define MULLWO(d,a,b) FXO(31,d,a,b,1,235)
349 # define MULLWO_(d,a,b) FXO_(31,d,a,b,1,235)
350 # define MULHD(d,a,b) FXO(31,d,a,b,0,73)
351 # define MULHD_(d,a,b) FXO_(31,d,a,b,0,73)
352 # define MULHDU(d,a,b) FXO(31,d,a,b,0,9)
353 # define MULHDU_(d,a,b) FXO_(31,d,a,b,0,9)
354 # define MULLD(d,a,b) FXO(31,d,a,b,0,233)
355 # define MULLD_(d,a,b) FXO_(31,d,a,b,0,233)
356 # define MULLDO(d,a,b) FXO(31,d,a,b,1,233)
357 # define MULLDO_(d,a,b) FXO_(31,d,a,b,1,233)
358 # define NAND(d,a,b) FX(31,a,d,b,476)
359 # define NAND_(d,a,b) FX_(31,a,d,b,476)
360 # define NEG(d,a) FXO(31,d,a,0,0,104)
361 # define NEG_(d,a) FXO_(31,d,a,0,0,104)
362 # define NEGO(d,a) FXO(31,d,a,0,1,104)
363 # define NEGO_(d,a) FXO_(31,d,a,0,1,104)
364 # define NOR(d,a,b) FX(31,a,d,b,124)
365 # define NOR_(d,a,b) FX_(31,a,d,b,124)
366 # define NOT(d,s) NOR(d,s,s)
367 # define OR(d,a,b) FX(31,a,d,b,444)
368 # define OR_(d,a,b) FX_(31,a,d,b,444)
369 # define MR(d,a) OR(d,a,a)
370 # define ORC(d,a,b) FX(31,a,d,b,412)
371 # define ORC_(d,a,b) FX_(31,a,d,b,412)
372 # define ORI(d,a,u) FDu(24,a,d,u)
373 # define NOP() ORI(0,0,0)
374 # define ORIS(d,a,u) FDu(25,a,d,u)
375 # define RFI() FXL(19,0,0,50)
376 # define RLWIMI(d,s,h,b,e) FM(20,s,d,h,b,e,0)
377 # define RLWIMI_(d,s,h,b,e) FM(20,s,d,h,b,e,1)
378 # define INSLWI(a,s,n,b) RLWIMI(a,s,32-b,b,b+n-1)
379 # define INSRWI(a,s,n,b) RLWIMI(a,s,32-(b+n),b,(b+n)-1)
380 # define RLWINM(a,s,h,b,e) FM(21,s,a,h,b,e,0)
381 # define RLWINM_(a,s,h,b,e) FM(21,s,a,h,b,e,1)
382 # define EXTLWI(a,s,n,b) RLWINM(a,s,b,0,n-1)
383 # define EXTRWI(a,s,n,b) RLWINM(a,s,b+n,32-n,31)
384 # define ROTLWI(a,s,n) RLWINM(a,s,n,0,31)
385 # define ROTRWI(a,s,n) RLWINM(a,s,32-n,0,31)
386 # define SLWI(a,s,n) RLWINM(a,s,n,0,31-n)
387 # define SRWI(a,s,n) RLWINM(a,s,32-n,n,31)
388 # define CLRLWI(a,s,n) RLWINM(a,s,0,n,31)
389 # define CLRRWI(a,s,n) RLWINM(a,s,0,0,31-n)
390 # define CLRLSWI(a,s,b,n) RLWINM(a,s,n,b-n,31-n)
391 # define RLWNM(a,s,b,m,e) FM(23,s,a,b,m,e,0)
392 # define RLWNM_(a,s,b,m,e) FM(23,s,a,b,m,e,1)
393 # define ROTLW(a,s,b) RLWNM(a,s,b,0,31)
394 # define SC() FDu(17,0,0,2)
395 # define SLW(a,s,b) FX(31,s,a,b,24)
396 # define SLW_(a,s,b) FX_(31,s,a,b,24)
397 # define SRAW(a,s,b) FX(31,s,a,b,792)
398 # define SRAW_(a,s,b) FX_(31,s,a,b,792)
399 # define SRAWI(a,s,h) FX(31,s,a,h,824)
400 # define SRAWI_(a,s,h) FX_(31,s,a,h,824)
401 # define SRW(a,s,b) FX(31,s,a,b,536)
402 # define SRW_(a,s,b) FX_(31,s,a,b,536)
403 # if __WORDSIZE == 64
404 # define RLDICL(a,s,h,b) FMD(30,s,a,h&~32,b,0,h>>5)
405 # define RLDICL_(a,s,h,b) FMD_(30,s,a,h&~32,b,0,h>>5)
406 # define EXTRDI(x,y,n,b) RLDICL(x,y,(b+n),(64-n))
407 # define SRDI(x,y,n) RLDICL(x,y,(64-n),n)
408 # define CLRLDI(x,y,n) RLDICL(x,y,0,n)
409 # define RLDICR(a,s,h,e) FMD(30,s,a,h&~32,e,1,h>>5)
410 # define RLDICR_(a,s,h,e) FMD_(30,s,a,h&~32,e,1,h>>5)
411 # define EXTRLI(x,y,n,b) RLDICR(x,y,b,(n-1))
412 # define SLDI(x,y,n) RLDICR(x,y,n,(63-n))
413 # define CLRRDI(x,y,n) RLDICR(x,y,0,(63-n))
414 # define RLDIC(a,s,h,b) FMD(30,s,a,h&~32,b,2,h>>5)
415 # define RLDIC_(a,s,h,b) FMD_(30,s,a,h&~32,b,2,h>>5)
416 # define CLRLSLDI(x,y,b,n) RLDIC(x,y,n,(b-n))
417 # define RLDCL(a,s,h,b) FMDS(30,s,a,h,b,8)
418 # define RLDCL_(a,s,h,b) FMDS_(30,s,a,h,b,8)
419 # define ROTLD(x,y,z) RLDCL(x,y,z,0)
420 # define RLDCR(a,s,b,e) FMDS(30,s,a,b,e,0)
421 # define RLDCR_(a,s,b,e) FMDS_(30,s,a,b,e,0)
422 # define RLDIMI(a,s,h,b) FMD(30,s,a,h&~32,b,3,h>>5)
423 # define RLDIMI_(a,s,h,b) FMD_(30,s,a,h&~32,b,3,h>>5)
424 # define INSRDI(x,y,n,b) RLDIMI(x,y,(64-(b+n)),b)
425 # define SLD(a,s,b) FX(31,s,a,b,27)
426 # define SLD_(a,s,b) FX_(31,s,a,b,27)
427 # define SRD(a,s,b) FX(31,s,a,b,539)
428 # define SRD_(a,s,b) FX_(31,s,a,b,539)
429 # define SRADI(a,s,h) FXS(31,s,a,h&~32,413,h>>5)
430 # define SRADI_(a,s,h) FXS_(31,s,a,h&~32,413,h>>5)
431 # define SRAD(a,s,b) FX(31,s,a,b,794)
432 # define SRAD_(a,s,b) FX_(31,s,a,b,794)
433 # endif
434 # define STB(s,a,d) FDs(38,s,a,d)
435 # define STBU(s,a,d) FDs(39,s,a,d)
436 # define STBUX(s,a,b) FX(31,s,a,b,247)
437 # define STBX(s,a,b) FX(31,s,a,b,215)
438 # define STH(s,a,d) FDs(44,s,a,d)
439 # define STHBRX(s,a,b) FX(31,s,a,b,918)
440 # define STHU(s,a,d) FDs(45,s,a,d)
441 # define STHUX(s,a,b) FX(31,s,a,b,439)
442 # define STHX(s,a,b) FX(31,s,a,b,407)
443 # define STMW(s,a,d) FDs(47,s,a,d)
444 # define STWSI(s,a,nb) FX(31,s,a,nb,725)
445 # define STSWX(s,a,b) FX(31,s,a,b,661)
446 # define STW(s,a,d) FDs(36,s,a,d)
447 # define STWBRX(s,a,b) FX(31,s,a,b,662)
448 # define STWCX_(s,a,b) FX_(31,s,a,b,150)
449 # define STWU(s,a,d) FDs(37,s,a,d)
450 # define STWUX(s,a,b) FX(31,s,a,b,183)
451 # define STWX(s,a,b) FX(31,s,a,b,151)
452 # define STD(s,a,d) FDs(62,s,a,d)
453 # define STDX(s,a,b) FX(31,s,a,b,149)
454 # define STDU(s,a,d) FDs(62,s,a,d|1)
455 # define STDUX(s,a,b) FX(31,s,a,b,181)
456 # define SUBF(d,a,b) FXO(31,d,a,b,0,40)
457 # define SUBF_(d,a,b) FXO_(31,d,a,b,0,40)
458 # define SUBFO(d,a,b) FXO(31,d,a,b,1,40)
459 # define SUBFO_(d,a,b) FXO_(31,d,a,b,1,40)
460 # define SUB(d,a,b) SUBF(d,b,a)
461 # define SUB_(d,a,b) SUBF_(d,b,a)
462 # define SUBO(d,a,b) SUBFO(d,b,a)
463 # define SUBO_(d,a,b) SUBFO_(d,b,a)
464 # define SUBI(d,a,s) ADDI(d,a,-s)
465 # define SUBIS(d,a,s) ADDIS(d,a,-s)
466 # define SUBFC(d,a,b) FXO(31,d,a,b,0,8)
467 # define SUBFC_(d,a,b) FXO_(31,d,a,b,0,8)
468 # define SUBFCO(d,a,b) FXO(31,d,a,b,1,8)
469 # define SUBFCO_(d,a,b) FXO_(31,d,a,b,1,8)
470 # define SUBC(d,a,b) SUBFC(d,b,a)
471 # define SUBIC(d,a,s) ADDIC(d,a,-s)
472 # define SUBIC_(d,a,s) ADDIC_(d,a,-s)
473 # define SUBFE(d,a,b) FXO(31,d,a,b,0,136)
474 # define SUBFE_(d,a,b) FXO_(31,d,a,b,0,136)
475 # define SUBFEO(d,a,b) FXO(31,d,a,b,1,136)
476 # define SUBFEO_(d,a,b) FXO_(31,d,a,b,1,136)
477 # define SUBE(d,a,b) SUBFE(d,b,a)
478 # define SUBFIC(d,a,s) FDs(8,d,a,s)
479 # define SUBFME(d,a) FXO(31,d,a,0,0,232)
480 # define SUBFME_(d,a) FXO_(31,d,a,0,0,232)
481 # define SUBFMEO(d,a) FXO(31,d,a,0,1,232)
482 # define SUBFMEO_(d,a) FXO_(31,d,a,0,1,232)
483 # define SUBFZE(d,a) FXO(31,d,a,0,0,200)
484 # define SUBFZE_(d,a) FXO_(31,d,a,0,0,200)
485 # define SUBFZEO(d,a) FXO(31,d,a,0,1,200)
486 # define SUBFZEO_(d,a) FXO_(31,d,a,0,1,200)
487 # define SYNC() FX(31,0,0,0,598)
488 # define TLBIA() FX(31,0,0,0,370)
489 # define TLBIE(b) FX(31,0,0,b,306)
490 # define TLBSYNC() FX(31,0,0,0,566)
491 # define TW(t,a,b) FX(31,t,a,b,4)
492 # define TWEQ(a,b) FX(31,4,a,b,4)
493 # define TWLGE(a,b) FX(31,5,a,b,4)
494 # define TRAP() FX(31,31,0,0,4)
495 # define TWI(t,a,s) FDs(3,t,a,s)
496 # define TWGTI(a,s) TWI(8,a,s)
497 # define TWLLEI(a,s) TWI(6,a,s)
498 # define XOR(d,a,b) FX(31,a,d,b,316)
499 # define XOR_(d,a,b) FX_(31,a,d,b,316)
500 # define XORI(s,a,u) FDu(26,a,s,u)
501 # define XORIS(s,a,u) FDu(27,a,s,u)
502 # define nop(c) _nop(_jit,c)
503 static void _nop(jit_state_t*,jit_int32_t);
504 # define movr(r0,r1) _movr(_jit,r0,r1)
505 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
506 # define movi(r0,i0) _movi(_jit,r0,i0)
507 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
508 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
509 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
510 # define negr(r0,r1) NEG(r0,r1)
511 # define comr(r0,r1) NOT(r0,r1)
512 # define extr_c(r0,r1) EXTSB(r0,r1)
513 # define extr_uc(r0,r1) ANDI_(r0,r1,0xff)
514 # define extr_s(r0,r1) EXTSH(r0,r1)
515 # define extr_us(r0,r1) ANDI_(r0,r1,0xffff)
516 # if __WORDSIZE == 64
517 # define extr_i(r0,r1) EXTSW(r0,r1)
518 # define extr_ui(r0,r1) CLRLDI(r0,r1,32)
519 # endif
520 # if __BYTE_ORDER == __BIG_ENDIAN
521 # define htonr_us(r0,r1) extr_us(r0,r1)
522 # if __WORDSIZE == 32
523 # define htonr_ui(r0,r1) movr(r0,r1)
524 # else
525 # define htonr_ui(r0,r1) extr_ui(r0,r1)
526 # define htonr_ul(r0,r1) movr(r0,r1)
527 # endif
528 # else
529 # define htonr_us(r0,r1) _htonr_us(_jit,r0,r1)
530 static void _htonr_us(jit_state_t*,jit_int32_t,jit_int32_t);
531 # define htonr_ui(r0,r1) _htonr_ui(_jit,r0,r1)
532 static void _htonr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
533 # if __WORDSIZE == 64
534 # define htonr_ul(r0,r1) _htonr_ul(_jit,r0,r1)
535 static void _htonr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
536 # endif
537 # endif
538 # define addr(r0,r1,r2) ADD(r0,r1,r2)
539 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
540 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
541 # define addcr(r0,r1,r2) ADDC(r0,r1,r2)
542 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
543 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
544 # define addxr(r0,r1,r2) ADDE(r0,r1,r2)
545 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
546 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
547 # define subr(r0,r1,r2) SUB(r0,r1,r2)
548 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
549 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
550 # define subcr(r0,r1,r2) SUBC(r0,r1,r2)
551 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
552 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
553 # define subxr(r0,r1,r2) SUBFE(r0,r2,r1)
554 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
555 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
556 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
557 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
558 # if __WORDSIZE == 32
559 # define mulr(r0,r1,r2) MULLW(r0,r1,r2)
560 # define mullr(r0,r1,r2) MULLW(r0,r1,r2)
561 # define mulhr(r0,r1,r2) MULHW(r0,r1,r2)
562 # define mulhr_u(r0,r1,r2) MULHWU(r0,r1,r2)
563 # else
564 # define mulr(r0,r1,r2) MULLD(r0,r1,r2)
565 # define mullr(r0,r1,r2) MULLD(r0,r1,r2)
566 # define mulhr(r0,r1,r2) MULHD(r0,r1,r2)
567 # define mulhr_u(r0,r1,r2) MULHDU(r0,r1,r2)
568 # endif
569 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
570 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
571 # define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
572 # define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
573 # define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
574 static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
575 jit_int32_t,jit_int32_t,jit_bool_t);
576 # define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
577 # define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
578 # define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
579 static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
580 jit_int32_t,jit_word_t,jit_bool_t);
581 # if __WORDSIZE == 32
582 # define divr(r0,r1,r2) DIVW(r0,r1,r2)
583 # else
584 # define divr(r0,r1,r2) DIVD(r0,r1,r2)
585 # endif
586 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
587 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
588 # if __WORDSIZE == 32
589 # define divr_u(r0,r1,r2) DIVWU(r0,r1,r2)
590 # else
591 # define divr_u(r0,r1,r2) DIVDU(r0,r1,r2)
592 # endif
593 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
594 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
595 # define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
596 # define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
597 # define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
598 static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
599 jit_int32_t,jit_int32_t,jit_bool_t);
600 # define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
601 # define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
602 # define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
603 static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
604 jit_int32_t,jit_word_t,jit_bool_t);
605 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
606 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
607 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
608 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
609 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
610 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
611 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
612 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
613 # define andr(r0,r1,r2) AND(r0,r1,r2)
614 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
615 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
616 # define orr(r0,r1,r2) OR(r0,r1,r2)
617 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
618 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
619 # define xorr(r0,r1,r2) XOR(r0,r1,r2)
620 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
621 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
622 # if __WORDSIZE == 32
623 # define lshr(r0,r1,r2) SLW(r0,r1,r2)
624 # else
625 # define lshr(r0,r1,r2) SLD(r0,r1,r2)
626 # endif
627 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
628 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
629 # if __WORDSIZE == 32
630 # define rshr(r0,r1,r2) SRAW(r0,r1,r2)
631 # else
632 # define rshr(r0,r1,r2) SRAD(r0,r1,r2)
633 # endif
634 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
635 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
636 # if __WORDSIZE == 32
637 # define rshr_u(r0,r1,r2) SRW(r0,r1,r2)
638 # else
639 # define rshr_u(r0,r1,r2) SRD(r0,r1,r2)
640 # endif
641 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
642 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
643 # define ltr(r0,r1,r2) _ltr(_jit,r0,r1,r2)
644 static void _ltr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
645 # define lti(r0,r1,i0) _lti(_jit,r0,r1,i0)
646 static void _lti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
647 # define ltr_u(r0,r1,r2) _ltr_u(_jit,r0,r1,r2)
648 static void _ltr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
649 # define lti_u(r0,r1,i0) _lti_u(_jit,r0,r1,i0)
650 static void _lti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
651 # define ler(r0,r1,r2) _ler(_jit,r0,r1,r2)
652 static void _ler(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
653 # define lei(r0,r1,i0) _lei(_jit,r0,r1,i0)
654 static void _lei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
655 # define ler_u(r0,r1,r2) _ler_u(_jit,r0,r1,r2)
656 static void _ler_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
657 # define lei_u(r0,r1,i0) _lei_u(_jit,r0,r1,i0)
658 static void _lei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
659 # define eqr(r0,r1,r2) _eqr(_jit,r0,r1,r2)
660 static void _eqr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
661 # define eqi(r0,r1,i0) _eqi(_jit,r0,r1,i0)
662 static void _eqi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
663 # define ger(r0,r1,r2) _ger(_jit,r0,r1,r2)
664 static void _ger(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
665 # define gei(r0,r1,i0) _gei(_jit,r0,r1,i0)
666 static void _gei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
667 # define ger_u(r0,r1,r2) _ger_u(_jit,r0,r1,r2)
668 static void _ger_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
669 # define gei_u(r0,r1,i0) _gei_u(_jit,r0,r1,i0)
670 static void _gei_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
671 # define gtr(r0,r1,r2) _gtr(_jit,r0,r1,r2)
672 static void _gtr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
673 # define gti(r0,r1,i0) _gti(_jit,r0,r1,i0)
674 static void _gti(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
675 # define gtr_u(r0,r1,r2) _gtr_u(_jit,r0,r1,r2)
676 static void _gtr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
677 # define gti_u(r0,r1,i0) _gti_u(_jit,r0,r1,i0)
678 static void _gti_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
679 # define ner(r0,r1,r2) _ner(_jit,r0,r1,r2)
680 static void _ner(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
681 # define nei(r0,r1,i0) _nei(_jit,r0,r1,i0)
682 static void _nei(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
683 #define bltr(i0,r0,r1) _bltr(_jit,i0,r0,r1)
684 static jit_word_t _bltr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
685 #define blti(i0,r0,i1) _blti(_jit,i0,r0,i1)
686 static jit_word_t _blti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
687 #define bltr_u(i0,r0,r1) _bltr_u(_jit,i0,r0,r1)
688 static jit_word_t _bltr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
689 #define blti_u(i0,r0,i1) _blti_u(_jit,i0,r0,i1)
690 static jit_word_t _blti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
691 #define bler(i0,r0,r1) _bler(_jit,i0,r0,r1)
692 static jit_word_t _bler(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
693 #define blei(i0,r0,i1) _blei(_jit,i0,r0,i1)
694 static jit_word_t _blei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
695 #define bler_u(i0,r0,r1) _bler_u(_jit,i0,r0,r1)
696 static jit_word_t _bler_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
697 #define blei_u(i0,r0,i1) _blei_u(_jit,i0,r0,i1)
698 static jit_word_t _blei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
699 #define beqr(i0,r0,r1) _beqr(_jit,i0,r0,r1)
700 static jit_word_t _beqr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
701 #define beqi(i0,r0,i1) _beqi(_jit,i0,r0,i1)
702 static jit_word_t _beqi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
703 #define bger(i0,r0,r1) _bger(_jit,i0,r0,r1)
704 static jit_word_t _bger(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
705 #define bgei(i0,r0,i1) _bgei(_jit,i0,r0,i1)
706 static jit_word_t _bgei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
707 #define bger_u(i0,r0,r1) _bger_u(_jit,i0,r0,r1)
708 static jit_word_t _bger_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
709 #define bgei_u(i0,r0,i1) _bgei_u(_jit,i0,r0,i1)
710 static jit_word_t _bgei_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
711 #define bgtr(i0,r0,r1) _bgtr(_jit,i0,r0,r1)
712 static jit_word_t _bgtr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
713 #define bgti(i0,r0,i1) _bgti(_jit,i0,r0,i1)
714 static jit_word_t _bgti(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
715 #define bgtr_u(i0,r0,r1) _bgtr_u(_jit,i0,r0,r1)
716 static jit_word_t _bgtr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
717 #define bgti_u(i0,r0,i1) _bgti_u(_jit,i0,r0,i1)
718 static jit_word_t _bgti_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
719 #define bner(i0,r0,r1) _bner(_jit,i0,r0,r1)
720 static jit_word_t _bner(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
721 #define bnei(i0,r0,i1) _bnei(_jit,i0,r0,i1)
722 static jit_word_t _bnei(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
723 #define bmsr(i0,r0,r1) _bmsr(_jit,i0,r0,r1)
724 static jit_word_t _bmsr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
725 #define bmsi(i0,r0,i1) _bmsi(_jit,i0,r0,i1)
726 static jit_word_t _bmsi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
727 #define bmcr(i0,r0,r1) _bmcr(_jit,i0,r0,r1)
728 static jit_word_t _bmcr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
729 #define bmci(i0,r0,i1) _bmci(_jit,i0,r0,i1)
730 static jit_word_t _bmci(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
731 #define boaddr(i0,r0,r1) _boaddr(_jit,i0,r0,r1)
732 static jit_word_t _boaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
733 #define boaddi(i0,r0,i1) _boaddi(_jit,i0,r0,i1)
734 static jit_word_t _boaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
735 #define bxaddr(i0,r0,r1) _bxaddr(_jit,i0,r0,r1)
736 static jit_word_t _bxaddr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
737 #define bxaddi(i0,r0,i1) _bxaddi(_jit,i0,r0,i1)
738 static jit_word_t _bxaddi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
739 #define bosubr(i0,r0,r1) _bosubr(_jit,i0,r0,r1)
740 static jit_word_t _bosubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
741 #define bosubi(i0,r0,i1) _bosubi(_jit,i0,r0,i1)
742 static jit_word_t _bosubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
743 #define bxsubr(i0,r0,r1) _bxsubr(_jit,i0,r0,r1)
744 static jit_word_t _bxsubr(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
745 #define bxsubi(i0,r0,i1) _bxsubi(_jit,i0,r0,i1)
746 static jit_word_t _bxsubi(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
747 #define boaddr_u(i0,r0,r1) _boaddr_u(_jit,i0,r0,r1)
748 static jit_word_t _boaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
749 #define boaddi_u(i0,r0,i1) _boaddi_u(_jit,i0,r0,i1)
750 static jit_word_t _boaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
751 #define bxaddr_u(i0,r0,r1) _bxaddr_u(_jit,i0,r0,r1)
752 static jit_word_t _bxaddr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
753 #define bxaddi_u(i0,r0,i1) _bxaddi_u(_jit,i0,r0,i1)
754 static jit_word_t _bxaddi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
755 #define bosubr_u(i0,r0,r1) _bosubr_u(_jit,i0,r0,r1)
756 static jit_word_t _bosubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
757 #define bosubi_u(i0,r0,i1) _bosubi_u(_jit,i0,r0,i1)
758 static jit_word_t _bosubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
759 #define bxsubr_u(i0,r0,r1) _bxsubr_u(_jit,i0,r0,r1)
760 static jit_word_t _bxsubr_u(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
761 #define bxsubi_u(i0,r0,i1) _bxsubi_u(_jit,i0,r0,i1)
762 static jit_word_t _bxsubi_u(jit_state_t*,jit_word_t,jit_int32_t,jit_word_t);
763 # define ldr_c(r0,r1) _ldr_c(_jit,r0,r1)
764 static void _ldr_c(jit_state_t*,jit_int32_t,jit_int32_t);
765 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
766 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
767 # define ldxr_c(r0,r1,i0) _ldxr_c(_jit,r0,r1,i0)
768 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
769 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
770 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
771 # define ldr_uc(r0,r1) LBZX(r0, _R0_REGNO, r1)
772 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
773 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
774 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
775 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
776 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
777 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
778 # define ldr_s(r0,r1) LHAX(r0, _R0_REGNO, r1)
779 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
780 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
781 # define ldxr_s(r0,r1,i0) _ldxr_s(_jit,r0,r1,i0)
782 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
783 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
784 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
785 # define ldr_us(r0,r1) LHZX(r0, _R0_REGNO, r1)
786 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
787 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
788 # define ldxr_us(r0,r1,i0) _ldxr_us(_jit,r0,r1,i0)
789 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
790 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
791 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
792 # if __WORDSIZE == 32
793 # define ldr_i(r0,r1) LWZX(r0, _R0_REGNO, r1)
794 # else
795 # define ldr_i(r0,r1) LWAX(r0, _R0_REGNO, r1)
796 # endif
797 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
798 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
799 # define ldxr_i(r0,r1,i0) _ldxr_i(_jit,r0,r1,i0)
800 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
801 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
802 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
803 # if __WORDSIZE == 64
804 # define ldr_ui(r0,r1) LWZX(r0, _R0_REGNO, r1)
805 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
806 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
807 # define ldxr_ui(r0,r1,i0) _ldxr_ui(_jit,r0,r1,i0)
808 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
809 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
810 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
811 # define ldr_l(r0,r1) LDX(r0, _R0_REGNO, r1)
812 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
813 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
814 # define ldxr_l(r0,r1,i0) _ldxr_l(_jit,r0,r1,i0)
815 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
816 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
817 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
818 # endif
819 # define str_c(r0,r1) STBX(r1, _R0_REGNO, r0)
820 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
821 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
822 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
823 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
824 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
825 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
826 # define str_s(r0,r1) STHX(r1, _R0_REGNO, r0)
827 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
828 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
829 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
830 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
831 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
832 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
833 # define str_i(r0,r1) STWX(r1, _R0_REGNO, r0)
834 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
835 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
836 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
837 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
838 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
839 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
840 # if __WORDSIZE == 64
841 # define str_l(r0,r1) STDX(r1, _R0_REGNO, r0)
842 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
843 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
844 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
845 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
846 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
847 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
848 # endif
849 # define jmpr(r0) _jmpr(_jit,r0)
850 static void _jmpr(jit_state_t*,jit_int32_t);
851 # define jmpi(i0) _jmpi(_jit,i0)
852 static jit_word_t _jmpi(jit_state_t*,jit_word_t);
853 # define jmpi_p(i0) _jmpi_p(_jit,i0)
854 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t) maybe_unused;
855 # if _CALL_SYSV
856 # define callr(r0,i0) _callr(_jit,r0,i0)
857 static void _callr(jit_state_t*,jit_int32_t,jit_int32_t);
858 # define calli(i0,i1) _calli(_jit,i0,i1)
859 static void _calli(jit_state_t*,jit_word_t,jit_int32_t);
860 # define calli_p(i0,i1) _calli_p(_jit,i0,i1)
861 static jit_word_t _calli_p(jit_state_t*,jit_word_t,jit_int32_t);
862 # else
863 # define callr(r0) _callr(_jit,r0)
864 static void _callr(jit_state_t*,jit_int32_t);
865 # define calli(i0) _calli(_jit,i0)
866 static void _calli(jit_state_t*,jit_word_t);
867 # define calli_p(i0) _calli_p(_jit,i0)
868 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
869 #endif
870 # define prolog(node) _prolog(_jit, node)
871 static void _prolog(jit_state_t*, jit_node_t*);
872 # define epilog(node) _epilog(_jit, node)
873 static void _epilog(jit_state_t*, jit_node_t*);
874 # define vastart(r0) _vastart(_jit, r0)
875 static void _vastart(jit_state_t*, jit_int32_t);
876 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
877 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
878 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
879 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
880 # define patch_at(i,l) _patch_at(_jit,i,l)
881 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
882 #endif
883
884 #if CODE
885 # define _u16(v) ((v) & 0xffff)
886 # define _u26(v) ((v) & 0x3ffffff)
887 static void
_FXO(jit_state_t * _jit,int o,int d,int a,int b,int e,int x,int r)888 _FXO(jit_state_t *_jit, int o, int d, int a, int b, int e, int x, int r)
889 {
890 assert(!(o & ~((1 << 6) - 1)));
891 assert(!(d & ~((1 << 5) - 1)));
892 assert(!(a & ~((1 << 5) - 1)));
893 assert(!(b & ~((1 << 5) - 1)));
894 assert(!(e & ~((1 << 1) - 1)));
895 assert(!(x & ~((1 << 9) - 1)));
896 assert(!(r & ~((1 << 1) - 1)));
897 ii((o<<26)|(d<<21)|(a<<16)|(b<<11)|(e<<10)|(x<<1)|r);
898 }
899
900 static void
_FDs(jit_state_t * _jit,int o,int d,int a,int s)901 _FDs(jit_state_t *_jit, int o, int d, int a, int s)
902 {
903 assert(!(o & ~((1 << 6) - 1)));
904 assert(!(d & ~((1 << 5) - 1)));
905 assert(!(a & ~((1 << 5) - 1)));
906 assert(can_sign_extend_short_p(s));
907 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
908 }
909
910 static void
_FDu(jit_state_t * _jit,int o,int d,int a,int s)911 _FDu(jit_state_t *_jit, int o, int d, int a, int s)
912 {
913 assert(!(o & ~((1 << 6) - 1)));
914 assert(!(d & ~((1 << 5) - 1)));
915 assert(!(a & ~((1 << 5) - 1)));
916 assert(can_zero_extend_short_p(s));
917 ii((o<<26)|(d<<21)|(a<<16)|_u16(s));
918 }
919
920 static void
_FX(jit_state_t * _jit,int o,int s,int a,int b,int x,int r)921 _FX(jit_state_t *_jit, int o, int s, int a, int b, int x, int r)
922 {
923 assert(!(o & ~((1 << 6) - 1)));
924 assert(!(s & ~((1 << 5) - 1)));
925 assert(!(a & ~((1 << 5) - 1)));
926 assert(!(b & ~((1 << 5) - 1)));
927 assert(!(x & ~((1 << 10) - 1)));
928 assert(!(r & ~((1 << 1) - 1)));
929 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(x<<1)|r);
930 }
931
932 static void
_FI(jit_state_t * _jit,int o,int t,int a,int k)933 _FI(jit_state_t *_jit, int o, int t, int a, int k)
934 {
935 assert(!(o & ~(( 1 << 6) - 1)));
936 assert(!(t & 3) && can_sign_extend_jump_p(t));
937 assert(!(a & ~(( 1 << 1) - 1)));
938 assert(!(k & ~(( 1 << 1) - 1)));
939 ii((o<<26)|_u26(t)|(a<<1)|k);
940 }
941
942 static void
_FB(jit_state_t * _jit,int o,int bo,int bi,int t,int a,int k)943 _FB(jit_state_t *_jit, int o, int bo, int bi, int t, int a, int k)
944 {
945 assert(!( o & ~((1 << 6) - 1)));
946 assert(!(bo & ~((1 << 5) - 1)));
947 assert(!(bi & ~((1 << 5) - 1)));
948 assert(!(t & 3) && can_sign_extend_short_p(t));
949 assert(!(a & ~(( 1 << 1) - 1)));
950 assert(!(k & ~(( 1 << 1) - 1)));
951 ii((o<<26)|(bo<<21)|(bi<<16)|_u16(t)|(a<<1)|k);
952 }
953
954 static void
_FXL(jit_state_t * _jit,int o,int bo,int bi,int x,int k)955 _FXL(jit_state_t *_jit, int o, int bo, int bi, int x, int k)
956 {
957 assert(!( o & ~((1 << 6) - 1)));
958 assert(!(bo & ~((1 << 5) - 1)));
959 assert(!(bi & ~((1 << 5) - 1)));
960 assert(!(x & ~(( 1 << 10) - 1)));
961 assert(!(k & ~(( 1 << 1) - 1)));
962 ii((o<<26)|(bo<<21)|(bi<<16)|(x<<1)|k);
963 }
964
965 static void
_FC(jit_state_t * _jit,int o,int d,int l,int a,int b,int x)966 _FC(jit_state_t *_jit, int o, int d, int l, int a, int b, int x)
967 {
968 assert(!(o & ~((1 << 6) - 1)));
969 assert(!(d & ~((1 << 3) - 1)));
970 assert(!(l & ~((1 << 1) - 1)));
971 assert(!(a & ~((1 << 5) - 1)));
972 assert(!(b & ~((1 << 5) - 1)));
973 assert(!(x & ~((1 << 10) - 1)));
974 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|(b<<11)|(x<<1));
975 }
976
977 static void
_FCI(jit_state_t * _jit,int o,int d,int l,int a,int s)978 _FCI(jit_state_t *_jit, int o, int d, int l, int a, int s)
979 {
980 assert(!(o & ~((1 << 6) - 1)));
981 assert(!(d & ~((1 << 3) - 1)));
982 assert(!(l & ~((1 << 1) - 1)));
983 assert(!(a & ~((1 << 5) - 1)));
984 if (o == 11) assert(can_sign_extend_short_p(s));
985 else if (o == 10) assert(can_zero_extend_short_p(s));
986 #if DEBUG
987 else abort();
988 #endif
989 ii((o<<26)|(d<<23)|(l<<21)|(a<<16)|_u16(s));
990 }
991
992 static void
_FXFX(jit_state_t * _jit,int o,int d,int x,int f)993 _FXFX(jit_state_t *_jit, int o, int d, int x, int f)
994 {
995 assert(!(o & ~((1 << 6) - 1)));
996 assert(!(d & ~((1 << 5) - 1)));
997 assert(!(x & ~((1 << 10) - 1)));
998 assert(!(f & ~((1 << 10) - 1)));
999 ii((o<<26)|(d<<21)|(x<<11)|(f<<1));
1000 }
1001
1002 static void
_FM(jit_state_t * _jit,int o,int s,int a,int h,int b,int e,int r)1003 _FM(jit_state_t *_jit, int o, int s, int a, int h, int b, int e, int r)
1004 {
1005 assert(!(o & ~((1 << 6) - 1)));
1006 assert(!(s & ~((1 << 5) - 1)));
1007 assert(!(a & ~((1 << 5) - 1)));
1008 assert(!(h & ~((1 << 5) - 1)));
1009 assert(!(b & ~((1 << 5) - 1)));
1010 assert(!(e & ~((1 << 5) - 1)));
1011 assert(!(r & ~((1 << 1) - 1)));
1012 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(b<<6)|(e<<1)|r);
1013 }
1014
1015 # if __WORDSIZE == 64
1016 static void
_FMDS(jit_state_t * _jit,int o,int s,int a,int b,int e,int x,int r)1017 _FMDS(jit_state_t *_jit, int o, int s, int a, int b, int e, int x, int r)
1018 {
1019 assert(!(o & ~((1 << 6) - 1)));
1020 assert(!(s & ~((1 << 5) - 1)));
1021 assert(!(a & ~((1 << 5) - 1)));
1022 assert(!(b & ~((1 << 5) - 1)));
1023 assert(!(e & ~((1 << 6) - 1)));
1024 assert(!(x & ~((1 << 4) - 1)));
1025 assert(!(r & ~((1 << 1) - 1)));
1026 e = (e >> 5) | ((e << 1) & 63);
1027 ii((o<<26)|(s<<21)|(a<<16)|(b<<11)|(e<<5)|(x<<1)|r);
1028 }
1029
1030 static void
_FMD(jit_state_t * _jit,int o,int s,int a,int h,int e,int x,int i,int r)1031 _FMD(jit_state_t *_jit, int o, int s, int a, int h, int e, int x, int i, int r)
1032 {
1033 assert(!(o & ~((1 << 6) - 1)));
1034 assert(!(s & ~((1 << 5) - 1)));
1035 assert(!(a & ~((1 << 5) - 1)));
1036 assert(!(h & ~((1 << 5) - 1)));
1037 assert(!(e & ~((1 << 6) - 1)));
1038 assert(!(x & ~((1 << 3) - 1)));
1039 assert(!(i & ~((1 << 1) - 1)));
1040 assert(!(r & ~((1 << 1) - 1)));
1041 e = (e >> 5) | ((e << 1) & 63);
1042 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(e<<5)|(x<<2)|(i<<1)|r);
1043 }
1044
1045 static void
_FXS(jit_state_t * _jit,int o,int s,int a,int h,int x,int i,int r)1046 _FXS(jit_state_t *_jit, int o, int s, int a, int h, int x, int i, int r)
1047 {
1048 assert(!(o & ~((1 << 6) - 1)));
1049 assert(!(s & ~((1 << 5) - 1)));
1050 assert(!(a & ~((1 << 5) - 1)));
1051 assert(!(h & ~((1 << 5) - 1)));
1052 assert(!(x & ~((1 << 9) - 1)));
1053 assert(!(i & ~((1 << 1) - 1)));
1054 assert(!(r & ~((1 << 1) - 1)));
1055 ii((o<<26)|(s<<21)|(a<<16)|(h<<11)|(x<<2)|(i<<1)|r);
1056 }
1057 #endif
1058
1059 #if !DEBUG
1060 /*
1061 * Use the sequence commented at
1062 * http://tenfourfox.blogspot.com/2011/04/attention-g5-owners-your-javascript-no.html
1063 */
1064 static void
_MCRXR(jit_state_t * _jit,jit_int32_t cr)1065 _MCRXR(jit_state_t *_jit, jit_int32_t cr)
1066 {
1067 jit_int32_t reg;
1068 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
1069 MFXER(rn(reg));
1070 MTCRF(128, rn(reg));
1071 RLWINM(rn(reg), rn(reg), 0, 0, 28);
1072 MTXER(rn(reg));
1073 jit_unget_reg(reg);
1074 }
1075 #endif
1076
1077 static void
_nop(jit_state_t * _jit,jit_int32_t i0)1078 _nop(jit_state_t *_jit, jit_int32_t i0)
1079 {
1080 for (; i0 > 0; i0 -= 4)
1081 NOP();
1082 assert(i0 == 0);
1083 }
1084
1085 static void
_movr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)1086 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1087 {
1088 if (r0 != r1)
1089 MR(r0, r1);
1090 }
1091
1092 static void
_movi(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)1093 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1094 {
1095 if (can_sign_extend_short_p(i0))
1096 LI(r0, i0);
1097 else {
1098 if (can_sign_extend_int_p(i0))
1099 LIS(r0, (jit_int16_t)(i0 >> 16));
1100 else if (can_zero_extend_int_p(i0)) {
1101 if (i0 & 0xffff0000) {
1102 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1103 SLWI(r0, r0, 16);
1104 }
1105 }
1106 # if __WORDSIZE == 64
1107 else {
1108 movi(r0, (jit_uint32_t)(i0 >> 32));
1109 if (i0 & 0xffff0000) {
1110 SLDI(r0, r0, 16);
1111 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1112 SLDI(r0, r0, 16);
1113 }
1114 else
1115 SLDI(r0, r0, 32);
1116 }
1117 # endif
1118 if (i0 & 0xffff)
1119 ORI(r0, r0, (jit_uint16_t)i0);
1120 }
1121 }
1122
1123 static jit_word_t
_movi_p(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)1124 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1125 {
1126 jit_word_t word = _jit->pc.w;
1127 # if __WORDSIZE == 32
1128 LIS(r0, (jit_int16_t)(i0 >> 16));
1129 ORI(r0, r0, (jit_uint16_t)i0);
1130 # else
1131 LIS(r0, (jit_int16_t)(i0 >> 48));
1132 ORI(r0, r0, (jit_uint16_t)(i0 >> 32));
1133 SLDI(r0, r0, 16);
1134 ORI(r0, r0, (jit_uint16_t)(i0 >> 16));
1135 SLDI(r0, r0, 16);
1136 ORI(r0, r0, (jit_uint16_t)i0);
1137 # endif
1138 return (word);
1139 }
1140
1141 # if __BYTE_ORDER == __LITTLE_ENDIAN
1142 static void
_htonr_us(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)1143 _htonr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1144 {
1145 jit_int32_t t0;
1146 t0 = jit_get_reg(jit_class_gpr);
1147 rshi(rn(t0), r1, 8);
1148 andi(r0, r1, 0xff);
1149 andi(rn(t0), rn(t0), 0xff);
1150 lshi(r0, r0, 8);
1151 orr(r0, r0, rn(t0));
1152 jit_unget_reg(t0);
1153 }
1154
1155 static void
_htonr_ui(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)1156 _htonr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1157 {
1158 jit_int32_t reg;
1159 reg = jit_get_reg(jit_class_gpr);
1160 ROTLWI(rn(reg), r1, 8);
1161 RLWIMI(rn(reg), r1, 24, 0, 7);
1162 RLWIMI(rn(reg), r1, 24, 16, 23);
1163 CLRLDI(r0, rn(reg), 32);
1164 jit_unget_reg(reg);
1165 }
1166
1167 # if __WORDSIZE == 64
1168 static void
_htonr_ul(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)1169 _htonr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1170 {
1171 jit_int32_t reg;
1172 reg = jit_get_reg(jit_class_gpr);
1173 rshi_u(rn(reg), r1, 32);
1174 htonr_ui(r0, r1);
1175 htonr_ui(rn(reg), rn(reg));
1176 lshi(r0, r0, 32);
1177 orr(r0, r0, rn(reg));
1178 jit_unget_reg(reg);
1179 }
1180 # endif
1181 # endif
1182
1183 static void
_addi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1184 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1185 {
1186 jit_int32_t reg;
1187 if (can_sign_extend_short_p(i0))
1188 ADDI(r0, r1, i0);
1189 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1190 ADDIS(r0, r1, i0 >> 16);
1191 else {
1192 reg = jit_get_reg(jit_class_gpr);
1193 movi(rn(reg), i0);
1194 ADD(r0, r1, rn(reg));
1195 jit_unget_reg(reg);
1196 }
1197 }
1198
1199 static void
_addci(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1200 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1201 {
1202 jit_int32_t reg;
1203 if (can_sign_extend_short_p(i0))
1204 ADDIC(r0, r1, i0);
1205 else {
1206 reg = jit_get_reg(jit_class_gpr);
1207 movi(rn(reg), i0);
1208 ADDC(r0, r1, rn(reg));
1209 jit_unget_reg(reg);
1210 }
1211 }
1212
1213 static void
_addxi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1214 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1215 {
1216 jit_int32_t reg;
1217 reg = jit_get_reg(jit_class_gpr);
1218 movi(rn(reg), i0);
1219 ADDE(r0, r1, rn(reg));
1220 jit_unget_reg(reg);
1221 }
1222
1223 static void
_subi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1224 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1225 {
1226 jit_int32_t reg;
1227 jit_word_t ni0 = -i0;
1228 if (can_sign_extend_short_p(ni0))
1229 ADDI(r0, r1, ni0);
1230 else if (can_zero_extend_int_p(ni0) && !(ni0 & 0x0000ffff))
1231 ADDIS(r0, r1, ni0 >> 16);
1232 else {
1233 reg = jit_get_reg(jit_class_gpr);
1234 movi(rn(reg), i0);
1235 SUB(r0, r1, rn(reg));
1236 jit_unget_reg(reg);
1237 }
1238 }
1239
1240 static void
_subci(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1241 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1242 {
1243 jit_int32_t reg;
1244 reg = jit_get_reg(jit_class_gpr);
1245 movi(rn(reg), i0);
1246 SUBC(r0, r1, rn(reg));
1247 jit_unget_reg(reg);
1248 }
1249
1250 static void
_subxi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1251 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1252 {
1253 jit_int32_t reg;
1254 reg = jit_get_reg(jit_class_gpr);
1255 movi(rn(reg), i0);
1256 SUBE(r0, r1, rn(reg));
1257 jit_unget_reg(reg);
1258 }
1259
1260 static void
_rsbi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1261 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1262 {
1263 subi(r0, r1, i0);
1264 negr(r0, r0);
1265 }
1266
1267 static void
_muli(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1268 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1269 {
1270 jit_int32_t reg;
1271 if (can_sign_extend_short_p(i0))
1272 MULLI(r0, r1, i0);
1273 else {
1274 reg = jit_get_reg(jit_class_gpr);
1275 movi(rn(reg), i0);
1276 mulr(r0, r1, rn(reg));
1277 jit_unget_reg(reg);
1278 }
1279 }
1280
1281 static void
_iqmulr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_int32_t r3,jit_bool_t sign)1282 _iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1283 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1284 {
1285 jit_int32_t reg;
1286 if (r0 == r2 || r0 == r3) {
1287 reg = jit_get_reg(jit_class_gpr);
1288 mullr(rn(reg), r2, r3);
1289 }
1290 else
1291 mullr(r0, r2, r3);
1292 if (sign)
1293 mulhr(r1, r2, r3);
1294 else
1295 mulhr_u(r1, r2, r3);
1296 if (r0 == r2 || r0 == r3) {
1297 movr(r0, rn(reg));
1298 jit_unget_reg(reg);
1299 }
1300 }
1301
1302 static void
_iqmuli(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_word_t i0,jit_bool_t sign)1303 _iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1304 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1305 {
1306 jit_int32_t reg;
1307 reg = jit_get_reg(jit_class_gpr);
1308 movi(rn(reg), i0);
1309 iqmulr(r0, r1, r2, rn(reg), sign);
1310 jit_unget_reg(reg);
1311 }
1312
1313 static void
_divi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1314 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1315 {
1316 jit_int32_t reg;
1317 reg = jit_get_reg(jit_class_gpr);
1318 movi(rn(reg), i0);
1319 divr(r0, r1, rn(reg));
1320 jit_unget_reg(reg);
1321 }
1322
1323 static void
_divi_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1324 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1325 {
1326 jit_int32_t reg;
1327 reg = jit_get_reg(jit_class_gpr);
1328 movi(rn(reg), i0);
1329 divr_u(r0, r1, rn(reg));
1330 jit_unget_reg(reg);
1331 }
1332
1333 static void
_iqdivr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_int32_t r3,jit_bool_t sign)1334 _iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1335 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1336 {
1337 jit_int32_t sv0, rg0;
1338 jit_int32_t sv1, rg1;
1339
1340 if (r0 == r2 || r0 == r3) {
1341 sv0 = jit_get_reg(jit_class_gpr);
1342 rg0 = rn(sv0);
1343 }
1344 else
1345 rg0 = r0;
1346 if (r1 == r2 || r1 == r3) {
1347 sv1 = jit_get_reg(jit_class_gpr);
1348 rg1 = rn(sv1);
1349 }
1350 else
1351 rg1 = r1;
1352
1353 if (sign)
1354 divr(rg0, r2, r3);
1355 else
1356 divr_u(rg0, r2, r3);
1357 mulr(rg1, r3, rg0);
1358 subr(rg1, r2, rg1);
1359 if (rg0 != r0) {
1360 movr(r0, rg0);
1361 jit_unget_reg(sv0);
1362 }
1363 if (rg1 != r1) {
1364 movr(r1, rg1);
1365 jit_unget_reg(sv1);
1366 }
1367 }
1368
1369 static void
_iqdivi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_word_t i0,jit_bool_t sign)1370 _iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1371 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1372 {
1373 jit_int32_t reg;
1374 reg = jit_get_reg(jit_class_gpr);
1375 movi(rn(reg), i0);
1376 iqdivr(r0, r1, r2, rn(reg), sign);
1377 jit_unget_reg(reg);
1378 }
1379
1380 static void
_remr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1381 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1382 {
1383 jit_int32_t reg;
1384 if (r0 == r1 || r0 == r2) {
1385 reg = jit_get_reg(jit_class_gpr);
1386 divr(rn(reg), r1, r2);
1387 mulr(rn(reg), r2, rn(reg));
1388 subr(r0, r1, rn(reg));
1389 jit_unget_reg(reg);
1390 }
1391 else {
1392 divr(r0, r1, r2);
1393 mulr(r0, r2, r0);
1394 subr(r0, r1, r0);
1395 }
1396 }
1397
1398 static void
_remi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1399 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1400 {
1401 jit_int32_t reg;
1402 reg = jit_get_reg(jit_class_gpr);
1403 movi(rn(reg), i0);
1404 remr(r0, r1, rn(reg));
1405 jit_unget_reg(reg);
1406 }
1407
1408 static void
_remr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1409 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1410 {
1411 jit_int32_t reg;
1412 if (r0 == r1 || r0 == r2) {
1413 reg = jit_get_reg(jit_class_gpr);
1414 divr_u(rn(reg), r1, r2);
1415 mulr(rn(reg), r2, rn(reg));
1416 subr(r0, r1, rn(reg));
1417 jit_unget_reg(reg);
1418 }
1419 else {
1420 divr_u(r0, r1, r2);
1421 mulr(r0, r2, r0);
1422 subr(r0, r1, r0);
1423 }
1424 }
1425
1426 static void
_remi_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1427 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1428 {
1429 jit_int32_t reg;
1430 reg = jit_get_reg(jit_class_gpr);
1431 movi(rn(reg), i0);
1432 remr_u(r0, r1, rn(reg));
1433 jit_unget_reg(reg);
1434 }
1435
1436 static void
_andi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1437 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1438 {
1439 jit_int32_t reg;
1440 if (can_zero_extend_short_p(i0))
1441 ANDI_(r0, r1, i0);
1442 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1443 ANDIS_(r0, r1, (jit_uword_t)i0 >> 16);
1444 else {
1445 reg = jit_get_reg(jit_class_gpr);
1446 movi(rn(reg), i0);
1447 AND(r0, r1, rn(reg));
1448 jit_unget_reg(reg);
1449 }
1450 }
1451
1452 static void
_ori(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1453 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1454 {
1455 jit_int32_t reg;
1456 if (can_zero_extend_short_p(i0))
1457 ORI(r0, r1, i0);
1458 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1459 ORIS(r0, r1, (jit_uword_t)i0 >> 16);
1460 else {
1461 reg = jit_get_reg(jit_class_gpr);
1462 movi(rn(reg), i0);
1463 OR(r0, r1, rn(reg));
1464 jit_unget_reg(reg);
1465 }
1466 }
1467
1468 static void
_xori(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1469 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1470 {
1471 jit_int32_t reg;
1472 if (can_zero_extend_short_p(i0))
1473 XORI(r0, r1, i0);
1474 else if (can_zero_extend_int_p(i0) && !(i0 & 0x0000ffff))
1475 XORIS(r0, r1, (jit_uword_t)i0 >> 16);
1476 else {
1477 reg = jit_get_reg(jit_class_gpr);
1478 movi(rn(reg), i0);
1479 XOR(r0, r1, rn(reg));
1480 jit_unget_reg(reg);
1481 }
1482 }
1483
1484 static void
_lshi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1485 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1486 {
1487 if (i0 == 0)
1488 movr(r0, r1);
1489 else {
1490 # if __WORDSIZE == 32
1491 SLWI(r0, r1, i0);
1492 # else
1493 SLDI(r0, r1, i0);
1494 # endif
1495 }
1496 }
1497
1498 static void
_rshi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1499 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1500 {
1501 if (i0 == 0)
1502 movr(r0, r1);
1503 else {
1504 # if __WORDSIZE == 32
1505 SRAWI(r0, r1, i0);
1506 # else
1507 SRADI(r0, r1, i0);
1508 # endif
1509 }
1510 }
1511
1512 static void
_rshi_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1513 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1514 {
1515 if (i0 == 0)
1516 movr(r0, r1);
1517 else {
1518 # if __WORDSIZE == 32
1519 SRWI(r0, r1, i0);
1520 # else
1521 SRDI(r0, r1, i0);
1522 # endif
1523 }
1524 }
1525
1526 static void
_ltr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1527 _ltr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1528 {
1529 CMPW(r1, r2);
1530 MFCR(r0);
1531 EXTRWI(r0, r0, 1, CR_LT);
1532 }
1533
1534 static void
_lti(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1535 _lti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1536 {
1537 jit_int32_t reg;
1538 if (can_sign_extend_short_p(i0))
1539 CMPWI(r1, i0);
1540 else {
1541 reg = jit_get_reg(jit_class_gpr);
1542 movi(rn(reg), i0);
1543 CMPW(r1, rn(reg));
1544 jit_unget_reg(reg);
1545 }
1546 MFCR(r0);
1547 EXTRWI(r0, r0, 1, CR_LT);
1548 }
1549
1550 static void
_ltr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1551 _ltr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1552 {
1553 CMPLW(r1, r2);
1554 MFCR(r0);
1555 EXTRWI(r0, r0, 1, CR_LT);
1556 }
1557
1558 static void
_lti_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1559 _lti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1560 {
1561 jit_int32_t reg;
1562 if (can_zero_extend_short_p(i0))
1563 CMPLWI(r1, i0);
1564 else {
1565 reg = jit_get_reg(jit_class_gpr);
1566 movi(rn(reg), i0);
1567 CMPLW(r1, rn(reg));
1568 jit_unget_reg(reg);
1569 }
1570 MFCR(r0);
1571 EXTRWI(r0, r0, 1, CR_LT);
1572 }
1573
1574 static void
_ler(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1575 _ler(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1576 {
1577 CMPW(r1, r2);
1578 CRNOT(CR_GT, CR_GT);
1579 MFCR(r0);
1580 EXTRWI(r0, r0, 1, CR_GT);
1581 }
1582
1583 static void
_lei(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1584 _lei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1585 {
1586 jit_int32_t reg;
1587 if (can_sign_extend_short_p(i0))
1588 CMPWI(r1, i0);
1589 else {
1590 reg = jit_get_reg(jit_class_gpr);
1591 movi(rn(reg), i0);
1592 CMPW(r1, rn(reg));
1593 jit_unget_reg(reg);
1594 }
1595 CRNOT(CR_GT, CR_GT);
1596 MFCR(r0);
1597 EXTRWI(r0, r0, 1, CR_GT);
1598 }
1599
1600 static void
_ler_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1601 _ler_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1602 {
1603 CMPLW(r1, r2);
1604 CRNOT(CR_GT, CR_GT);
1605 MFCR(r0);
1606 EXTRWI(r0, r0, 1, CR_GT);
1607 }
1608
1609 static void
_lei_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1610 _lei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1611 {
1612 jit_int32_t reg;
1613 if (can_zero_extend_short_p(i0))
1614 CMPLWI(r1, i0);
1615 else {
1616 reg = jit_get_reg(jit_class_gpr);
1617 movi(rn(reg), i0);
1618 CMPLW(r1, rn(reg));
1619 jit_unget_reg(reg);
1620 }
1621 CRNOT(CR_GT, CR_GT);
1622 MFCR(r0);
1623 EXTRWI(r0, r0, 1, CR_GT);
1624 }
1625
1626 static void
_eqr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1627 _eqr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1628 {
1629 CMPW(r1, r2);
1630 MFCR(r0);
1631 EXTRWI(r0, r0, 1, CR_EQ);
1632 }
1633
1634 static void
_eqi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1635 _eqi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1636 {
1637 jit_int32_t reg;
1638 if (can_sign_extend_short_p(i0))
1639 CMPWI(r1, i0);
1640 else if (can_zero_extend_short_p(i0))
1641 CMPLWI(r1, i0);
1642 else {
1643 reg = jit_get_reg(jit_class_gpr);
1644 movi(rn(reg), i0);
1645 CMPW(r1, rn(reg));
1646 jit_unget_reg(reg);
1647 }
1648 MFCR(r0);
1649 EXTRWI(r0, r0, 1, CR_EQ);
1650 }
1651
1652 static void
_ger(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1653 _ger(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1654 {
1655 CMPW(r1, r2);
1656 CRNOT(CR_LT, CR_LT);
1657 MFCR(r0);
1658 EXTRWI(r0, r0, 1, CR_LT);
1659 }
1660
1661 static void
_gei(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1662 _gei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1663 {
1664 jit_int32_t reg;
1665 if (can_sign_extend_short_p(i0))
1666 CMPWI(r1, i0);
1667 else {
1668 reg = jit_get_reg(jit_class_gpr);
1669 movi(rn(reg), i0);
1670 CMPW(r1, rn(reg));
1671 jit_unget_reg(reg);
1672 }
1673 CRNOT(CR_LT, CR_LT);
1674 MFCR(r0);
1675 EXTRWI(r0, r0, 1, CR_LT);
1676 }
1677
1678 static void
_ger_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1679 _ger_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1680 {
1681 CMPLW(r1, r2);
1682 CRNOT(CR_LT, CR_LT);
1683 MFCR(r0);
1684 EXTRWI(r0, r0, 1, CR_LT);
1685 }
1686
1687 static void
_gei_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1688 _gei_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1689 {
1690 jit_int32_t reg;
1691 if (can_zero_extend_short_p(i0))
1692 CMPLWI(r1, i0);
1693 else {
1694 reg = jit_get_reg(jit_class_gpr);
1695 movi(rn(reg), i0);
1696 CMPLW(r1, rn(reg));
1697 jit_unget_reg(reg);
1698 }
1699 CRNOT(CR_LT, CR_LT);
1700 MFCR(r0);
1701 EXTRWI(r0, r0, 1, CR_LT);
1702 }
1703
1704 static void
_gtr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1705 _gtr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1706 {
1707 CMPW(r1, r2);
1708 MFCR(r0);
1709 EXTRWI(r0, r0, 1, CR_GT);
1710 }
1711
1712 static void
_gti(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1713 _gti(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1714 {
1715 jit_int32_t reg;
1716 if (can_sign_extend_short_p(i0))
1717 CMPWI(r1, i0);
1718 else {
1719 reg = jit_get_reg(jit_class_gpr);
1720 movi(rn(reg), i0);
1721 CMPW(r1, rn(reg));
1722 jit_unget_reg(reg);
1723 }
1724 MFCR(r0);
1725 EXTRWI(r0, r0, 1, CR_GT);
1726 }
1727
1728 static void
_gtr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1729 _gtr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1730 {
1731 CMPLW(r1, r2);
1732 MFCR(r0);
1733 EXTRWI(r0, r0, 1, CR_GT);
1734 }
1735
1736 static void
_gti_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1737 _gti_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1738 {
1739 jit_int32_t reg;
1740 if (can_zero_extend_short_p(i0))
1741 CMPLWI(r1, i0);
1742 else {
1743 reg = jit_get_reg(jit_class_gpr);
1744 movi(rn(reg), i0);
1745 CMPLW(r1, rn(reg));
1746 jit_unget_reg(reg);
1747 }
1748 MFCR(r0);
1749 EXTRWI(r0, r0, 1, CR_GT);
1750 }
1751
1752 static void
_ner(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)1753 _ner(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1754 {
1755 CMPW(r1, r2);
1756 CRNOT(CR_EQ, CR_EQ);
1757 MFCR(r0);
1758 EXTRWI(r0, r0, 1, CR_EQ);
1759 }
1760
1761 static void
_nei(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)1762 _nei(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1763 {
1764 jit_int32_t reg;
1765 if (can_sign_extend_short_p(i0))
1766 CMPWI(r1, i0);
1767 else if (can_zero_extend_short_p(i0))
1768 CMPLWI(r1, i0);
1769 else {
1770 reg = jit_get_reg(jit_class_gpr);
1771 movi(rn(reg), i0);
1772 CMPW(r1, rn(reg));
1773 jit_unget_reg(reg);
1774 }
1775 CRNOT(CR_EQ, CR_EQ);
1776 MFCR(r0);
1777 EXTRWI(r0, r0, 1, CR_EQ);
1778 }
1779
1780 static jit_word_t
_bltr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1781 _bltr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1782 {
1783 jit_word_t d, w;
1784 CMPW(r0, r1);
1785 w = _jit->pc.w;
1786 d = (i0 - w) & ~3;
1787 BLT(d);
1788 return (w);
1789 }
1790
1791 static jit_word_t
_blti(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)1792 _blti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1793 {
1794 jit_int32_t reg;
1795 jit_word_t d, w;
1796 if (can_sign_extend_short_p(i1))
1797 CMPWI(r0, i1);
1798 else {
1799 reg = jit_get_reg(jit_class_gpr);
1800 movi(rn(reg), i1);
1801 CMPW(r0, rn(reg));
1802 jit_unget_reg(reg);
1803 }
1804 w = _jit->pc.w;
1805 d = (i0 - w) & ~3;
1806 BLT(d);
1807 return (w);
1808 }
1809
1810 static jit_word_t
_bltr_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1811 _bltr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1812 {
1813 jit_word_t d, w;
1814 CMPLW(r0, r1);
1815 w = _jit->pc.w;
1816 d = (i0 - w) & ~3;
1817 BLT(d);
1818 return (w);
1819 }
1820
1821 static jit_word_t
_blti_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)1822 _blti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1823 {
1824 jit_int32_t reg;
1825 jit_word_t d, w;
1826 if (can_zero_extend_short_p(i1))
1827 CMPLWI(r0, i1);
1828 else {
1829 reg = jit_get_reg(jit_class_gpr);
1830 movi(rn(reg), i1);
1831 CMPLW(r0, rn(reg));
1832 jit_unget_reg(reg);
1833 }
1834 w = _jit->pc.w;
1835 d = (i0 - w) & ~3;
1836 BLT(d);
1837 return (w);
1838 }
1839
1840 static jit_word_t
_bler(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1841 _bler(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1842 {
1843 jit_word_t d, w;
1844 CMPW(r0, r1);
1845 w = _jit->pc.w;
1846 d = (i0 - w) & ~3;
1847 BLE(d);
1848 return (w);
1849 }
1850
1851 static jit_word_t
_blei(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)1852 _blei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1853 {
1854 jit_int32_t reg;
1855 jit_word_t d, w;
1856 if (can_sign_extend_short_p(i1))
1857 CMPWI(r0, i1);
1858 else {
1859 reg = jit_get_reg(jit_class_gpr);
1860 movi(rn(reg), i1);
1861 CMPW(r0, rn(reg));
1862 jit_unget_reg(reg);
1863 }
1864 w = _jit->pc.w;
1865 d = (i0 - w) & ~3;
1866 BLE(d);
1867 return (w);
1868 }
1869
1870 static jit_word_t
_bler_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1871 _bler_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1872 {
1873 jit_word_t d, w;
1874 CMPLW(r0, r1);
1875 w = _jit->pc.w;
1876 d = (i0 - w) & ~3;
1877 BLE(d);
1878 return (w);
1879 }
1880
1881 static jit_word_t
_blei_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)1882 _blei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1883 {
1884 jit_int32_t reg;
1885 jit_word_t d, w;
1886 if (can_zero_extend_short_p(i1))
1887 CMPLWI(r0, i1);
1888 else {
1889 reg = jit_get_reg(jit_class_gpr);
1890 movi(rn(reg), i1);
1891 CMPLW(r0, rn(reg));
1892 jit_unget_reg(reg);
1893 }
1894 w = _jit->pc.w;
1895 d = (i0 - w) & ~3;
1896 BLE(d);
1897 return (w);
1898 }
1899
1900 static jit_word_t
_beqr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1901 _beqr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1902 {
1903 jit_word_t d, w;
1904 CMPW(r0, r1);
1905 w = _jit->pc.w;
1906 d = (i0 - w) & ~3;
1907 BEQ(d);
1908 return (w);
1909 }
1910
1911 static jit_word_t
_beqi(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)1912 _beqi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1913 {
1914 jit_int32_t reg;
1915 jit_word_t d, w;
1916 if (can_sign_extend_short_p(i1))
1917 CMPWI(r0, i1);
1918 else if (can_zero_extend_short_p(i1))
1919 CMPLWI(r0, i1);
1920 else {
1921 reg = jit_get_reg(jit_class_gpr);
1922 movi(rn(reg), i1);
1923 CMPW(r0, rn(reg));
1924 jit_unget_reg(reg);
1925 }
1926 w = _jit->pc.w;
1927 d = (i0 - w) & ~3;
1928 BEQ(d);
1929 return (w);
1930 }
1931
1932 static jit_word_t
_bger(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1933 _bger(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1934 {
1935 jit_word_t d, w;
1936 CMPW(r0, r1);
1937 w = _jit->pc.w;
1938 d = (i0 - w) & ~3;
1939 BGE(d);
1940 return (w);
1941 }
1942
1943 static jit_word_t
_bgei(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)1944 _bgei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1945 {
1946 jit_int32_t reg;
1947 jit_word_t d, w;
1948 if (can_sign_extend_short_p(i1))
1949 CMPWI(r0, i1);
1950 else {
1951 reg = jit_get_reg(jit_class_gpr);
1952 movi(rn(reg), i1);
1953 CMPW(r0, rn(reg));
1954 jit_unget_reg(reg);
1955 }
1956 w = _jit->pc.w;
1957 d = (i0 - w) & ~3;
1958 BGE(d);
1959 return (w);
1960 }
1961
1962 static jit_word_t
_bger_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1963 _bger_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1964 {
1965 jit_word_t d, w;
1966 CMPLW(r0, r1);
1967 w = _jit->pc.w;
1968 d = (i0 - w) & ~3;
1969 BGE(d);
1970 return (w);
1971 }
1972
1973 static jit_word_t
_bgei_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)1974 _bgei_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
1975 {
1976 jit_int32_t reg;
1977 jit_word_t d, w;
1978 if (can_zero_extend_short_p(i1))
1979 CMPLWI(r0, i1);
1980 else {
1981 reg = jit_get_reg(jit_class_gpr);
1982 movi(rn(reg), i1);
1983 CMPLW(r0, rn(reg));
1984 jit_unget_reg(reg);
1985 }
1986 w = _jit->pc.w;
1987 d = (i0 - w) & ~3;
1988 BGE(d);
1989 return (w);
1990 }
1991
1992 static jit_word_t
_bgtr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)1993 _bgtr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1994 {
1995 jit_word_t d, w;
1996 CMPW(r0, r1);
1997 w = _jit->pc.w;
1998 d = (i0 - w) & ~3;
1999 BGT(d);
2000 return (w);
2001 }
2002
2003 static jit_word_t
_bgti(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2004 _bgti(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2005 {
2006 jit_int32_t reg;
2007 jit_word_t d, w;
2008 if (can_sign_extend_short_p(i1))
2009 CMPWI(r0, i1);
2010 else {
2011 reg = jit_get_reg(jit_class_gpr);
2012 movi(rn(reg), i1);
2013 CMPW(r0, rn(reg));
2014 jit_unget_reg(reg);
2015 }
2016 w = _jit->pc.w;
2017 d = (i0 - w) & ~3;
2018 BGT(d);
2019 return (w);
2020 }
2021
2022 static jit_word_t
_bgtr_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2023 _bgtr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2024 {
2025 jit_word_t d, w;
2026 CMPLW(r0, r1);
2027 w = _jit->pc.w;
2028 d = (i0 - w) & ~3;
2029 BGT(d);
2030 return (w);
2031 }
2032
2033 static jit_word_t
_bgti_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2034 _bgti_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2035 {
2036 jit_int32_t reg;
2037 jit_word_t d, w;
2038 if (can_zero_extend_short_p(i1))
2039 CMPLWI(r0, i1);
2040 else {
2041 reg = jit_get_reg(jit_class_gpr);
2042 movi(rn(reg), i1);
2043 CMPLW(r0, rn(reg));
2044 jit_unget_reg(reg);
2045 }
2046 w = _jit->pc.w;
2047 d = (i0 - w) & ~3;
2048 BGT(d);
2049 return (w);
2050 }
2051
2052 static jit_word_t
_bner(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2053 _bner(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2054 {
2055 jit_word_t d, w;
2056 CMPW(r0, r1);
2057 w = _jit->pc.w;
2058 d = (i0 - w) & ~3;
2059 BNE(d);
2060 return (w);
2061 }
2062
2063 static jit_word_t
_bnei(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2064 _bnei(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2065 {
2066 jit_int32_t reg;
2067 jit_word_t d, w;
2068 if (can_sign_extend_short_p(i1))
2069 CMPWI(r0, i1);
2070 else if (can_zero_extend_short_p(i1))
2071 CMPLWI(r0, i1);
2072 else {
2073 reg = jit_get_reg(jit_class_gpr);
2074 movi(rn(reg), i1);
2075 CMPW(r0, rn(reg));
2076 jit_unget_reg(reg);
2077 }
2078 w = _jit->pc.w;
2079 d = (i0 - w) & ~3;
2080 BNE(d);
2081 return (w);
2082 }
2083
2084 static jit_word_t
_bmsr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2085 _bmsr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2086 {
2087 jit_word_t w;
2088 jit_int32_t reg;
2089 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2090 andr(rn(reg), r0, r1);
2091 w = bnei(i0, rn(reg), 0);
2092 jit_unget_reg(reg);
2093 return (w);
2094 }
2095
2096 static jit_word_t
_bmsi(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2097 _bmsi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2098 {
2099 jit_word_t w;
2100 jit_int32_t reg;
2101 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2102 andi(rn(reg), r0, i1);
2103 w = bnei(i0, rn(reg), 0);
2104 jit_unget_reg(reg);
2105 return (w);
2106 }
2107
2108 static jit_word_t
_bmcr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2109 _bmcr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2110 {
2111 jit_word_t w;
2112 jit_int32_t reg;
2113 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2114 andr(rn(reg), r0, r1);
2115 w = beqi(i0, rn(reg), 0);
2116 jit_unget_reg(reg);
2117 return (w);
2118 }
2119
2120 static jit_word_t
_bmci(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2121 _bmci(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2122 {
2123 jit_word_t w;
2124 jit_int32_t reg;
2125 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2126 andi(rn(reg), r0, i1);
2127 w = beqi(i0, rn(reg), 0);
2128 jit_unget_reg(reg);
2129 return (w);
2130 }
2131
2132 static jit_word_t
_boaddr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2133 _boaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2134 {
2135 jit_word_t d, w;
2136 ADDO(r0, r0, r1);
2137 MCRXR(CR_0);
2138 w = _jit->pc.w;
2139 d = (i0 - w) & ~3;
2140 BGT(d); /* GT = bit 1 of XER = OV */
2141 return (w);
2142 }
2143
2144 static jit_word_t
_boaddi(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2145 _boaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2146 {
2147 jit_word_t w;
2148 jit_int32_t reg;
2149 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2150 movi(rn(reg), i1);
2151 w = boaddr(i0, r0, rn(reg));
2152 jit_unget_reg(reg);
2153 return (w);
2154 }
2155
2156 static jit_word_t
_bxaddr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2157 _bxaddr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2158 {
2159 jit_word_t d, w;
2160 ADDO(r0, r0, r1);
2161 MCRXR(CR_0);
2162 w = _jit->pc.w;
2163 d = (i0 - w) & ~3;
2164 BLE(d);
2165 return (w);
2166 }
2167
2168 static jit_word_t
_bxaddi(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2169 _bxaddi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2170 {
2171 jit_word_t w;
2172 jit_int32_t reg;
2173 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2174 movi(rn(reg), i1);
2175 w = bxaddr(i0, r0, rn(reg));
2176 jit_unget_reg(reg);
2177 return (w);
2178 }
2179
2180 static jit_word_t
_bosubr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2181 _bosubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2182 {
2183 jit_word_t d, w;
2184 SUBO(r0, r0, r1);
2185 MCRXR(CR_0);
2186 w = _jit->pc.w;
2187 d = (i0 - w) & ~3;
2188 BGT(d);
2189 return (w);
2190 }
2191
2192 static jit_word_t
_bosubi(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2193 _bosubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2194 {
2195 jit_word_t w;
2196 jit_int32_t reg;
2197 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2198 movi(rn(reg), i1);
2199 w = bosubr(i0, r0, rn(reg));
2200 jit_unget_reg(reg);
2201 return (w);
2202 }
2203
2204 static jit_word_t
_bxsubr(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2205 _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2206 {
2207 jit_word_t d, w;
2208 SUBO(r0, r0, r1);
2209 MCRXR(CR_0);
2210 w = _jit->pc.w;
2211 d = (i0 - w) & ~3;
2212 BLE(d);
2213 return (w);
2214 }
2215
2216 static jit_word_t
_bxsubi(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2217 _bxsubi(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2218 {
2219 jit_word_t w;
2220 jit_int32_t reg;
2221 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2222 movi(rn(reg), i1);
2223 w = bxsubr(i0, r0, rn(reg));
2224 jit_unget_reg(reg);
2225 return (w);
2226 }
2227
2228 static jit_word_t
_boaddr_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2229 _boaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2230 {
2231 jit_word_t d, w;
2232 ADDC(r0, r0, r1);
2233 MCRXR(CR_0);
2234 w = _jit->pc.w;
2235 d = (i0 - w) & ~3;
2236 BEQ(d); /* EQ = bit 2 of XER = CA */
2237 return (w);
2238 }
2239
2240 static jit_word_t
_boaddi_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2241 _boaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2242 {
2243 jit_int32_t reg;
2244 jit_word_t d, w;
2245 if (can_sign_extend_short_p(i1)) {
2246 ADDIC(r0, r0, i1);
2247 MCRXR(CR_0);
2248 w = _jit->pc.w;
2249 d = (i0 - w) & ~3;
2250 BEQ(d);
2251 return (w);
2252 }
2253 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2254 movi(rn(reg), i1);
2255 w = boaddr_u(i0, r0, rn(reg));
2256 jit_unget_reg(reg);
2257 return (w);
2258 }
2259
2260 static jit_word_t
_bxaddr_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2261 _bxaddr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2262 {
2263 jit_word_t d, w;
2264 ADDC(r0, r0, r1);
2265 MCRXR(CR_0);
2266 w = _jit->pc.w;
2267 d = (i0 - w) & ~3;
2268 BNE(d);
2269 return (w);
2270 }
2271
2272 static jit_word_t
_bxaddi_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2273 _bxaddi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2274 {
2275 jit_int32_t reg;
2276 jit_word_t d, w;
2277 if (can_sign_extend_short_p(i1)) {
2278 ADDIC(r0, r0, i1);
2279 MCRXR(CR_0);
2280 w = _jit->pc.w;
2281 d = (i0 - w) & ~3;
2282 BNE(d);
2283 return (w);
2284 }
2285 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2286 movi(rn(reg), i1);
2287 w = bxaddr_u(i0, r0, rn(reg));
2288 jit_unget_reg(reg);
2289 return (w);
2290 }
2291
2292 static jit_word_t
_bosubr_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2293 _bosubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2294 {
2295 jit_word_t d, w;
2296 SUBC(r0, r0, r1);
2297 MCRXR(CR_0);
2298 w = _jit->pc.w;
2299 d = (i0 - w) & ~3;
2300 BNE(d); /* PPC uses "carry" not "borrow" */
2301 return (w);
2302 }
2303
2304 static jit_word_t
_bosubi_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2305 _bosubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2306 {
2307 jit_word_t w;
2308 jit_int32_t reg;
2309 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2310 movi(rn(reg), i1);
2311 w = bosubr_u(i0, r0, rn(reg));
2312 jit_unget_reg(reg);
2313 return (w);
2314 }
2315
2316 static jit_word_t
_bxsubr_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2317 _bxsubr_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2318 {
2319 jit_word_t d, w;
2320 SUBC(r0, r0, r1);
2321 MCRXR(CR_0);
2322 w = _jit->pc.w;
2323 d = (i0 - w) & ~3;
2324 BEQ(d);
2325 return (w);
2326 }
2327
2328 static jit_word_t
_bxsubi_u(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2329 _bxsubi_u(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2330 {
2331 jit_word_t w;
2332 jit_int32_t reg;
2333 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2334 movi(rn(reg), i1);
2335 w = bxsubr_u(i0, r0, rn(reg));
2336 jit_unget_reg(reg);
2337 return (w);
2338 }
2339
2340 static void
_ldr_c(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)2341 _ldr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2342 {
2343 ldr_uc(r0, r1);
2344 extr_c(r0, r0);
2345 }
2346
2347 static void
_ldi_c(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2348 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2349 {
2350 ldi_uc(r0, i0);
2351 extr_c(r0, r0);
2352 }
2353
2354 static void
_ldxr_c(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2355 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2356 {
2357 ldxr_uc(r0, r1, r2);
2358 extr_c(r0, r0);
2359 }
2360
2361 static void
_ldxi_c(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2362 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2363 {
2364 ldxi_uc(r0, r1, i0);
2365 extr_c(r0, r0);
2366 }
2367
2368 static void
_ldi_uc(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2369 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2370 {
2371 jit_bool_t inv;
2372 jit_int32_t reg;
2373 jit_word_t lo, hi;
2374 if (can_sign_extend_short_p(i0))
2375 LBZ(r0, _R0_REGNO, i0);
2376 else if (can_sign_extend_int_p(i0)) {
2377 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2378 lo = (jit_int16_t)(i0 - (hi << 16));
2379 reg = jit_get_reg(jit_class_gpr);
2380 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2381 LIS(rn(reg), hi);
2382 LBZ(r0, rn(reg), lo);
2383 jit_unget_reg(reg);
2384 if (inv) jit_unget_reg(_R0);
2385 }
2386 else {
2387 reg = jit_get_reg(jit_class_gpr);
2388 movi(rn(reg), i0);
2389 ldr_uc(r0, rn(reg));
2390 jit_unget_reg(reg);
2391 }
2392 }
2393
2394 static void
_ldxr_uc(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2395 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2396 {
2397 jit_int32_t reg;
2398 if (r1 == _R0_REGNO) {
2399 if (r2 != _R0_REGNO)
2400 LBZX(r0, r2, r1);
2401 else {
2402 reg = jit_get_reg(jit_class_gpr);
2403 movr(rn(reg), r1);
2404 LBZX(r0, rn(reg), r2);
2405 jit_unget_reg(reg);
2406 }
2407 }
2408 else
2409 LBZX(r0, r1, r2);
2410 }
2411
2412 static void
_ldxi_uc(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2413 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2414 {
2415 jit_int32_t reg;
2416 if (i0 == 0)
2417 ldr_uc(r0, r1);
2418 else if (can_sign_extend_short_p(i0)) {
2419 if (r1 == _R0_REGNO) {
2420 reg = jit_get_reg(jit_class_gpr);
2421 movr(rn(reg), r1);
2422 LBZ(r0, rn(reg), i0);
2423 jit_unget_reg(reg);
2424 }
2425 else
2426 LBZ(r0, r1, i0);
2427 }
2428 else {
2429 reg = jit_get_reg(jit_class_gpr);
2430 movi(rn(reg), i0);
2431 ldxr_uc(r0, r1, rn(reg));
2432 jit_unget_reg(reg);
2433 }
2434 }
2435
2436 static void
_ldi_s(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2437 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2438 {
2439 jit_bool_t inv;
2440 jit_int32_t reg;
2441 jit_word_t lo, hi;
2442 if (can_sign_extend_short_p(i0))
2443 LHA(r0, _R0_REGNO, i0);
2444 else if (can_sign_extend_int_p(i0)) {
2445 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2446 lo = (jit_int16_t)(i0 - (hi << 16));
2447 reg = jit_get_reg(jit_class_gpr);
2448 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2449 LIS(rn(reg), hi);
2450 LHA(r0, rn(reg), lo);
2451 jit_unget_reg(reg);
2452 if (inv) jit_unget_reg(_R0);
2453 }
2454 else {
2455 reg = jit_get_reg(jit_class_gpr);
2456 movi(rn(reg), i0);
2457 ldr_s(r0, rn(reg));
2458 jit_unget_reg(reg);
2459 }
2460 }
2461
2462 static void
_ldxr_s(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2463 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2464 {
2465 jit_int32_t reg;
2466 if (r1 == _R0_REGNO) {
2467 if (r2 != _R0_REGNO)
2468 LHAX(r0, r2, r1);
2469 else {
2470 reg = jit_get_reg(jit_class_gpr);
2471 movr(rn(reg), r1);
2472 LHAX(r0, rn(reg), r2);
2473 jit_unget_reg(reg);
2474 }
2475 }
2476 else
2477 LHAX(r0, r1, r2);
2478 }
2479
2480 static void
_ldxi_s(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2481 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2482 {
2483 jit_int32_t reg;
2484 if (i0 == 0)
2485 ldr_s(r0, r1);
2486 else if (can_sign_extend_short_p(i0)) {
2487 if (r1 == _R0_REGNO) {
2488 reg = jit_get_reg(jit_class_gpr);
2489 movr(rn(reg), r1);
2490 LHA(r0, rn(reg), i0);
2491 jit_unget_reg(reg);
2492 }
2493 else
2494 LHA(r0, r1, i0);
2495 }
2496 else {
2497 reg = jit_get_reg(jit_class_gpr);
2498 movi(rn(reg), i0);
2499 ldxr_s(r0, r1, rn(reg));
2500 jit_unget_reg(reg);
2501 }
2502 }
2503
2504 static void
_ldi_us(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2505 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2506 {
2507 jit_bool_t inv;
2508 jit_int32_t reg;
2509 jit_word_t lo, hi;
2510 if (can_sign_extend_short_p(i0))
2511 LHZ(r0, _R0_REGNO, i0);
2512 else if (can_sign_extend_int_p(i0)) {
2513 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2514 lo = (jit_int16_t)(i0 - (hi << 16));
2515 reg = jit_get_reg(jit_class_gpr);
2516 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2517 LIS(rn(reg), hi);
2518 LHZ(r0, rn(reg), lo);
2519 jit_unget_reg(reg);
2520 if (inv) jit_unget_reg(_R0);
2521 }
2522 else {
2523 reg = jit_get_reg(jit_class_gpr);
2524 movi(rn(reg), i0);
2525 ldr_us(r0, rn(reg));
2526 jit_unget_reg(reg);
2527 }
2528 }
2529
2530 static void
_ldxr_us(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2531 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2532 {
2533 jit_int32_t reg;
2534 if (r1 == _R0_REGNO) {
2535 if (r2 != _R0_REGNO)
2536 LHZX(r0, r2, r1);
2537 else {
2538 reg = jit_get_reg(jit_class_gpr);
2539 movr(rn(reg), r1);
2540 LHZX(r0, rn(reg), r2);
2541 jit_unget_reg(reg);
2542 }
2543 }
2544 else
2545 LHZX(r0, r1, r2);
2546 }
2547
2548 static void
_ldxi_us(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2549 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2550 {
2551 jit_int32_t reg;
2552 if (i0 == 0)
2553 ldr_us(r0, r1);
2554 else if (can_sign_extend_short_p(i0)) {
2555 if (r1 == _R0_REGNO) {
2556 reg = jit_get_reg(jit_class_gpr);
2557 movr(rn(reg), r1);
2558 LHZ(r0, rn(reg), i0);
2559 jit_unget_reg(reg);
2560 }
2561 else
2562 LHZ(r0, r1, i0);
2563 }
2564 else {
2565 reg = jit_get_reg(jit_class_gpr);
2566 movi(rn(reg), i0);
2567 ldxr_us(r0, r1, rn(reg));
2568 jit_unget_reg(reg);
2569 }
2570 }
2571
2572 # if __WORDSIZE == 32
2573 static void
_ldi_i(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2574 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2575 {
2576 jit_bool_t inv;
2577 jit_int32_t reg;
2578 jit_word_t lo, hi;
2579 if (can_sign_extend_short_p(i0))
2580 LWZ(r0, _R0_REGNO, i0);
2581 else if (can_sign_extend_int_p(i0)) {
2582 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2583 lo = (jit_int16_t)(i0 - (hi << 16));
2584 reg = jit_get_reg(jit_class_gpr);
2585 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2586 LIS(rn(reg), hi);
2587 LWZ(r0, rn(reg), lo);
2588 jit_unget_reg(reg);
2589 if (inv) jit_unget_reg(_R0);
2590 }
2591 else {
2592 reg = jit_get_reg(jit_class_gpr);
2593 movi(rn(reg), i0);
2594 ldr_i(r0, rn(reg));
2595 jit_unget_reg(reg);
2596 }
2597 }
2598
2599 static void
_ldxr_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2600 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2601 {
2602 jit_int32_t reg;
2603 if (r1 == _R0_REGNO) {
2604 if (r2 != _R0_REGNO)
2605 LWZX(r0, r2, r1);
2606 else {
2607 reg = jit_get_reg(jit_class_gpr);
2608 movr(rn(reg), r1);
2609 LWZX(r0, rn(reg), r2);
2610 jit_unget_reg(reg);
2611 }
2612 }
2613 else
2614 LWZX(r0, r1, r2);
2615 }
2616
2617 static void
_ldxi_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2618 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2619 {
2620 jit_int32_t reg;
2621 if (i0 == 0)
2622 ldr_i(r0, r1);
2623 else if (can_sign_extend_short_p(i0)) {
2624 if (r1 == _R0_REGNO) {
2625 reg = jit_get_reg(jit_class_gpr);
2626 movr(rn(reg), r1);
2627 LWZ(r0, rn(reg), i0);
2628 jit_unget_reg(reg);
2629 }
2630 else
2631 LWZ(r0, r1, i0);
2632 }
2633 else {
2634 reg = jit_get_reg(jit_class_gpr);
2635 movi(rn(reg), i0);
2636 ldxr_i(r0, r1, rn(reg));
2637 jit_unget_reg(reg);
2638 }
2639 }
2640
2641 # else
2642 static void
_ldi_i(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2643 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2644 {
2645 jit_bool_t inv;
2646 jit_int32_t reg;
2647 jit_word_t lo, hi;
2648 if (can_sign_extend_short_p(i0))
2649 LWA(r0, _R0_REGNO, i0);
2650 else if (can_sign_extend_int_p(i0)) {
2651 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2652 lo = (jit_int16_t)(i0 - (hi << 16));
2653 reg = jit_get_reg(jit_class_gpr);
2654 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2655 LIS(rn(reg), hi);
2656 LWA(r0, rn(reg), lo);
2657 jit_unget_reg(reg);
2658 if (inv) jit_unget_reg(_R0);
2659 }
2660 else {
2661 reg = jit_get_reg(jit_class_gpr);
2662 movi(rn(reg), i0);
2663 ldr_i(r0, rn(reg));
2664 jit_unget_reg(reg);
2665 }
2666 }
2667
2668 static void
_ldxr_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2669 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2670 {
2671 jit_int32_t reg;
2672 if (r1 == _R0_REGNO) {
2673 if (r2 != _R0_REGNO)
2674 LWZX(r0, r2, r1);
2675 else {
2676 reg = jit_get_reg(jit_class_gpr);
2677 movr(rn(reg), r1);
2678 LWAX(r0, rn(reg), r2);
2679 jit_unget_reg(reg);
2680 }
2681 }
2682 else
2683 LWZX(r0, r1, r2);
2684 }
2685
2686 static void
_ldxi_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2687 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2688 {
2689 jit_int32_t reg;
2690 if (i0 == 0)
2691 ldr_i(r0, r1);
2692 else if (can_sign_extend_short_p(i0)) {
2693 if (r1 == _R0_REGNO) {
2694 reg = jit_get_reg(jit_class_gpr);
2695 movr(rn(reg), r1);
2696 LWA(r0, rn(reg), i0);
2697 jit_unget_reg(reg);
2698 }
2699 else
2700 LWA(r0, r1, i0);
2701 }
2702 else {
2703 reg = jit_get_reg(jit_class_gpr);
2704 movi(rn(reg), i0);
2705 ldxr_i(r0, r1, rn(reg));
2706 jit_unget_reg(reg);
2707 }
2708 }
2709
2710 static void
_ldi_ui(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2711 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2712 {
2713 jit_bool_t inv;
2714 jit_int32_t reg;
2715 jit_word_t lo, hi;
2716 if (can_sign_extend_short_p(i0))
2717 LWZ(r0, _R0_REGNO, i0);
2718 else if (can_sign_extend_int_p(i0)) {
2719 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2720 lo = (jit_int16_t)(i0 - (hi << 16));
2721 reg = jit_get_reg(jit_class_gpr);
2722 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2723 LIS(rn(reg), hi);
2724 LWZ(r0, rn(reg), lo);
2725 jit_unget_reg(reg);
2726 if (inv) jit_unget_reg(_R0);
2727 }
2728 else {
2729 reg = jit_get_reg(jit_class_gpr);
2730 movi(rn(reg), i0);
2731 ldr_ui(r0, rn(reg));
2732 jit_unget_reg(reg);
2733 }
2734 }
2735
2736 static void
_ldxr_ui(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2737 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2738 {
2739 jit_int32_t reg;
2740 if (r1 == _R0_REGNO) {
2741 if (r2 != _R0_REGNO)
2742 LWZX(r0, r2, r1);
2743 else {
2744 reg = jit_get_reg(jit_class_gpr);
2745 movr(rn(reg), r1);
2746 LWZX(r0, rn(reg), r2);
2747 jit_unget_reg(reg);
2748 }
2749 }
2750 else
2751 LWZX(r0, r1, r2);
2752 }
2753
2754 static void
_ldxi_ui(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2755 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2756 {
2757 jit_int32_t reg;
2758 if (i0 == 0)
2759 ldr_i(r0, r1);
2760 else if (can_sign_extend_short_p(i0)) {
2761 if (r1 == _R0_REGNO) {
2762 reg = jit_get_reg(jit_class_gpr);
2763 movr(rn(reg), r1);
2764 LWZ(r0, rn(reg), i0);
2765 jit_unget_reg(reg);
2766 }
2767 else
2768 LWZ(r0, r1, i0);
2769 }
2770 else {
2771 reg = jit_get_reg(jit_class_gpr);
2772 movi(rn(reg), i0);
2773 ldxr_ui(r0, r1, rn(reg));
2774 jit_unget_reg(reg);
2775 }
2776 }
2777
2778 static void
_ldi_l(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2779 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2780 {
2781 jit_bool_t inv;
2782 jit_int32_t reg;
2783 jit_word_t lo, hi;
2784 if (can_sign_extend_short_p(i0))
2785 LD(r0, _R0_REGNO, i0);
2786 else if (can_sign_extend_int_p(i0)) {
2787 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2788 lo = (jit_int16_t)(i0 - (hi << 16));
2789 reg = jit_get_reg(jit_class_gpr);
2790 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2791 LIS(rn(reg), hi);
2792 LD(r0, rn(reg), lo);
2793 jit_unget_reg(reg);
2794 if (inv) jit_unget_reg(_R0);
2795 }
2796 else {
2797 reg = jit_get_reg(jit_class_gpr);
2798 movi(rn(reg), i0);
2799 ldr_l(r0, rn(reg));
2800 jit_unget_reg(reg);
2801 }
2802 }
2803
2804 static void
_ldxr_l(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2805 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2806 {
2807 jit_int32_t reg;
2808 if (r1 == _R0_REGNO) {
2809 if (r2 != _R0_REGNO)
2810 LDX(r0, r2, r1);
2811 else {
2812 reg = jit_get_reg(jit_class_gpr);
2813 movr(rn(reg), r1);
2814 LDX(r0, rn(reg), r2);
2815 jit_unget_reg(reg);
2816 }
2817 }
2818 else
2819 LDX(r0, r1, r2);
2820 }
2821
2822 static void
_ldxi_l(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2823 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2824 {
2825 jit_int32_t reg;
2826 if (i0 == 0)
2827 ldr_l(r0, r1);
2828 else if (can_sign_extend_short_p(i0)) {
2829 if (r1 == _R0_REGNO) {
2830 reg = jit_get_reg(jit_class_gpr);
2831 movr(rn(reg), r1);
2832 LD(r0, rn(reg), i0);
2833 jit_unget_reg(reg);
2834 }
2835 else
2836 LD(r0, r1, i0);
2837 }
2838 else {
2839 reg = jit_get_reg(jit_class_gpr);
2840 movi(rn(reg), i0);
2841 ldxr_l(r0, r1, rn(reg));
2842 jit_unget_reg(reg);
2843 }
2844 }
2845 # endif
2846
2847 static void
_sti_c(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)2848 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2849 {
2850 jit_bool_t inv;
2851 jit_int32_t reg;
2852 jit_word_t lo, hi;
2853 if (can_sign_extend_short_p(i0))
2854 STB(r0, _R0_REGNO, i0);
2855 else if (can_sign_extend_int_p(i0)) {
2856 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2857 lo = (jit_int16_t)(i0 - (hi << 16));
2858 reg = jit_get_reg(jit_class_gpr);
2859 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2860 LIS(rn(reg), hi);
2861 STB(r0, rn(reg), lo);
2862 jit_unget_reg(reg);
2863 if (inv) jit_unget_reg(_R0);
2864 }
2865 else {
2866 reg = jit_get_reg(jit_class_gpr);
2867 movi(rn(reg), i0);
2868 str_c(rn(reg), r0);
2869 jit_unget_reg(reg);
2870 }
2871 }
2872
2873 static void
_stxr_c(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2874 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2875 {
2876 jit_int32_t reg;
2877 if (r0 == _R0_REGNO) {
2878 if (r1 != _R0_REGNO)
2879 STBX(r2, r1, r0);
2880 else {
2881 reg = jit_get_reg(jit_class_gpr);
2882 movr(rn(reg), r0);
2883 STBX(r2, rn(reg), r1);
2884 jit_unget_reg(reg);
2885 }
2886 }
2887 else
2888 STBX(r2, r0, r1);
2889 }
2890
2891 static void
_stxi_c(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2892 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2893 {
2894 jit_int32_t reg;
2895 if (i0 == 0)
2896 str_c(r0, r1);
2897 else if (can_sign_extend_short_p(i0)) {
2898 if (r0 == _R0_REGNO) {
2899 reg = jit_get_reg(jit_class_gpr);
2900 movr(rn(reg), i0);
2901 STB(r1, rn(reg), i0);
2902 jit_unget_reg(reg);
2903 }
2904 else
2905 STB(r1, r0, i0);
2906 }
2907 else {
2908 reg = jit_get_reg(jit_class_gpr);
2909 movi(rn(reg), i0);
2910 stxr_c(rn(reg), r0, r1);
2911 jit_unget_reg(reg);
2912 }
2913 }
2914
2915 static void
_sti_s(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)2916 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2917 {
2918 jit_bool_t inv;
2919 jit_int32_t reg;
2920 jit_word_t lo, hi;
2921 if (can_sign_extend_short_p(i0))
2922 STH(r0, _R0_REGNO, i0);
2923 else if (can_sign_extend_int_p(i0)) {
2924 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2925 lo = (jit_int16_t)(i0 - (hi << 16));
2926 reg = jit_get_reg(jit_class_gpr);
2927 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2928 LIS(rn(reg), hi);
2929 STH(r0, rn(reg), lo);
2930 jit_unget_reg(reg);
2931 if (inv) jit_unget_reg(_R0);
2932 }
2933 else {
2934 reg = jit_get_reg(jit_class_gpr);
2935 movi(rn(reg), i0);
2936 str_s(rn(reg), r0);
2937 jit_unget_reg(reg);
2938 }
2939 }
2940
2941 static void
_stxr_s(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2942 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2943 {
2944 jit_int32_t reg;
2945 if (r0 == _R0_REGNO) {
2946 if (r1 != _R0_REGNO)
2947 STHX(r2, r1, r0);
2948 else {
2949 reg = jit_get_reg(jit_class_gpr);
2950 movr(rn(reg), r0);
2951 STHX(r2, rn(reg), r1);
2952 jit_unget_reg(reg);
2953 }
2954 }
2955 else
2956 STHX(r2, r0, r1);
2957 }
2958
2959 static void
_stxi_s(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2960 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2961 {
2962 jit_int32_t reg;
2963 if (i0 == 0)
2964 str_s(r0, r1);
2965 else if (can_sign_extend_short_p(i0)) {
2966 if (r0 == _R0_REGNO) {
2967 reg = jit_get_reg(jit_class_gpr);
2968 movr(rn(reg), i0);
2969 STH(r1, rn(reg), i0);
2970 jit_unget_reg(reg);
2971 }
2972 else
2973 STH(r1, r0, i0);
2974 }
2975 else {
2976 reg = jit_get_reg(jit_class_gpr);
2977 movi(rn(reg), i0);
2978 stxr_s(rn(reg), r0, r1);
2979 jit_unget_reg(reg);
2980 }
2981 }
2982
2983 static void
_sti_i(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)2984 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2985 {
2986 jit_bool_t inv;
2987 jit_int32_t reg;
2988 jit_word_t lo, hi;
2989 if (can_sign_extend_short_p(i0))
2990 STW(r0, _R0_REGNO, i0);
2991 else if (can_sign_extend_int_p(i0)) {
2992 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
2993 lo = (jit_int16_t)(i0 - (hi << 16));
2994 reg = jit_get_reg(jit_class_gpr);
2995 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
2996 LIS(rn(reg), hi);
2997 STW(r0, rn(reg), lo);
2998 jit_unget_reg(reg);
2999 if (inv) jit_unget_reg(_R0);
3000 }
3001 else {
3002 reg = jit_get_reg(jit_class_gpr);
3003 movi(rn(reg), i0);
3004 str_i(rn(reg), r0);
3005 jit_unget_reg(reg);
3006 }
3007 }
3008
3009 static void
_stxr_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3010 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3011 {
3012 jit_int32_t reg;
3013 if (r0 == _R0_REGNO) {
3014 if (r1 != _R0_REGNO)
3015 STWX(r2, r1, r0);
3016 else {
3017 reg = jit_get_reg(jit_class_gpr);
3018 movr(rn(reg), r0);
3019 STWX(r2, rn(reg), r1);
3020 jit_unget_reg(reg);
3021 }
3022 }
3023 else
3024 STWX(r2, r0, r1);
3025 }
3026
3027 static void
_stxi_i(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)3028 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3029 {
3030 jit_int32_t reg;
3031 if (i0 == 0)
3032 str_i(r0, r1);
3033 else if (can_sign_extend_short_p(i0)) {
3034 if (r0 == _R0_REGNO) {
3035 reg = jit_get_reg(jit_class_gpr);
3036 movr(rn(reg), i0);
3037 STW(r1, rn(reg), i0);
3038 jit_unget_reg(reg);
3039 }
3040 else
3041 STW(r1, r0, i0);
3042 }
3043 else {
3044 reg = jit_get_reg(jit_class_gpr);
3045 movi(rn(reg), i0);
3046 stxr_i(rn(reg), r0, r1);
3047 jit_unget_reg(reg);
3048 }
3049 }
3050
3051 # if __WORDSIZE == 64
3052 static void
_sti_l(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)3053 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3054 {
3055 jit_bool_t inv;
3056 jit_int32_t reg;
3057 jit_word_t lo, hi;
3058 if (can_sign_extend_short_p(i0))
3059 STD(r0, _R0_REGNO, i0);
3060 else if (can_sign_extend_int_p(i0)) {
3061 hi = (jit_int16_t)((i0 >> 16) + ((jit_uint16_t)i0 >> 15));
3062 lo = (jit_int16_t)(i0 - (hi << 16));
3063 reg = jit_get_reg(jit_class_gpr);
3064 if ((inv = reg == _R0)) reg = jit_get_reg(jit_class_gpr);
3065 LIS(rn(reg), hi);
3066 STD(r0, rn(reg), lo);
3067 jit_unget_reg(reg);
3068 if (inv) jit_unget_reg(_R0);
3069 }
3070 else {
3071 reg = jit_get_reg(jit_class_gpr);
3072 movi(rn(reg), i0);
3073 str_l(rn(reg), r0);
3074 jit_unget_reg(reg);
3075 }
3076 }
3077
3078 static void
_stxr_l(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3079 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3080 {
3081 jit_int32_t reg;
3082 if (r0 == _R0_REGNO) {
3083 if (r1 != _R0_REGNO)
3084 STDX(r2, r1, r0);
3085 else {
3086 reg = jit_get_reg(jit_class_gpr);
3087 movr(rn(reg), r0);
3088 STDX(r2, rn(reg), r1);
3089 jit_unget_reg(reg);
3090 }
3091 }
3092 else
3093 STDX(r2, r0, r1);
3094 }
3095
3096 static void
_stxi_l(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)3097 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3098 {
3099 jit_int32_t reg;
3100 if (i0 == 0)
3101 str_l(r0, r1);
3102 else if (can_sign_extend_short_p(i0)) {
3103 if (r0 == _R0_REGNO) {
3104 reg = jit_get_reg(jit_class_gpr);
3105 movr(rn(reg), i0);
3106 STD(r1, rn(reg), i0);
3107 jit_unget_reg(reg);
3108 }
3109 else
3110 STD(r1, r0, i0);
3111 }
3112 else {
3113 reg = jit_get_reg(jit_class_gpr);
3114 movi(rn(reg), i0);
3115 stxr_l(rn(reg), r0, r1);
3116 jit_unget_reg(reg);
3117 }
3118 }
3119 # endif
3120
3121 static void
_jmpr(jit_state_t * _jit,jit_int32_t r0)3122 _jmpr(jit_state_t *_jit, jit_int32_t r0)
3123 {
3124 #if 0
3125 MTLR(r0);
3126 BLR();
3127 #else
3128 MTCTR(r0);
3129 BCTR();
3130 #endif
3131 }
3132
3133 /* pc relative jump */
3134 static jit_word_t
_jmpi(jit_state_t * _jit,jit_word_t i0)3135 _jmpi(jit_state_t *_jit, jit_word_t i0)
3136 {
3137 jit_int32_t reg;
3138 jit_word_t w, d;
3139 w = _jit->pc.w;
3140 d = (i0 - w) & ~3;
3141 if (can_sign_extend_jump_p(d))
3142 B(d);
3143 else {
3144 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3145 w = movi_p(rn(reg), i0);
3146 jmpr(rn(reg));
3147 jit_unget_reg(reg);
3148 }
3149 return (w);
3150 }
3151
3152 /* absolute jump */
3153 static jit_word_t
_jmpi_p(jit_state_t * _jit,jit_word_t i0)3154 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3155 {
3156 jit_word_t w;
3157 jit_int32_t reg;
3158 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
3159 w = movi_p(rn(reg), i0);
3160 jmpr(rn(reg));
3161 jit_unget_reg(reg);
3162 return (w);
3163 }
3164
3165 static void
_callr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t varargs)3166 _callr(jit_state_t *_jit, jit_int32_t r0
3167 # if _CALL_SYSV
3168 , jit_int32_t varargs
3169 # endif
3170 )
3171 {
3172 # if _CALL_AIXDESC
3173 stxi(sizeof(void*) * 5, _SP_REGNO, _R2_REGNO);
3174 /* FIXME Pretend to not know about r11? */
3175 if (r0 == _R0_REGNO) {
3176 movr(_R11_REGNO, _R0_REGNO);
3177 ldxi(_R2_REGNO, _R11_REGNO, sizeof(void*));
3178 ldxi(_R11_REGNO, _R11_REGNO, sizeof(void*) * 2);
3179 }
3180 else {
3181 ldxi(_R2_REGNO, r0, sizeof(void*));
3182 ldxi(_R11_REGNO, r0, sizeof(void*) * 2);
3183 }
3184 ldr(r0, r0);
3185 # else
3186 # if _CALL_SYSV
3187 /* Tell double arguments were passed in registers. */
3188 if (varargs)
3189 CREQV(6, 6, 6);
3190 # endif
3191 movr(_R12_REGNO, r0);
3192 # endif
3193
3194 MTCTR(r0);
3195 BCTRL();
3196
3197 # if _CALL_AIXDESC
3198 ldxi(_R2_REGNO, _SP_REGNO, sizeof(void*) * 5);
3199 # endif
3200 }
3201
3202 /* assume fixed address or reachable address */
3203 static void
_calli(jit_state_t * _jit,jit_word_t i0,jit_int32_t varargs)3204 _calli(jit_state_t *_jit, jit_word_t i0
3205 # if _CALL_SYSV
3206 , jit_int32_t varargs
3207 # endif
3208 )
3209 {
3210 # if _CALL_SYSV
3211 jit_word_t d;
3212 d = (i0 - _jit->pc.w) & ~3;
3213 if (can_sign_extend_jump_p(d))
3214 BL(d);
3215 else
3216 # endif
3217 {
3218 movi(_R12_REGNO, i0);
3219 callr(_R12_REGNO
3220 # if _CALL_SYSV
3221 , varargs
3222 # endif
3223 );
3224 }
3225 }
3226
3227 /* absolute jump */
3228 static jit_word_t
_calli_p(jit_state_t * _jit,jit_word_t i0,jit_int32_t varargs)3229 _calli_p(jit_state_t *_jit, jit_word_t i0
3230 # if _CALL_SYSV
3231 , jit_int32_t varargs
3232 # endif
3233 )
3234 {
3235 jit_word_t w;
3236 w = movi_p(_R12_REGNO, i0);
3237 callr(_R12_REGNO
3238 # if _CALL_SYSV
3239 , varargs
3240 # endif
3241 );
3242 return (w);
3243 }
3244
3245 /* order is not guaranteed to be sequential */
3246 static jit_int32_t save[] = {
3247 _R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21, _R22,
3248 _R23, _R24, _R25, _R26, _R27, _R28, _R29, _R30, _R31,
3249 };
3250
3251 static void
_prolog(jit_state_t * _jit,jit_node_t * node)3252 _prolog(jit_state_t *_jit, jit_node_t *node)
3253 {
3254 unsigned long regno;
3255 jit_word_t offset;
3256
3257 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3258 jit_int32_t frame = -_jitc->function->frame;
3259 assert(_jitc->function->self.aoff >= frame);
3260 if (_jitc->function->assume_frame)
3261 return;
3262 _jitc->function->self.aoff = frame;
3263 }
3264 if (_jitc->function->allocar) {
3265 _jitc->function->self.aoff -= 2 * sizeof(jit_word_t);
3266 _jitc->function->self.aoff &= -16;
3267 }
3268 _jitc->function->stack = ((_jitc->function->self.alen +
3269 _jitc->function->self.size -
3270 _jitc->function->self.aoff) + 15) & -16;
3271
3272 /* return address */
3273 MFLR(_R0_REGNO);
3274
3275 /* params >= %r31+params_offset+(8*sizeof(jit_word_t))
3276 * alloca < %r31-80 */
3277
3278 #if _CALL_SYSV
3279 stxi(sizeof(jit_word_t), _SP_REGNO, _R0_REGNO);
3280 #else
3281 stxi(sizeof(void*) * 2, _SP_REGNO, _R0_REGNO);
3282 #endif
3283 offset = -gpr_save_area;
3284 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3285 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3286 stxi(offset, _SP_REGNO, rn(save[regno]));
3287 }
3288 for (offset = 0; offset < 8; offset++) {
3289 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3290 stxi_d(-(gpr_save_area + 8 + offset * 8),
3291 _SP_REGNO, rn(_F14 + offset));
3292 }
3293
3294 stxi(-(sizeof(void*)), _SP_REGNO, _FP_REGNO);
3295
3296 movr(_FP_REGNO, _SP_REGNO);
3297 #if __WORDSIZE == 32
3298 STWU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3299 #else
3300 STDU(_SP_REGNO, _SP_REGNO, -_jitc->function->stack);
3301 #endif
3302
3303 if (_jitc->function->allocar) {
3304 regno = jit_get_reg(jit_class_gpr);
3305 movi(rn(regno), _jitc->function->self.aoff);
3306 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(regno));
3307 jit_unget_reg(regno);
3308 }
3309
3310 #if !_CALL_SYSV
3311 if (_jitc->function->self.call & jit_call_varargs) {
3312 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3313 stxi(params_offset + regno * sizeof(jit_word_t),
3314 _FP_REGNO, rn(JIT_RA0 - regno));
3315 }
3316 #else
3317 if (_jitc->function->self.call & jit_call_varargs) {
3318 for (regno = _jitc->function->vagp; jit_arg_reg_p(regno); ++regno)
3319 stxi(_jitc->function->vaoff + first_gp_offset +
3320 regno * sizeof(jit_word_t), _FP_REGNO, rn(JIT_RA0 - regno));
3321 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3322 stxi_d(_jitc->function->vaoff + first_fp_offset +
3323 regno * va_fp_increment, _FP_REGNO,
3324 rn(JIT_FA0 - regno));
3325 }
3326 #endif
3327 }
3328
3329 static void
_epilog(jit_state_t * _jit,jit_node_t * node)3330 _epilog(jit_state_t *_jit, jit_node_t *node)
3331 {
3332 unsigned long regno;
3333 jit_word_t offset;
3334
3335 if (_jitc->function->assume_frame)
3336 return;
3337 if (_jitc->function->allocar)
3338 ldr(_SP_REGNO, _SP_REGNO);
3339 else
3340 addi(_SP_REGNO, _SP_REGNO, _jitc->function->stack);
3341 #if _CALL_SYSV
3342 ldxi(_R0_REGNO, _SP_REGNO, sizeof(jit_word_t));
3343 #else
3344 ldxi(_R0_REGNO, _SP_REGNO, sizeof(void*) * 2);
3345 #endif
3346 offset = -gpr_save_area;
3347 for (regno = 0; regno < jit_size(save); regno++, offset += sizeof(void*)) {
3348 if (jit_regset_tstbit(&_jitc->function->regset, save[regno]))
3349 ldxi(rn(save[regno]), _SP_REGNO, offset);
3350 }
3351 for (offset = 0; offset < 8; offset++) {
3352 if (jit_regset_tstbit(&_jitc->function->regset, _F14 + offset))
3353 ldxi_d(rn(_F14 + offset), _SP_REGNO,
3354 -(gpr_save_area + 8 + offset * 8));
3355 }
3356
3357 MTLR(_R0_REGNO);
3358 ldxi(_FP_REGNO, _SP_REGNO, -(sizeof(void*)));
3359
3360 BLR();
3361 }
3362
3363 static void
_vastart(jit_state_t * _jit,jit_int32_t r0)3364 _vastart(jit_state_t *_jit, jit_int32_t r0)
3365 {
3366 #if !_CALL_SYSV
3367 assert(_jitc->function->self.call & jit_call_varargs);
3368 /* Initialize stack pointer to the first stack argument. */
3369 addi(r0, _FP_REGNO, _jitc->function->self.size);
3370 #else
3371 jit_int32_t reg;
3372 assert(_jitc->function->self.call & jit_call_varargs);
3373
3374 /* Return jit_va_list_t in the register argument */
3375 addi(r0, _FP_REGNO, _jitc->function->vaoff);
3376 reg = jit_get_reg(jit_class_gpr);
3377
3378 /* Initialize the gp counter. */
3379 movi(rn(reg), _jitc->function->vagp);
3380 stxi_c(offsetof(jit_va_list_t, ngpr), r0, rn(reg));
3381
3382 /* Initialize the fp counter. */
3383 movi(rn(reg), _jitc->function->vafp);
3384 stxi_c(offsetof(jit_va_list_t, nfpr), r0, rn(reg));
3385
3386 /* Initialize overflow pointer to the first stack argument. */
3387 addi(rn(reg), _FP_REGNO, _jitc->function->self.size);
3388 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3389
3390 /* Initialize register save area pointer. */
3391 addi(rn(reg), r0, first_gp_offset);
3392 stxi(offsetof(jit_va_list_t, save), r0, rn(reg));
3393
3394 jit_unget_reg(reg);
3395 #endif
3396 }
3397
3398 static void
_vaarg(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)3399 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3400 {
3401 #if !_CALL_SYSV
3402 assert(_jitc->function->self.call & jit_call_varargs);
3403 /* Load argument. */
3404 ldr(r0, r1);
3405 /* Update va_list. */
3406 addi(r1, r1, sizeof(jit_word_t));
3407 #else
3408 jit_int32_t rg0;
3409 jit_int32_t rg1;
3410 jit_word_t ge_code;
3411 jit_word_t lt_code;
3412
3413 assert(_jitc->function->self.call & jit_call_varargs);
3414
3415 rg0 = jit_get_reg(jit_class_gpr);
3416 rg1 = jit_get_reg(jit_class_gpr);
3417
3418 /* Load the gp offset in save area in the first temporary. */
3419 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, ngpr));
3420
3421 /* Jump over if there are no remaining arguments in the save area. */
3422 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3423
3424 /* Update the gp counter. */
3425 addi(rn(rg1), rn(rg0), 1);
3426 stxi_c(offsetof(jit_va_list_t, ngpr), r1, rn(rg1));
3427
3428 /* Load the save area pointer in the second temporary. */
3429 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3430
3431 /* Load the vararg argument in the first argument. */
3432 lshi(rn(rg0), rn(rg0), va_gp_shift);
3433 ldxr(r0, rn(rg1), rn(rg0));
3434
3435 /* Will only need one temporary register below. */
3436 jit_unget_reg(rg1);
3437
3438 /* Jump over overflow code. */
3439 lt_code = _jit->pc.w;
3440 B(0);
3441
3442 /* Where to land if argument is in overflow area. */
3443 patch_at(ge_code, _jit->pc.w);
3444
3445 /* Load overflow pointer. */
3446 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3447
3448 /* Load argument. */
3449 ldr(r0, rn(rg0));
3450
3451 /* Update overflow pointer. */
3452 addi(rn(rg0), rn(rg0), va_gp_increment);
3453 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3454
3455 /* Where to land if argument is in save area. */
3456 patch_at(lt_code, _jit->pc.w);
3457
3458 jit_unget_reg(rg0);
3459 #endif
3460 }
3461
3462 static void
_vaarg_d(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)3463 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3464 {
3465 #if !_CALL_SYSV
3466 assert(_jitc->function->self.call & jit_call_varargs);
3467 /* Load argument. */
3468 ldr_d(r0, r1);
3469 /* Update va_list. */
3470 addi(r1, r1, sizeof(jit_float64_t));
3471 #else
3472 jit_int32_t rg0;
3473 jit_int32_t rg1;
3474 jit_word_t ge_code;
3475 jit_word_t lt_code;
3476
3477 assert(_jitc->function->self.call & jit_call_varargs);
3478
3479 rg0 = jit_get_reg(jit_class_gpr);
3480 rg1 = jit_get_reg(jit_class_gpr);
3481
3482 /* Load the fp offset in save area in the first temporary. */
3483 ldxi_uc(rn(rg0), r1, offsetof(jit_va_list_t, nfpr));
3484
3485 /* Jump over if there are no remaining arguments in the save area. */
3486 ge_code = bgei(_jit->pc.w, rn(rg0), 8);
3487
3488 /* Update the fp counter. */
3489 addi(rn(rg1), rn(rg0), 1);
3490 stxi_c(offsetof(jit_va_list_t, nfpr), r1, rn(rg1));
3491
3492 /* Load the save area pointer in the second temporary. */
3493 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3494
3495 /* Load the vararg argument in the first argument. */
3496 lshi(rn(rg0), rn(rg0), 3);
3497 addi(rn(rg0), rn(rg0), offsetof(jit_va_list_t, first_fp_argument) -
3498 offsetof(jit_va_list_t, first_gp_argument));
3499 ldxr_d(r0, rn(rg1), rn(rg0));
3500
3501 /* Jump over overflow code. */
3502 lt_code = _jit->pc.w;
3503 B(0);
3504
3505 /* Where to land if argument is in overflow area. */
3506 patch_at(ge_code, _jit->pc.w);
3507
3508 /* Load overflow pointer. */
3509 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3510
3511 # if __WORDSIZE == 32
3512 /* Align if required. */
3513 andi(rn(rg1), rn(rg0), 7);
3514 addr(rn(rg0), rn(rg0), rn(rg1));
3515 # endif
3516
3517 /* Load argument. */
3518 ldr_d(r0, rn(rg0));
3519
3520 /* Update overflow pointer. */
3521 addi(rn(rg0), rn(rg0), va_fp_increment);
3522 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3523
3524 /* Where to land if argument is in save area. */
3525 patch_at(lt_code, _jit->pc.w);
3526
3527 jit_unget_reg(rg0);
3528 jit_unget_reg(rg1);
3529 #endif
3530 }
3531
3532 static void
_patch_at(jit_state_t * _jit,jit_word_t instr,jit_word_t label)3533 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3534 {
3535 jit_word_t d;
3536 union {
3537 jit_int32_t *i;
3538 jit_word_t w;
3539 } u;
3540 u.w = instr;
3541 switch ((u.i[0] & 0xfc000000) >> 26) {
3542 case 16: /* BCx */
3543 d = label - instr;
3544 assert(!(d & 3));
3545 if (!can_sign_extend_short_p(d)) {
3546 /* use absolute address */
3547 assert(can_sign_extend_short_p(label));
3548 d |= 2;
3549 }
3550 u.i[0] = (u.i[0] & ~0xfffd) | (d & 0xfffe);
3551 break;
3552 case 18: /* Bx */
3553 #if _CALL_AIXDESC
3554 if (_jitc->jump && (!(u.i[0] & 1))) { /* jmpi label */
3555 /* zero is used for toc and env, so, quick check
3556 * if this is a "jmpi main" like initial jit
3557 * instruction */
3558 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3559 for (d = 0; d < _jitc->prolog.offset; d++) {
3560 /* not so pretty, but hides powerpc
3561 * specific abi intrinsics and/or
3562 * implementation from user */
3563 if (_jitc->prolog.ptr[d] == label) {
3564 label += sizeof(void*) * 3;
3565 break;
3566 }
3567 }
3568 }
3569 }
3570 #endif
3571 d = label - instr;
3572 assert(!(d & 3));
3573 if (!can_sign_extend_jump_p(d)) {
3574 /* use absolute address */
3575 assert(can_sign_extend_jump_p(label));
3576 d |= 2;
3577 }
3578 u.i[0] = (u.i[0] & ~0x3fffffd) | (d & 0x3fffffe);
3579 break;
3580 case 15: /* LI */
3581 #if __WORDSIZE == 32
3582 # define MTCTR_OFF 2
3583 # define BCTR_OFF 3
3584 #else
3585 # define MTCTR_OFF 6
3586 # define BCTR_OFF 7
3587 #endif
3588 #if _CALL_AIXDESC
3589 /* movi reg label; jmpr reg */
3590 if (_jitc->jump &&
3591 #if 0
3592 /* check for MLTR(reg) */
3593 (u.i[MTCTR_OFF] >> 26) == 31 &&
3594 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 8 &&
3595 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3596 /* check for BLR */
3597 u.i[BCTR_OFF] == 0x4e800020) {
3598 #else
3599 /* check for MTCTR(reg) */
3600 (u.i[MTCTR_OFF] >> 26) == 31 &&
3601 ((u.i[MTCTR_OFF] >> 16) & 0x3ff) == 9 &&
3602 ((u.i[MTCTR_OFF] >> 1) & 0x3ff) == 467 &&
3603 /* check for BCTR */
3604 u.i[BCTR_OFF] == 0x4e800420) {
3605 #endif
3606 /* zero is used for toc and env, so, quick check
3607 * if this is a "jmpi main" like initial jit
3608 * instruction */
3609 if (((long *)label)[1] == 0 && ((long *)label)[2] == 0) {
3610 for (d = 0; d < _jitc->prolog.offset; d++) {
3611 /* not so pretty, but hides powerpc
3612 * specific abi intrinsics and/or
3613 * implementation from user */
3614 if (_jitc->prolog.ptr[d] == label) {
3615 label += sizeof(void*) * 3;
3616 break;
3617 }
3618 }
3619 }
3620 }
3621 #endif
3622 #undef BCTR_OFF
3623 #undef MTCTR_OFF
3624 #if __WORDSIZE == 32
3625 assert(!(u.i[0] & 0x1f0000));
3626 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 16) & 0xffff);
3627 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3628 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3629 u.i[1] = (u.i[1] & ~0xffff) | (label & 0xffff);
3630 #else
3631 assert(!(u.i[0] & 0x1f0000));
3632 u.i[0] = (u.i[0] & ~0xffff) | ((label >> 48) & 0xffff);
3633 assert((u.i[1] & 0xfc000000) >> 26 == 24); /* ORI */
3634 assert(((u.i[1] >> 16) & 0x1f) == ((u.i[1] >> 21) & 0x1f));
3635 u.i[1] = (u.i[1] & ~0xffff) | ((label >> 32) & 0xffff);
3636 /* not fully validating SLDI */
3637 assert((u.i[2] & 0xfc000000) >> 26 == 30); /* SLDI */
3638 assert(((u.i[2] >> 16) & 0x1f) == ((u.i[2] >> 21) & 0x1f));
3639 assert((u.i[3] & 0xfc000000) >> 26 == 24); /* ORI */
3640 assert(((u.i[3] >> 16) & 0x1f) == ((u.i[3] >> 21) & 0x1f));
3641 u.i[3] = (u.i[3] & ~0xffff) | ((label >> 16) & 0xffff);
3642 /* not fully validating SLDI */
3643 assert((u.i[4] & 0xfc000000) >> 26 == 30); /* SLDI */
3644 assert(((u.i[4] >> 16) & 0x1f) == ((u.i[4] >> 21) & 0x1f));
3645 assert((u.i[5] & 0xfc000000) >> 26 == 24); /* ORI */
3646 assert(((u.i[5] >> 16) & 0x1f) == ((u.i[5] >> 21) & 0x1f));
3647 u.i[5] = (u.i[5] & ~0xffff) | (label & 0xffff);
3648 #endif
3649 break;
3650 default:
3651 assert(!"unhandled branch opcode");
3652 }
3653 }
3654 #endif
3655