1 /*
2 * Copyright (C) 2013-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 ldr(r0,r1) ldr_i(r0,r1)
23 # define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2)
24 # define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0)
25 # define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
26 # else
27 # define ldr(r0,r1) ldr_l(r0,r1)
28 # define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2)
29 # define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0)
30 # define stxi(i0,r0,r1) stxi_l(i0,r0,r1)
31 # endif
32 # define is(i) *_jit->pc.us++ = i
33 # if __WORDSIZE == 32
34 # define stack_framesize 96
35 # else
36 # define stack_framesize 160
37 # endif
38 # define _R0_REGNO 0
39 # define _R1_REGNO 1
40 # define _R7_REGNO 7
41 # define _R13_REGNO 13
42 # define _FP_REGNO _R13_REGNO
43 # define _R14_REGNO 14
44 # define _R15_REGNO 15
45 # define u12_p(i0) ((i0) >= 0 && (i0) <= 4095)
46 # define s16_p(i0) ((i0) >= -32768 && (i0) <= 32767)
47 # define x16(i0) ((i0) & 0xffff)
48 # define s20_p(i0) ((i0) >= -524288 && (i0) <= 524287)
49 # define x20(i0) ((i0) & 0xfffff)
50 # if __WORDSIZE == 32
51 # define s32_p(i0) 1
52 # else
53 # define s32_p(i0) \
54 ((i0) >= -2147483648L && (i0) < 2147483647L)
55 # endif
56
57 /*
58 Condition Code Instruction (Mask) Bit Mask Value
59 0 8 8
60 1 9 4
61 2 10 2
62 3 11 1
63
64 AGR:
65 0 Zero
66 1 < zero
67 2 > zero
68 3 Overflow
69 --
70 1 -> overflow CC_O
71 14 -> no overflow CC_NO
72
73 ALGR:
74 0 Zero, no carry
75 1 Not zero, no carry
76 2 Zero, carry
77 3 Not zero, carry
78 --
79 2|1 -> carry CC_NLE
80 8|4 -> no carry CC_LE
81
82 SGR:
83 0 Zero
84 1 < zero
85 2 > zero
86 3 Overflow
87 --
88 1 -> overflow CC_O
89 14 -> no overflow CC_NO
90
91 SLGR:
92 0 --
93 1 Not zero, borrow
94 2 Zero, no borrow
95 3 Not zero, no borrow
96 --
97 4 -> borrow CC_L
98 11 -> no borrow CC_NL
99 */
100
101 # define CC_NV 0x0
102 # define CC_O 0x1
103 # define CC_H 0x2
104 # define CC_NLE 0x3
105 # define CC_L 0x4
106 # define CC_NHE 0x5
107 # define CC_LH 0x6
108 # define CC_NE 0x7
109 # define CC_E 0x8
110 # define CC_NLH 0x9
111 # define CC_HE 0xA
112 # define CC_NL 0xB
113 # define CC_LE 0xC
114 # define CC_NH 0xD
115 # define CC_NO 0xE
116 # define CC_AL 0xF
117 # define _us jit_uint16_t
118 # define _ui jit_uint32_t
119 # define E_(Op) _E(_jit,Op)
120 static void _E(jit_state_t*,_ui);
121 # define I_(Op,I) _I(_jit,Op,I)
122 static void _I(jit_state_t*,_ui,_ui);
123 # define RR_(Op,R1,R2) _RR(_jit,Op,R1,R2)
124 static void _RR(jit_state_t*,_ui,_ui,_ui);
125 # define RRE_(Op,R1,R2) _RRE(_jit,Op,R1,R2)
126 static void _RRE(jit_state_t*,_ui,_ui,_ui);
127 # define RRF_(Op,R3,M4,R1,R2) _RRF(_jit,Op,R3,M4,R1,R2)
128 static void _RRF(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
129 # define RX_(Op,R1,X2,B2,D2) _RX(_jit,Op,R1,X2,B2,D2)
130 static void _RX(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
131 # define RXE_(Op,R1,X2,B2,D2,Op2) _RXE(_jit,Op,R1,X2,B2,D2,Op2)
132 static void _RXE(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui);
133 # define RXF_(Op,R3,X2,B2,D2,R1,Op2) _RXF(_jit,Op,R3,X2,B2,D2,R1,Op2)
134 static void _RXF(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui,_ui);
135 # define RXY_(Op,R1,X2,B2,D2,Op2) _RXY(_jit,Op,R1,X2,B2,D2,Op2)
136 static void _RXY(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui);
137 # define RS_(Op,R1,R3,B2,D2) _RS(_jit,Op,R1,R3,B2,D2)
138 static void _RS(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
139 # define RSY_(Op,R1,R3,B2,D2,Op2) RXY_(Op,R1,R3,B2,D2,Op2)
140 # define RSL_(Op,L1,B1,D1,Op2) _RSL(_jit,Op,L1,B1,D1,Op2)
141 static void _RSL(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
142 # define RSI_(Op,R1,R3,I2) _RSI(_jit,Op,R1,R3,I2)
143 static void _RSI(jit_state_t*,_ui,_ui,_ui,_ui);
144 # define RI_(Op,R1,Op2,I2) RSI_(Op,R1,Op2,I2)
145 # define RIE_(Op,R1,R3,I2,Op2) _RIE(_jit,Op,R1,R3,I2,Op2)
146 static void _RIE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
147 # define RIL_(Op,R1,Op2,I2) _RIL(_jit,Op,R1,Op2,I2)
148 static void _RIL(jit_state_t*,_ui,_ui,_ui,_ui);
149 # define SI_(Op,I2,B1,D1) _SI(_jit,Op,I2,B1,D1)
150 static void _SI(jit_state_t*,_ui,_ui,_ui,_ui);
151 # define SIY_(Op,I2,B1,D1,Op2) _SIY(_jit,Op,I2,B1,D1,Op2)
152 static void _SIY(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
153 # define S_(Op,B2,D2) _S(_jit,Op,B2,D2)
154 static void _S(jit_state_t*,_ui,_ui,_ui);
155 # define SSL_(Op,L,B1,D1,B2,D2) SS_(Op,(L)>>4,(L)&0xF,B1,D1,B2,D2)
156 # define SS_(Op,LL,LH,B1,D1,B2,D2) _SS(_jit,Op,LL,LH,B1,D1,B2,D2)
157 static void _SS(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui,_ui);
158 # define SSE_(Op,B1,D1,B2,D2) _SSE(_jit,Op,B1,D1,B2,D2)
159 static void _SSE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
160 # undef _us
161 # undef _ui
162 # define nop(c) _nop(_jit,c)
163 static void _nop(jit_state_t*,jit_int32_t);
164 # if __WORDSIZE == 32
165 # define ADD_(r0,r1) AR(r0,r1)
166 # define ADDI_(r0,i0) AHI(r0,i0)
167 # define ADDC_(r0,r1) ALR(r0,r1)
168 # define ADDX_(r0,r1) ALCR(r0,r1)
169 # define AND_(r0,r1) NR(r0,r1)
170 # define CMP_(r0,r1) CR(r0,r1)
171 # define CMPU_(r0,r1) CLR(r0,r1)
172 # define DIVREM_(r0,r1) DR(r0,r1)
173 # define DIVREMU_(r0,r1) DLR(r0,r1)
174 # define OR_(r0,r1) OR(r0,r1)
175 # define MUL_(r0,r1) MSR(r0,r1)
176 # define MULI_(r0,i0) MHI(r0,i0)
177 # define MULU_(r0,r1) MLR(r0,r1)
178 # define SUB_(r0,r1) SR(r0,r1)
179 # define SUBC_(r0,r1) SLR(r0,r1)
180 # define SUBX_(r0,r1) SLBR(r0,r1)
181 # define TEST_(r0,r1) LTR(r0,r1)
182 # define XOR_(r0,r1) XR(r0,r1)
183 # else
184 # define ADD_(r0,r1) AGR(r0,r1)
185 # define ADDI_(r0,i0) AGHI(r0,i0)
186 # define ADDC_(r0,r1) ALGR(r0,r1)
187 # define ADDX_(r0,r1) ALCGR(r0,r1)
188 # define AND_(r0,r1) NGR(r0,r1)
189 # define CMP_(r0,r1) CGR(r0,r1)
190 # define CMPU_(r0,r1) CLGR(r0,r1)
191 # define DIVREM_(r0,r1) DSGR(r0,r1)
192 # define DIVREMU_(r0,r1) DLGR(r0,r1)
193 # define MUL_(r0,r1) MSGR(r0,r1)
194 # define MULI_(r0,i0) MGHI(r0,i0)
195 # define MULU_(r0,r1) MLGR(r0,r1)
196 # define OR_(r0,r1) OGR(r0,r1)
197 # define SUB_(r0,r1) SGR(r0,r1)
198 # define SUBC_(r0,r1) SLGR(r0,r1)
199 # define SUBX_(r0,r1) SLBGR(r0,r1)
200 # define TEST_(r0,r1) LTGR(r0,r1)
201 # define XOR_(r0,r1) XGR(r0,r1)
202 # endif
203 /****************************************************************
204 * General Instructions *
205 ****************************************************************/
206 /* ADD */
207 # define AR(R1,R2) RR_(0x1A,R1,R2)
208 # define AGR(R1,R2) RRE_(0xB908,R1,R2)
209 # define AGFR(R1,R2) RRE_(0xB918,R1,R2)
210 # define A(R1,D2,X2,B2) RX_(0x5A,R1,X2,B2,D2)
211 # define AY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5A)
212 # define AG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x08)
213 # define AGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x18)
214 /* ADD HALFWORD */
215 # define AH(R1,D2,X2,B2) RX_(0x4A,R1,X2,B2,D2)
216 # define AHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x7A)
217 /* ADD HALFWORD IMMEDIATE */
218 # define AHI(R1,I2) RI_(0xA7,R1,0xA,I2)
219 # define AGHI(R1,I2) RI_(0xA7,R1,0xB,I2)
220 /* ADD LOGICAL */
221 # define ALR(R1,R2) RR_(0x1E,R1,R2)
222 # define ALGR(R1,R2) RRE_(0xB90A,R1,R2)
223 # define ALGFR(R1,R2) RRE_(0xB91A,R1,R2)
224 # define AL(R1,D2,X2,B2) RX_(0x5E,R1,X2,B2,D2)
225 # define ALY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5E)
226 # define ALG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0A)
227 # define ALGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1A)
228 /* ADD LOGICAL WITH CARRY */
229 # define ALCR(R1,R2) RRE_(0xB998,R1,R2)
230 # define ALCGR(R1,R2) RRE_(0xB988,R1,R2)
231 # define ALC(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x98)
232 # define ALCG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x88)
233 /* AND */
234 # define NR(R1,R2) RR_(0x14,R1,R2)
235 # define NGR(R1,R2) RRE_(0xB980,R1,R2)
236 # define N(R1,D2,X2,B2) RX_(0x54,R1,X2,B2,D2)
237 # define NY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x54)
238 # define NG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x80)
239 # define NI(D1,B1,I2) SI_(0x94,I2,B1,D1)
240 # define NIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x54)
241 # define NC(D1,L,B1,D2,B2) SSL_(0xD4,L,B1,D1,B2,D2)
242 /* AND IMMEDIATE */
243 # define NIHH(R1,I2) RI_(0xA5,R1,0x4,I2)
244 # define NIHL(R1,I2) RI_(0xA5,R1,0x5,I2)
245 # define NILH(R1,I2) RI_(0xA5,R1,0x6,I2)
246 # define NILL(R1,I2) RI_(0xA5,R1,0x7,I2)
247 /* BRANCH AND LINK */
248 # define BALR(R1,R2) RR_(0x05,R1,R2)
249 # define BAL(R1,D2,X2,B2) RX_(0x45,R1,X2,B2,D2)
250 /* BRANCH AND SAVE */
251 # define BASR(R1,R2) RR_(0x0D,R1,R2)
252 # define BAS(R1,D2,X2,B2) RX_(0x4D,R1,X2,B2,D2)
253 /* BRANCH AND SAVE AND SET MODE */
254 # define BASSM(R1,R2) RR_(0x0C,R1,R2)
255 /* BRANCH AND SET MODE */
256 # define BSM(R1,R2) RR_(0x0B,R1,R2)
257 /* BRANCH ON CONDITION */
258 # define BCR(M1,R2) RR_(0x07,M1,R2)
259 # define BR(R2) BCR(CC_AL,R2)
260 # define NOPR(R2) BCR(CC_NV,R2)
261 # define BC(M1,D2,X2,B2) RX_(0x47,M1,X2,B2,D2)
262 /* BRANCH ON COUNT */
263 # define BCTR(R1,R2) RR_(0x06,R1,R2)
264 # define BCTGR(R1,R2) RRE_(0xB946,R1,R2)
265 # define BCT(R1,D2,X2,B2) RX_(0x46,R1,X2,B2,D2)
266 # define BCTG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x46)
267 /* BRANCH ON INDEX HIGH */
268 # define BXH(R1,R3,D2,B2) RS_(0x86,R1,R3,B2,D2)
269 # define BXHG(R1,R3,B2,D2) RSY_(0xEB,R1,R3,B2,D2,0x44)
270 /* BRANCH ON INDEX LOW OR EQUAL */
271 # define BXLE(R1,R3,D2,B2) RS_(0x87,R1,R3,B2,D2)
272 # define BXLEG(R1,R3,B2,D2) RSY_(0xEB,R1,R3,B2,D2,0x45)
273 /* BRANCH RELATIVE AND SAVE */
274 # define BRAS(R1,I2) RI_(0xA7,R1,0x5,I2)
275 /* BRANCH RELATIVE AND SAVE LONG */
276 # define BRASL(R1,I2) RIL_(0xC0,R1,0x5,I2)
277 /* BRANCH RELATIVE ON CONDITION */
278 # define BRC(M1,I2) RI_(0xA7,M1,0x4,I2)
279 # define J(I2) BRC(CC_AL,I2)
280 /* BRANCH RELATIVE ON CONDITION LONG */
281 # define BRCL(M1,I2) RIL_(0xC0,M1,0x4,I2)
282 # define BRL(I2) BRCL(CC_AL,I2)
283 /* BRANCH RELATIVE ON COUNT */
284 # define BRCT(M1,I2) RI_(0xA7,M1,0x6,I2)
285 # define BRCTG(M1,I2) RI_(0xA7,M1,0x7,I2)
286 /* BRANCH RELATIVE ON INDEX HIGH */
287 # define BRXH(R1,R3,I2) RSI_(0x84,R1,R3,I2)
288 # define BRXHG(R1,R3,I2) RIE_(0xEC,R1,R3,I2,0x44)
289 /* BRANCH RELATIVE ON INDEX LOW OR EQUAL */
290 # define BRXLE(R1,R3,I2) RSI_(0x85,R1,R3,I2)
291 # define BRXLEG(R1,R3,I2) RIE_(0xEC,R1,R3,I2,0x45)
292 /* CHECKSUM */
293 # define CKSUM(R1,R2) RRE_(0xB241,R1,R2)
294 /* CIPHER MESAGE (KM) */
295 # define KM(R1,R2) RRE_(0xB92E,R1,R2)
296 /* CIPHER MESAGE WITH CHAINING (KMC) */
297 # define KMC(R1,R2) RRE_(0xB92F,R1,R2)
298 /* COMPARE */
299 # define CR(R1,R2) RR_(0x19,R1,R2)
300 # define CGR(R1,R2) RRE_(0xB920,R1,R2)
301 # define CGFR(R1,R2) RRE_(0xB930,R1,R2)
302 # define C(R1,D2,X2,B2) RX_(0x59,R1,X2,B2,D2)
303 # define CY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x59)
304 # define CG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x20)
305 # define CGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x30)
306 /* COMPARE AND FORM CODEWORD */
307 # define CFC(D2,B2) S_(0xB21A,B2,D2)
308 /* COMPARE AND SWAP */
309 # define CS(R1,R3,D2,B2) RS_(0xBA,R1,R3,B2,D2)
310 # define CSY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x14)
311 # define CSG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x30)
312 /* COMPARE DOUBLE AND SWAP */
313 # define CDS(R1,R3,D2,B2) RS_(0xBB,R1,R3,B2,D2)
314 # define CSDY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x31)
315 # define CSDG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x3E)
316 /* COMPARE HALFWORD */
317 # define CH(R1,D2,X2,B2) RX_(0x49,R1,X2,B2,D2)
318 # define CHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x79)
319 /* COMPARE HALFWORD IMMEDIATE */
320 # define CHI(R1,I2) RI_(0xA7,R1,0xE,I2)
321 # define CGHI(R1,I2) RI_(0xA7,R1,0xF,I2)
322 /* COMPARE LOGICAL */
323 # define CLR(R1,R2) RR_(0x15,R1,R2)
324 # define CLGR(R1,R2) RRE_(0xB921,R1,R2)
325 # define CLGFR(R1,R2) RRE_(0xB931,R1,R2)
326 # define CL(R1,D2,X2,B2) RX_(0x55,R1,X2,B2,D2)
327 # define CLY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x55)
328 # define CLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x21)
329 # define CLGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x31)
330 # define CLI(D1,B1,I2) SI_(0x95,I2,B1,D1)
331 # define CLIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x55)
332 # define CLC(D1,L,B1,D2,B2) SSL_(0xD5,L,B1,D1,B2,D2)
333 /* COMPARE LOGICAL CHARACTERS UNDER MASK */
334 # define CLM(R1,M3,D2,B2) RS_(0xBD,R1,M3,B2,D2)
335 # define CLMY(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x21)
336 # define CLMH(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x20)
337 /* COMPARE LOGICAL LONG */
338 # define CLCL(R1,R2) RR_(0x0F,R1,R2)
339 /* COMPARE LOGICAL LONG EXTENDED */
340 # define CLCLE(R1,R3,D2,B2) RS_(0xA9,R1,R3,B2,D2)
341 /* COMPARE LOGICAL LONG UNICODE */
342 # define CLCLU(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x8F)
343 /* COMPARE LOGICAL STRING */
344 # define CLST(R1,R2) RRE_(0xB25D,R1,R2)
345 /* COMPARE UNTIL SUBSTRING EQUAL */
346 # define CUSE(R1,R2) RRE_(0xB257,R1,R2)
347 /* COMPRESSION CALL */
348 # define CMPSC(R1,R2) RRE_(0xB263,R1,R2)
349 /* COMPUTE INTERMEDIATE MESSAGE DIGEST (KIMD) */
350 # define KIMD(R1,R2) RRE_(0xB93E,R1,R2)
351 /* COMPUTE LAST MESSAGE DIGEST (KIMD) */
352 # define KLMD(R1,R2) RRE_(0xB93F,R1,R2)
353 /* COMPUTE MESSAGE AUTHENTICATION CODE (KMAC) */
354 # define KMAC(R1,R2) RRE_(0xB91E,R1,R2)
355 /* CONVERT TO BINARY */
356 # define CVB(R1,D2,X2,B2) RX_(0x4F,R1,X2,B2,D2)
357 # define CVBY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x06)
358 # define CVBG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0e)
359 /* CONVERT TO DECIMAL */
360 # define CVD(R1,D2,X2,B2) RX_(0x4E,R1,X2,B2,D2)
361 # define CVDY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x26)
362 # define CVDG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x2E)
363 /* CONVERT UNICODE TO UTF-8 */
364 # define CUUTF(R1,R2) RRE_(0xB2A6,R1,R2)
365 /* CONVERT UTF-8 TO UNICODE */
366 # define CUTFU(R1,R2) RRE_(0xB2A7,R1,R2)
367 /* COPY ACCESS */
368 # define CPYA(R1,R2) RRE_(0xB24D,R1,R2)
369 /* DIVIDE */
370 # define DR(R1,R2) RR_(0x1D,R1,R2)
371 # define D(R1,D2,X2,B2) RX_(0x5D,R1,X2,B2,D2)
372 /* DIVIDE LOGICAL */
373 # define DLR(R1,R2) RRE_(0xB997,R1,R2)
374 # define DLGR(R1,R2) RRE_(0xB987,R1,R2)
375 # define DL(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x97)
376 # define DLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x87)
377 /* DIVIDE SINGLE */
378 # define DSGR(R1,R2) RRE_(0xB90D,R1,R2)
379 # define DSGFR(R1,R2) RRE_(0xB91D,R1,R2)
380 # define DSG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0D)
381 # define DSGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1D)
382 /* EXCLUSIVE OR */
383 # define XR(R1,R2) RR_(0x17,R1,R2)
384 # define XGR(R1,R2) RRE_(0xB982,R1,R2)
385 # define X(R1,D2,X2,B2) RX_(0x57,R1,X2,B2,D2)
386 # define XY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x57)
387 # define XG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x82)
388 # define XI(D1,B1,I2) SI_(0x97,I2,B1,D1)
389 # define XIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x57)
390 # define XC(D1,L,B1,D2,B2) SSL_(0xD7,L,B1,D1,B2,D2)
391 /* EXECUTE */
392 # define EX(R1,D2,X2,B2) RX_(0x44,R1,X2,B2,D2)
393 /* EXTRACT ACCESS */
394 # define EAR(R1,R2) RRE_(0xB24F,R1,R2)
395 /* EXTRACT PSW */
396 # define EPSW(R1,R2) RRE_(0xB98D,R1,R2)
397 /* INSERT CHARACTER */
398 # define IC(R1,D2,X2,B2) RX_(0x43,R1,X2,B2,D2)
399 # define ICY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x73)
400 /* INSERT CHARACTERS UNDER MASK */
401 # define ICM(R1,M3,D2,B2) RS_(0xBF,R1,M3,B2,D2)
402 # define ICMY(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x81)
403 # define ICMH(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x80)
404 /* INSERT IMMEDIATE */
405 # define IIHH(R1,I2) RI_(0xA5,R1,0x0,I2)
406 # define IIHL(R1,I2) RI_(0xA5,R1,0x1,I2)
407 # define IILH(R1,I2) RI_(0xA5,R1,0x2,I2)
408 # define IILL(R1,I2) RI_(0xA5,R1,0x3,I2)
409 /* INSERT PROGRAM MASK */
410 # define IPM(R1) RRE_(0xB222,R1,0)
411 /* LOAD */
412 # define LR(R1,R2) RR_(0x18,R1,R2)
413 # define LGR(R1,R2) RRE_(0xB904,R1,R2)
414 # define LGFR(R1,R2) RRE_(0xB914,R1,R2)
415 # define L(R1,D2,X2,B2) RX_(0x58,R1,X2,B2,D2)
416 # define LY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x58)
417 # define LG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x04)
418 # define LGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x14)
419 /* LOAD ACCESS MULTIPLE */
420 # define LAM(R1,R3,D2,B2) RS_(0x9A,R1,R3,B2,D2)
421 # define LAMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x9A)
422 /* LOAD ADDRESS */
423 # define LA(R1,D2,X2,B2) RX_(0x41,R1,X2,B2,D2)
424 # define LAY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x71)
425 /* LOAD ADDRESS EXTENDED */
426 # define LAE(R1,D2,X2,B2) RX_(0x51,R1,X2,B2,D2)
427 /* LOAD ADDRESS RELATIVE LONG */
428 # define LARL(R1,I2) RIL_(0xC0,R1,0x0,I2)
429 /* LOAD AND TEST */
430 # define LTR(R1,R2) RR_(0x12,R1,R2)
431 # define LTGR(R1,R2) RRE_(0xB902,R1,R2)
432 # define LTGFR(R1,R2) RRE_(0xB912,R1,R2)
433 /* LOAD BYTE */
434 # define LGBR(R1,R2) RRE_(0xB906,R1,R2) /* disasm */
435 # define LB(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x76)
436 # define LGB(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x77)
437 /* LOAD COMPLEMENT */
438 # define LCR(R1,R2) RR_(0x13,R1,R2)
439 # define LCGR(R1,R2) RRE_(0xB903,R1,R2)
440 # define LCGFR(R1,R2) RRE_(0xB913,R1,R2)
441 /* LOAD HALFWORD */
442 # define LH(R1,D2,X2,B2) RX_(0x48,R1,X2,B2,D2)
443 # define LHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x78)
444 # define LGHR(R1,R2) RRE_(0xB907,R1,R2) /* disasm */
445 # define LGH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x15)
446 /* LOAD HALFWORD IMMEDIATE */
447 # define LHI(R1,I2) RI_(0xA7,R1,0x8,I2)
448 # define LGHI(R1,I2) RI_(0xA7,R1,0x9,I2)
449 /* LOAD LOGICAL */
450 # define LLGFR(R1,R2) RRE_(0xB916,R1,R2)
451 # define LLGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x16)
452 /* LOAD LOGICAL CHARACTER */
453 # define LLGCR(R1,R2) RRE_(0xB984,R1,R2) /* disasm */
454 # define LLGC(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x90)
455 /* LOAD LOGICAL HALFWORD */
456 # define LLGHR(R1,R2) RRE_(0xB985,R1,R2) /* disasm */
457 # define LLGH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x91)
458 /* LOAD LOGICAL IMMEDIATE */
459 # define LLIHH(R1,I2) RI_(0xA5,R1,0xC,I2)
460 # define LLIHL(R1,I2) RI_(0xA5,R1,0xD,I2)
461 # define LLILH(R1,I2) RI_(0xA5,R1,0xE,I2)
462 # define LLILL(R1,I2) RI_(0xA5,R1,0xF,I2)
463 /* LOAD LOGICAL THIRTY ONE BITS */
464 # define LLGTR(R1,R2) RRE_(0xB917,R1,R2)
465 # define LLGT(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x17)
466 /* LOAD MULTIPLE */
467 # define LM(R1,R3,D2,B2) RS_(0x98,R1,R3,B2,D2)
468 # define LMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x98)
469 # define LMG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x04)
470 /* LOAD MULTIPLE DISJOINT */
471 # define LMD(R1,R3,D2,B2,D4,B4) SS_(0xEF,R1,R3,B2,D2,B4,D4)
472 /* LOAD MULTIPLE HIGH */
473 # define LMH(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x96)
474 /* LOAD NEGATIVE */
475 # define LNR(R1,R2) RR_(0x11,R1,R2)
476 # define LNGR(R1,R2) RRE_(0xB901,R1,R2)
477 # define LNGFR(R1,R2) RRE_(0xB911,R1,R2)
478 /* LOAD PAIR FROM QUADWORD */
479 # define LPQ(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x8F)
480 /* LOAD POSITIVE */
481 # define LPR(R1,R2) RR_(0x10,R1,R2)
482 # define LPGR(R1,R2) RRE_(0xB900,R1,R2)
483 # define LPGFR(R1,R2) RRE_(0xB910,R1,R2)
484 /* LOAD REVERSED */
485 # define LRVR(R1,R2) RRE_(0xB91F,R1,R2)
486 # define LRVGR(R1,R2) RRE_(0xB90F,R1,R2)
487 # define LRVH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1F)
488 # define LRV(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1E)
489 # define LRVG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0F)
490 /* MONITOR CALL */
491 # define MC(D1,B1,I2) SI_(0xAF,I2,B1,D1)
492 /* MOVE */
493 # define MVI(D1,B1,I2) SI_(0x92,I2,B1,D1)
494 # define MVIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x52)
495 # define MVC(D1,L,B1,D2,B2) SSL_(0xD2,L,B1,D1,B2,D2)
496 /* MOVE INVERSE */
497 # define MVCIN(D1,L,B1,D2,B2) SSL_(0xE8,L,B1,D1,B2,D2)
498 /* MOVE LONG */
499 # define MVCL(R1,R2) RR_(0x0E,R1,R2)
500 /* MOVE LONG EXTENDED */
501 # define MVCLE(R1,R3,D2,B2) RS_(0xA8,R1,R3,B2,D2)
502 /* MOVE LONG UNICODE */
503 # define MVCLU(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x8E)
504 /* MOVE NUMERICS */
505 # define MVN(D1,L,B1,D2,B2) SSL_(0xD1,L,B1,D1,B2,D2)
506 /* MOVE STRING */
507 # define MVST(R1,R2) RRE_(0xB255,R1,R2)
508 /* MOVE WITH OFFSET */
509 # define MVO(D1,L1,B1,D2,L2,B2) SS_(0xF1,L1,L2,B1,D1,B2,D2)
510 /* MOVE ZONES */
511 # define MVZ(D1,L,B1,D2,B2) SSL_(0xD3,L,B1,D1,B2,D2)
512 /* MULTIPLY */
513 # define MR(R1,R2) RR_(0x1C,R1,R2)
514 # define M(R1,D2,X2,B2) RX_(0x5C,R1,X2,B2,D2)
515 /* MULTIPLY HALFWORD */
516 # define MH(R1,D2,X2,B2) RX_(0x4C,R1,X2,B2,D2)
517 /* MULTIPLY HALFWORD IMMEDIATE */
518 # define MHI(R1,I2) RI_(0xA7,R1,0xC,I2)
519 # define MGHI(R1,I2) RI_(0xA7,R1,0xD,I2)
520 /* MULTIPLY LOGICAL */
521 # define MLR(R1,R2) RRE_(0xB996,R1,R2)
522 # define MLGR(R1,R2) RRE_(0xB986,R1,R2)
523 # define ML(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x96)
524 # define MLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x86)
525 /* MULTIPLY SINGLE */
526 # define MSR(R1,R2) RRE_(0xB252,R1,R2)
527 # define MSGR(R1,R2) RRE_(0xB90C,R1,R2)
528 # define MSGFR(R1,R2) RRE_(0xB91C,R1,R2)
529 # define MS(R1,D2,X2,B2) RX_(0x71,R1,X2,B2,D2)
530 # define MSY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x51)
531 # define MSG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0C)
532 # define MSGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1C)
533 /* OR */
534 # define OR(R1,R2) RR_(0x16,R1,R2)
535 # define OGR(R1,R2) RRE_(0xB981,R1,R2)
536 # define O(R1,D2,X2,B2) RX_(0x56,R1,X2,B2,D2)
537 # define OY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x56)
538 # define OG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x81)
539 # define OI(D1,B1,I2) SI_(0x96,I2,B1,D1)
540 # define OIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x56)
541 # define OC(D1,L,B1,D2,B2) SSL_(0xD6,L,B1,D1,B2,D2)
542 /* OR IMMEDIATE */
543 # define OIHH(R1,I2) RI_(0xA5,R1,0x8,I2)
544 # define OIHL(R1,I2) RI_(0xA5,R1,0x9,I2)
545 # define OILH(R1,I2) RI_(0xA5,R1,0xA,I2)
546 # define OILL(R1,I2) RI_(0xA5,R1,0xB,I2)
547 /* PACK */
548 # define PACK(D1,L1,B1,D2,L2,B2) SS_(0xF2,L1,L2,B1,D1,B2,D2)
549 /* PACK ASCII */
550 # define PKA(D1,B1,D2,L2,B2) SSL_(0xE9,L2,B1,D1,B2,D2)
551 /* PACK UNICODE */
552 # define PKU(D1,B1,D2,L2,B2) SSL_(0xE1,L2,B1,D1,B2,D2)
553 /* PERFORM LOCKED OPERATION */
554 # define PLO(R1,D2,B2,R3,D4,B4) SS_(0xEE,R1,R3,B2,D2,B4,D4)
555 /* ROTATE LEFT SINGLE LOGICAL */
556 # define RLL(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x1D)
557 # define RLLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x1C)
558 /* SEARCH STRING */
559 # define SRST(R1,R2) RRE_(0xB25E,R1,R2)
560 /* SET ACCESS */
561 # define SAR(R1,R2) RRE_(0xB24E,R1,R2)
562 /* SET ADDRESSING MODE */
563 # define SAM24() E_(0x10C)
564 # define SAM31() E_(0x10D)
565 # define SAM64() E_(0x10E)
566 /* SET PROGRAM MASK */
567 # define SPM(R1) RR_(0x04,R1,0)
568 /* SHIFT LEFT DOUBLE */
569 # define SLDA(R1,D2,B2) RS_(0x8F,R1,0,B2,D2)
570 /* SHIFT LEFT DOUBLE LOGICAL */
571 # define SLDL(R1,D2,B2) RS_(0x8D,R1,0,B2,D2)
572 /* SHIFT LEFT SINGLE */
573 # define SLA(R1,D2,B2) RS_(0x8B,R1,0,B2,D2)
574 # define SLAG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0B)
575 /* SHIFT LEFT SINGLE LOGICAL */
576 # define SLL(R1,D2,B2) RS_(0x89,R1,0,B2,D2)
577 # define SLLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0D)
578 /* SHIFT RIGHT DOUBLE */
579 # define SRDA(R1,D2,B2) RS_(0x8E,R1,0,B2,D2)
580 /* SHIFT RIGHT DOUBLE LOGICAL */
581 # define SRDL(R1,D2,B2) RS_(0x8C,R1,0,B2,D2)
582 /* SHIFT RIGHT SINGLE */
583 # define SRA(R1,D2,B2) RS_(0x8A,R1,0,B2,D2)
584 # define SRAG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0A)
585 /* SHIFT RIGHT SINGLE LOGICAL */
586 # define SRL(R1,D2,B2) RS_(0x88,R1,0,B2,D2)
587 # define SRLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0C)
588 /* STORE */
589 # define ST(R1,D2,X2,B2) RX_(0x50,R1,X2,B2,D2)
590 # define STY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x50)
591 # define STG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x24)
592 /* STORE ACCESS MULTIPLE */
593 # define STAM(R1,R3,D2,B2) RS_(0x9B,R1,R3,B2,D2)
594 # define STAMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x9B)
595 /* STORE CHARACTER */
596 # define STC(R1,D2,X2,B2) RX_(0x42,R1,X2,B2,D2)
597 # define STCY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x72)
598 /* STORE CHARACTERS UNDER MASK */
599 # define STCM(R1,M3,D2,B2) RS_(0xBE,R1,M3,B2,D2)
600 # define STCMY(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x2D)
601 # define STCMH(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x2C)
602 /* STORE CLOCK */
603 # define STCK(D2,B2) S_(0xB205,B2,D2)
604 /* STORE CLOCK EXTENDED */
605 # define STCKE(D2,B2) S_(0xB278,B2,D2)
606 /* STORE HALFWORD */
607 # define STH(R1,D2,X2,B2) RX_(0x40,R1,X2,B2,D2)
608 # define STHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x70)
609 /* STORE MULTIPLE */
610 # define STM(R1,R3,D2,B2) RS_(0x90,R1,R3,B2,D2)
611 # define STMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x90)
612 # define STMG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x24)
613 /* STORE MULTIPLE HIGH */
614 # define STMH(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x26)
615 /* STORE PAIR TO QUADWORD */
616 # define STPQ(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x8E)
617 /* STORE REVERSED */
618 # define STRVH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x3F)
619 # define STRV(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x3E)
620 # define STRVG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x2F)
621 /* SUBTRACT */
622 # define SR(R1,R2) RR_(0x1B,R1,R2)
623 # define SGR(R1,R2) RRE_(0xB909,R1,R2)
624 # define SGFR(R1,R2) RRE_(0xB919,R1,R2)
625 # define S(R1,D2,X2,B2) RX_(0x5B,R1,X2,B2,D2)
626 # define SY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5B)
627 # define SG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x09)
628 # define SGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x19)
629 /* SUBTRACT HALFWORD */
630 # define SH(R1,D2,X2,B2) RX_(0x4B,R1,X2,B2,D2)
631 # define SHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x7B)
632 /* SUBTRACT LOGICAL */
633 # define SLR(R1,R2) RR_(0x1F,R1,R2)
634 # define SLGR(R1,R2) RRE_(0xB90B,R1,R2)
635 # define SLGFR(R1,R2) RRE_(0xB91B,R1,R2)
636 # define SL(R1,D2,X2,B2) RX_(0x5F,R1,X2,B2,D2)
637 # define SLY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5F)
638 # define SLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0B)
639 # define SLGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1B)
640 /* SUBTRACT LOGICAL WITH BORROW */
641 # define SLBR(R1,R2) RRE_(0xB999,R1,R2)
642 # define SLBGR(R1,R2) RRE_(0xB989,R1,R2)
643 # define SLB(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x99)
644 # define SLBG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x89)
645 /* SUPERVISOR CALL */
646 # define SVC(I) I_(0xA,I)
647 /* TEST ADDRESSING MODE */
648 # define TAM() E_(0x10B)
649 /* TEST AND SET */
650 # define TS(D2,B2) RS_(0x93,0,0,B2,D2)
651 /* TEST UNDER MASK (TEST UNDER MASK HIGH, TEST UNDER MASK LOW) */
652 # define TM(D1,B1,I2) SI_(0x91,I2,B1,D1)
653 # define TMY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x51)
654 # define TMHH(R1,I2) RI_(0xA7,R1,0x2,I2)
655 # define TMHL(R1,I2) RI_(0xA7,R1,0x3,I2)
656 # define TMLH(R1,I2) RI_(0xA7,R1,0x0,I2)
657 # define TMH(R1,I2) TMLH(R1,I2)
658 # define TMLL(R1,I2) RI_(0xA7,R1,0x1,I2)
659 # define TML(R1,I2) TMLL(R1,I2)
660 /* TRANSLATE */
661 # define TR(D1,L,B1,D2,B2) SSL_(0xDC,L,B1,D1,B2,D2)
662 /* TRANSLATE AND TEST */
663 # define TRT(D1,L,B1,D2,B2) SSL_(0xDD,L,B1,D1,B2,D2)
664 /* TRANSLATE EXTENDED */
665 # define TRE(R1,R2) RRE_(0xB2A5,R1,R2)
666 /* TRANSLATE ONE TO ONE */
667 # define TROO(R1,R2) RRE_(0xB993,R1,R2)
668 /* TRANSLATE ONE TO TWO */
669 # define TROT(R1,R2) RRE_(0xB992,R1,R2)
670 /* TRANSLATE TWO TO ONE */
671 # define TRTO(R1,R2) RRE_(0xB991,R1,R2)
672 /* TRANSLATE TWO TO TWO */
673 # define TRTT(R1,R2) RRE_(0xB990,R1,R2)
674 /* UNPACK */
675 # define UNPK(D1,L1,B1,D2,L2,B2) SS_(0xF3,L1,L2,B1,D1,B2,D2)
676 /* UNPACK ASCII */
677 # define UNPKA(D1,L1,B1,D2,L2,B2) SS_(0xEA,L1,L2,B1,D1,B2,D2)
678 /* UNPACK UNICODE */
679 # define UNPKU(D1,L1,B1,D2,L2,B2) SS_(0xE2,L1,L2,B1,D1,B2,D2)
680 /* UPDATE TREE */
681 # define UPT() E_(0x0102)
682 /****************************************************************
683 * Decimal Instructions *
684 ****************************************************************/
685 /* ADD DECIMAL */
686 # define AP(D1,L1,B1,D2,L2,B2) SS_(0xFA,L1,L2,B1,D1,B2,D2)
687 /* COMPARE DECIMAL */
688 # define CP(D1,L1,B1,D2,L2,B2) SS_(0xF9,L1,L2,B1,D1,B2,D2)
689 /* DIVIDE DECIMAL */
690 # define DP(D1,L1,B1,D2,L2,B2) SS_(0xFD,L1,L2,B1,D1,B2,D2)
691 /* EDIT */
692 # define ED(D1,L,B1,D2,B2) SSL_(0xDE,L,B1,D1,B2,D2)
693 /* EDIT AND MARK */
694 # define EDMK(D1,L,B1,D2,B2) SSL_(0xDE,L,B1,D1,B2,D2)
695 /* MULTIPLY DECIMAL */
696 # define MP(D1,L1,B1,D2,L2,B2) SS_(0xFC,L1,L2,B1,D1,B2,D2)
697 /* SHIFT AND ROUND DECIMAL */
698 # define SRP(D1,L1,B1,D2,L2,B2) SS_(0xF0,L1,L2,B1,D1,B2,D2)
699 /* SUBTRACE DECIMAL */
700 # define SP(D1,L1,B1,D2,L2,B2) SS_(0xFB,L1,L2,B1,D1,B2,D2)
701 /* TEST DECIMAL */
702 # define TP(D1,L1,B1) RSL_(0xEB,L1,B1,D1,0xC0)
703 /* ZERO AND ADD */
704 # define ZAP(D1,L1,B1,D2,L2,B2) SS_(0xF8,L1,L2,B1,D1,B2,D2)
705 /****************************************************************
706 * Control Instructions *
707 ****************************************************************/
708 /* BRANCH AND SET AUTHORITY */
709 # define BSA(R1,R2) RRE_(0xB25A,R1,R2)
710 /* BRANCH AND STACK */
711 # define BAKR(R1,R2) RRE_(0xB240,R1,R2)
712 /* BRANCH IN SUBSPACE GROUP */
713 # define BSG(R1,R2) RRE_(0xB258,R1,R2)
714 /* COMPARE AND SWAP AND PURGE */
715 # define CSP(R1,R2) RRE_(0xB250,R1,R2)
716 # define CSPG(R1,R2) RRE_(0xB98A,R1,R2)
717 /* DIAGNOSE */
718 # define DIAG() SI_(0x83,0,0,0)
719 /* EXTRACT AND SET EXTENDED AUTHORITY */
720 # define ESEA(R1) RRE_(0xB99D,R1,0)
721 /* EXTRACT PRIMARY ASN */
722 # define EPAR(R1) RRE_(0xB226,R1,0)
723 /* EXTRACT SECONDARY ASN */
724 # define ESAR(R1) RRE_(0xB227,R1,0)
725 /* EXTRACT STACKED REGISTERS */
726 # define EREG(R1,R2) RRE_(0xB249,R1,R2)
727 # define EREGG(R1,R2) RRE_(0xB90E,R1,R2)
728 /* EXTRACT STACKED STATE */
729 # define ESTA(R1,R2) RRE_(0xB24A,R1,R2)
730 /* INSERT ADDRESS SPACE CONTROL */
731 # define IAC(R1) RRE_(0xB224,R1,0)
732 /* INSERT PSW KEY */
733 # define IPK() S_(0xB20B,0,0)
734 /* INSERT STORAGE KEY EXTENDED */
735 # define ISKE(R1,R2) RRE_(0xB229,R1,R2)
736 /* INSERT VIRTUAL STORAGE KEY */
737 # define IVSK(R1,R2) RRE_(0xB223,R1,R2)
738 /* INVALIDATE DAT TABLE ENTRY */
739 # define IDTE(R1,R2,R3) RRF_(0xB98E,R3,0,R1,R2)
740 /* INVALIDATE PAGE TABLE ENTRY */
741 # define IPTE(R1,R2) RRE_(0xB221,R1,R2)
742 /* LOAD ADDRESS SPACE PARAMETER */
743 # define LASP(D1,B1,D2,B2) SSE_(0xE500,B1,D1,B2,D2)
744 /* LOAD CONTROL */
745 # define LCTL(R1,R3,D2,B2) RS_(0xB7,R1,R3,B2,D2)
746 # define LCTLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x2F)
747 /* LOAD PSW */
748 # define LPSW(D2,B2) SI_(0x82,0,B2,D2)
749 /* LOAD PSW EXTENDED */
750 # define LPSWE(D2,B2) S_(0xB2B2,B2,D2)
751 /* LOAD REAL ADDRESS */
752 # define LRA(R1,D2,X2,B2) RX_(0xB1,R1,X2,B2,D2)
753 # define LRAY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x13)
754 # define LRAG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x03)
755 /* LOAD USING REAL ADDRESS */
756 # define LURA(R1,R2) RRE_(0xB24B,R1,R2)
757 # define LURAG(R1,R2) RRE_(0xB905,R1,R2)
758 /* MODIFY STACKED STATE */
759 # define MSTA(R1) RRE_(0xB247,R1,0)
760 /* MOVE PAGE */
761 # define MVPG(R1,R2) RRE_(0xB254,R1,R2)
762 /* MOVE TO PRIMARY */
763 # define MVCP(D1,R1,B1,D2,B2,R3) SS_(0xDA,R1,R3,B1,D1,B2,D2)
764 /* MOVE TO SECONDARY */
765 # define MVCS(D1,R1,B1,D2,B2,R3) SS_(0xDB,R1,R3,B1,D1,B2,D2)
766 /* MOVE WITH DESTINATION KEY */
767 # define MVCDK(D1,B1,D2,B2) SSE_(0xE50F,B1,D1,B2,D2)
768 /* MOVE WITH KEY */
769 # define MVCK(D1,R1,B1,D2,B2,R3) SS_(0xD9,R1,R3,B1,D1,B2,D2)
770 /* MOVE WITH SOURCE KEY */
771 # define MVCSK(D1,B1,D2,B2) SSE_(0xE50E,B1,D1,B2,D2)
772 /* PAGE IN */
773 # define PGIN(R1,R2) RRE_(0xB22E,R1,R2)
774 /* PAGE OUT */
775 # define PGOUT(R1,R2) RRE_(0xB22F,R1,R2)
776 /* PROGRAM CALL */
777 # define PC(D2,B2) S_(0xB218,B2,D2)
778 /* PROGRAM RETURN */
779 # define PR() E_(0x0101)
780 /* PROGRAM TRANSFER */
781 # define PT(R1,R2) RRE_(0xB228,R1,R2)
782 /* PURGE ALB */
783 # define PALB() RRE_(0xB248,0,0)
784 /* PURGE TLB */
785 # define PTLB() S_(0xB20D,0,0)
786 /* RESET REFERENCE BIT EXTENDED */
787 # define RRBE(R1,R2) RRE_(0xB22A,R1,R2)
788 /* RESUME PROGRAM */
789 # define RP(D2,B2) S_(0xB277,B2,D2)
790 /* SET ADDRESS SPACE CONTROL */
791 # define SAC(D2,B2) S_(0xB219,B2,D2)
792 /* SET ADDRESS SPACE CONTROL FAST */
793 # define SACF(D2,B2) S_(0xB279,B2,D2)
794 /* SET CLOCK */
795 # define SCK(D2,B2) S_(0xB204,B2,D2)
796 /* SET CLOCK COMPARATOR */
797 # define SCKC(D2,B2) S_(0xB206,B2,D2)
798 /* SET CLOCK PROGRAMMABLE FIELD */
799 # define SCKPF() E_(0x0107)
800 /* SET CPU TIMER */
801 # define SPT(D2,B2) S_(0xB208,B2,D2)
802 /* SET PREFIX */
803 # define SPX(D2,B2) S_(0xB210,B2,D2)
804 /* SET PSW FROM ADDRESS */
805 # define SPKA(D2,B2) S_(0xB20A,B2,D2)
806 /* SET SECONDARY ASN */
807 # define SSAR(R1) RRE_(0xB225,R1,0)
808 /* SET STORAGE KEY EXTENDED */
809 # define SSKE(R1,R2) RRE_(0xB22B,R1,R2)
810 /* SET SYSTEM MASK */
811 # define SSM(D2,B2) SI_(0x80,0,B2,D2)
812 /* SIGNAL PROCESSOR */
813 # define SIGP(R1,R3,D2,B2) RS_(0xAE,R1,R3,B2,D2)
814 /* STORE CLOCK COMPARATOR */
815 # define STCKC(D2,B2) S_(0xB207,B2,D2)
816 /* STORE CONTROL */
817 # define STCTL(R1,R3,D2,B2) RS_(0xB6,R1,R3,B2,D2)
818 # define STCTG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x25)
819 /* STORE CPU ADDRESS */
820 # define STAP(D2,B2) S_(0xB212,B2,D2)
821 /* STORE CPU ID */
822 # define STIDP(D2,B2) S_(0xB202,B2,D2)
823 /* STORE CPU TIMER */
824 # define STPT(D2,B2) S_(0xB209,B2,D2)
825 /* STORE FACILITY LIST */
826 # define STFL(D2,B2) S_(0xB2B1,B2,D2)
827 /* STORE PREFIX */
828 # define STPX(D2,B2) S_(0xB211,B2,D2)
829 /* STORE REAL ADDRES */
830 # define STRAG(D1,B1,D2,B2) SSE_(0xE502,B1,D1,B2,D2)
831 /* STORE SYSTEM INFORMATION */
832 # define STSI(D2,B2) S_(0xB27D,B2,D2)
833 /* STORE THEN AND SYSTEM MASK */
834 # define STNSM(D1,B1,I2) SI_(0xAC,I2,B1,D1)
835 /* STORE THEN OR SYSTEM MASK */
836 # define STOSM(D1,B1,I2) SI_(0xAD,I2,B1,D1)
837 /* STORE USING REAL ADDRESS */
838 # define STURA(R1,R2) RRE_(0xB246,R1,R2)
839 # define STURG(R1,R2) RRE_(0xB925,R1,R2)
840 /* TEST ACCESS */
841 # define TAR(R1,R2) RRE_(0xB24C,R1,R2)
842 /* TEST BLOCK */
843 # define TB(R1,R2) RRE_(0xB22C,R1,R2)
844 /* TEST PROTECTION */
845 # define TPROT(D1,B1,D2,B2) SSE_(0xE501,B1,D1,B2,D2)
846 /* TRACE */
847 # define TRACE(R1,R3,D2,B2) RS_(0x99,R1,R3,B2,D2)
848 # define TRACG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0F)
849 /* TRAP */
850 # define TRAP2() E_(0x01FF)
851 # define TRAP4(D2,B2) S_(0xB2FF,B2,D2)
852 /****************************************************************
853 * I/O Instructions *
854 ****************************************************************/
855 /* CANCEL SUBCHANNEL */
856 # define XSCH() S_(0xB276,0,0)
857 /* CLEAR SUBCHANNEL */
858 # define CSCH() S_(0xB230,0,0)
859 /* HALT SUBCHANNEL */
860 # define HSCH() S_(0xB231,0,0)
861 /* MODIFY SUBCHANNEL */
862 # define MSCH(D2,B2) S_(0xB232,B2,D2)
863 /* RESET CHANNEL PATH */
864 # define RCHP() S_(0xB23B,0,0)
865 /* RESUME SUBCHANNEL */
866 # define RSCH() S_(0xB238,0,0)
867 /* SET ADDRESS LIMIT */
868 # define SAL() S_(0xB237,0,0)
869 /* SET CHANNEL MONITOR */
870 # define SCHM() S_(0xB23C,0,0)
871 /* START SUBCHANNEL */
872 # define SSCH(D2,B2) S_(0xB233,B2,D2)
873 /* STORE CHANNEL PATH STATUS */
874 # define STCPS(D2,B2) S_(0xB23A,B2,D2)
875 /* STORE CHANNEL REPORT WORD */
876 # define STCRW(D2,B2) S_(0xB239,B2,D2)
877 /* STORE SUBCHANNEL */
878 # define STSCH(D2,B2) S_(0xB234,B2,D2)
879 /* TEST PENDING INTERRUPTION */
880 # define TPI(D2,B2) S_(0xB236,B2,D2)
881 /* TEST SUBCHANNEL */
882 # define TSCH(D2,B2) S_(0xB235,B2,D2)
883 # define xdivr(r0,r1) _xdivr(_jit,r0,r1)
884 static jit_int32_t _xdivr(jit_state_t*,jit_int32_t,jit_int32_t);
885 # define xdivr_u(r0,r1) _xdivr_u(_jit,r0,r1)
886 static jit_int32_t _xdivr_u(jit_state_t*,jit_int32_t,jit_int32_t);
887 # define xdivi(r0,i0) _xdivi(_jit,r0,i0)
888 static jit_int32_t _xdivi(jit_state_t*,jit_int32_t,jit_word_t);
889 # define xdivi_u(r0,i0) _xdivi_u(_jit,r0,i0)
890 static jit_int32_t _xdivi_u(jit_state_t*,jit_int32_t,jit_word_t);
891 # define crr(cc,r0,r1,r2) _crr(_jit,cc,r0,r1,r2)
892 static void _crr(jit_state_t*,
893 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
894 # define cri(cc,r0,r1,i0) _cri(_jit,cc,r0,r1,i0)
895 static void _cri(jit_state_t*,
896 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
897 # define crr_u(cc,r0,r1,r2) _crr_u(_jit,cc,r0,r1,r2)
898 static void _crr_u(jit_state_t*,
899 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
900 # define cri_u(cc,r0,r1,i0) _cri_u(_jit,cc,r0,r1,i0)
901 static void _cri_u(jit_state_t*,
902 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
903 # define brr(cc,i0,r0,r1) _brr(_jit,cc,i0,r0,r1)
904 static void _brr(jit_state_t*,jit_int32_t,
905 jit_word_t,jit_int32_t,jit_int32_t);
906 # define brr_p(cc,i0,r0,r1) _brr_p(_jit,cc,i0,r0,r1)
907 static jit_word_t _brr_p(jit_state_t*,jit_int32_t,
908 jit_word_t,jit_int32_t,jit_int32_t);
909 # define bri(cc,i0,r0,i1) _bri(_jit,cc,i0,r0,i1)
910 static void _bri(jit_state_t*,jit_int32_t,
911 jit_word_t,jit_int32_t,jit_word_t);
912 # define bri_p(cc,i0,r0,i1) _bri_p(_jit,cc,i0,r0,i1)
913 static jit_word_t _bri_p(jit_state_t*,jit_int32_t,
914 jit_word_t,jit_int32_t,jit_word_t);
915 # define brr_u(cc,i0,r0,r1) _brr_u(_jit,cc,i0,r0,r1)
916 static void _brr_u(jit_state_t*,jit_int32_t,
917 jit_word_t,jit_int32_t,jit_int32_t);
918 # define brr_u_p(cc,i0,r0,r1) _brr_u_p(_jit,cc,i0,r0,r1)
919 static jit_word_t _brr_u_p(jit_state_t*,jit_int32_t,
920 jit_word_t,jit_int32_t,jit_int32_t);
921 # define bri_u(cc,i0,r0,i1) _bri_u(_jit,cc,i0,r0,i1)
922 static void _bri_u(jit_state_t*,jit_int32_t,
923 jit_word_t,jit_int32_t,jit_word_t);
924 # define bri_u_p(cc,i0,r0,i1) _bri_u_p(_jit,cc,i0,r0,i1)
925 static jit_word_t _bri_u_p(jit_state_t*,jit_int32_t,
926 jit_word_t,jit_int32_t,jit_word_t);
927 # define baddr(c,s,i0,r0,r1) _baddr(_jit,c,s,i0,r0,r1)
928 static void _baddr(jit_state_t*,jit_int32_t,jit_bool_t,
929 jit_word_t,jit_int32_t,jit_int32_t);
930 # define baddr_p(c,s,i0,r0,r1) _baddr_p(_jit,c,s,i0,r0,r1)
931 static jit_word_t _baddr_p(jit_state_t*,jit_int32_t,jit_bool_t,
932 jit_word_t,jit_int32_t,jit_int32_t);
933 # define baddi(c,s,i0,r0,i1) _baddi(_jit,c,s,i0,r0,i1)
934 static void _baddi(jit_state_t*,jit_int32_t,jit_bool_t,
935 jit_word_t,jit_int32_t,jit_word_t);
936 # define baddi_p(c,s,i0,r0,i1) _baddi_p(_jit,c,s,i0,r0,i1)
937 static jit_word_t _baddi_p(jit_state_t*,jit_int32_t,jit_bool_t,
938 jit_word_t,jit_int32_t,jit_word_t);
939 # define bsubr(c,s,i0,r0,r1) _bsubr(_jit,c,s,i0,r0,r1)
940 static void _bsubr(jit_state_t*,jit_int32_t,jit_bool_t,
941 jit_word_t,jit_int32_t,jit_int32_t);
942 # define bsubr_p(c,s,i0,r0,r1) _bsubr_p(_jit,c,s,i0,r0,r1)
943 static jit_word_t _bsubr_p(jit_state_t*,jit_int32_t,jit_bool_t,
944 jit_word_t,jit_int32_t,jit_int32_t);
945 # define bsubi(c,s,i0,r0,i1) _bsubi(_jit,c,s,i0,r0,i1)
946 static void _bsubi(jit_state_t*,jit_int32_t,jit_bool_t,
947 jit_word_t,jit_int32_t,jit_word_t);
948 # define bsubi_p(c,s,i0,r0,i1) _bsubi_p(_jit,c,s,i0,r0,i1)
949 static jit_word_t _bsubi_p(jit_state_t*,jit_int32_t,jit_bool_t,
950 jit_word_t,jit_int32_t,jit_word_t);
951 # define bmxr(cc,i0,r0,r1) _bmxr(_jit,cc,i0,r0,r1)
952 static void _bmxr(jit_state_t*,jit_int32_t,
953 jit_word_t,jit_int32_t,jit_int32_t);
954 # define bmxr_p(cc,i0,r0,r1) _bmxr_p(_jit,cc,i0,r0,r1)
955 static jit_word_t _bmxr_p(jit_state_t*,jit_int32_t,
956 jit_word_t,jit_int32_t,jit_int32_t);
957 # define bmxi(cc,i0,r0,i1) _bmxi(_jit,cc,i0,r0,i1)
958 static void _bmxi(jit_state_t*,jit_int32_t,
959 jit_word_t,jit_int32_t,jit_word_t);
960 # define bmxi_p(cc,i0,r0,i1) _bmxi_p(_jit,cc,i0,r0,i1)
961 static jit_word_t _bmxi_p(jit_state_t*,jit_int32_t,
962 jit_word_t,jit_int32_t,jit_word_t);
963 # define movr(r0,r1) _movr(_jit,r0,r1)
964 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
965 # define movi(r0,i0) _movi(_jit,r0,i0)
966 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
967 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
968 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
969 # define addr(r0,r1,r2) _addr(_jit,r0,r1,r2)
970 static void _addr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
971 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
972 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
973 # define addcr(r0,r1,r2) _addcr(_jit,r0,r1,r2)
974 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
975 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
976 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
977 # define addxr(r0,r1,r2) _addxr(_jit,r0,r1,r2)
978 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
979 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
980 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
981 # define subr(r0,r1,r2) _subr(_jit,r0,r1,r2)
982 static void _subr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
983 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
984 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
985 # define subcr(r0,r1,r2) _subcr(_jit,r0,r1,r2)
986 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
987 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
988 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
989 # define subxr(r0,r1,r2) _subxr(_jit,r0,r1,r2)
990 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
991 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
992 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
993 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
994 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
995 # define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
996 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
997 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
998 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
999 # define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
1000 static void _qmulr(jit_state_t*,jit_int32_t,
1001 jit_int32_t,jit_int32_t,jit_int32_t);
1002 # define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
1003 static void _qmuli(jit_state_t*,jit_int32_t,
1004 jit_int32_t,jit_int32_t,jit_word_t);
1005 # define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
1006 static void _qmulr_u(jit_state_t*,jit_int32_t,
1007 jit_int32_t,jit_int32_t,jit_int32_t);
1008 # define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
1009 static void _qmuli_u(jit_state_t*,jit_int32_t,
1010 jit_int32_t,jit_int32_t,jit_word_t);
1011 # define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
1012 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1013 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
1014 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1015 # define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
1016 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1017 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
1018 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1019 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
1020 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1021 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
1022 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1023 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
1024 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1025 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
1026 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1027 # define qdivr(r0,r1,r2,r3) _qdivr(_jit,r0,r1,r2,r3)
1028 static void _qdivr(jit_state_t*,jit_int32_t,
1029 jit_int32_t,jit_int32_t,jit_int32_t);
1030 # define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
1031 static void _qdivi(jit_state_t*,jit_int32_t,
1032 jit_int32_t,jit_int32_t,jit_word_t);
1033 # define qdivr_u(r0,r1,r2,r3) _qdivr_u(_jit,r0,r1,r2,r3)
1034 static void _qdivr_u(jit_state_t*,jit_int32_t,
1035 jit_int32_t,jit_int32_t,jit_int32_t);
1036 # define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
1037 static void _qdivi_u(jit_state_t*,jit_int32_t,
1038 jit_int32_t,jit_int32_t,jit_word_t);
1039 # if __WORDSIZE == 32
1040 # define lshr(r0,r1,r2) _lshr(_jit,r0,r1,r2)
1041 static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1042 # else
1043 # define lshr(r0,r1,r2) SLLG(r0,r1,0,r2)
1044 # endif
1045 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
1046 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1047 # if __WORDSIZE == 32
1048 # define rshr(r0,r1,r2) _rshr(_jit,r0,r1,r2)
1049 static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1050 # else
1051 # define rshr(r0,r1,r2) SRAG(r0,r1,0,r2)
1052 # endif
1053 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0)
1054 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1055 # if __WORDSIZE == 32
1056 # define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2)
1057 static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1058 # else
1059 # define rshr_u(r0,r1,r2) SRLG(r0,r1,0,r2)
1060 # endif
1061 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
1062 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1063 # if __WORDSIZE == 32
1064 # define negr(r0,r1) LCR(r0,r1)
1065 # else
1066 # define negr(r0,r1) LCGR(r0,r1)
1067 # endif
1068 # define comr(r0,r1) _comr(_jit,r0,r1)
1069 static void _comr(jit_state_t*,jit_int32_t,jit_int32_t);
1070 # define andr(r0,r1,r2) _andr(_jit,r0,r1,r2)
1071 static void _andr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1072 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
1073 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1074 # define orr(r0,r1,r2) _orr(_jit,r0,r1,r2)
1075 static void _orr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1076 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
1077 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1078 # define xorr(r0,r1,r2) _xorr(_jit,r0,r1,r2)
1079 static void _xorr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1080 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
1081 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1082 # define htonr_us(r0,r1) extr_us(r0,r1)
1083 # if __WORDSIZE == 32
1084 # define htonr_ui(r0,r1) movr(r0,r1)
1085 # else
1086 # define htonr_ui(r0,r1) extr_ui(r0,r1)
1087 # define htonr_ul(r0,r1) movr(r0,r1)
1088 # endif
1089 # define extr_c(r0,r1) LGBR(r0,r1)
1090 # define extr_uc(r0,r1) LLGCR(r0,r1)
1091 # define extr_s(r0,r1) LGHR(r0,r1)
1092 # define extr_us(r0,r1) LLGHR(r0,r1)
1093 # if __WORDSIZE == 64
1094 # define extr_i(r0,r1) LGFR(r0,r1)
1095 # define extr_ui(r0,r1) LLGFR(r0,r1)
1096 # endif
1097 # define ldr_c(r0,r1) LGB(r0,0,0,r1)
1098 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
1099 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
1100 # define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
1101 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1102 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
1103 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1104 # define ldr_uc(r0,r1) LLGC(r0,0,0,r1)
1105 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
1106 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
1107 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
1108 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1109 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
1110 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1111 # if __WORDSIZE == 32
1112 # define ldr_s(r0,r1) LH(r0,0,0,r1)
1113 # else
1114 # define ldr_s(r0,r1) LGH(r0,0,0,r1)
1115 # endif
1116 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
1117 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
1118 # define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
1119 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1120 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
1121 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1122 # define ldr_us(r0,r1) LLGH(r0,0,0,r1)
1123 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
1124 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
1125 # define ldxr_us(r0,r1,r2) _ldxr_us(_jit,r0,r1,r2)
1126 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1127 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
1128 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1129 # if __WORDSIZE == 32
1130 # define ldr_i(r0,r1) LLGF(r0,0,0,r1)
1131 # else
1132 # define ldr_i(r0,r1) LGF(r0,0,0,r1)
1133 # endif
1134 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
1135 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
1136 # define ldxr_i(r0,r1,r2) _ldxr_i(_jit,r0,r1,r2)
1137 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1138 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
1139 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1140 # if __WORDSIZE == 64
1141 # define ldr_ui(r0,r1) LLGF(r0,0,0,r1)
1142 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
1143 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
1144 # define ldxr_ui(r0,r1,r2) _ldxr_ui(_jit,r0,r1,r2)
1145 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1146 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
1147 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1148 # define ldr_l(r0,r1) LG(r0,0,0,r1)
1149 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
1150 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
1151 # define ldxr_l(r0,r1,r2) _ldxr_l(_jit,r0,r1,r2)
1152 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1153 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
1154 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1155 # endif
1156 # define str_c(r0,r1) STC(r1,0,0,r0)
1157 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
1158 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
1159 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
1160 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1161 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
1162 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1163 # define str_s(r0,r1) STH(r1,0,0,r0)
1164 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
1165 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
1166 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
1167 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1168 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
1169 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1170 # define str_i(r0,r1) ST(r1,0,0,r0)
1171 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
1172 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
1173 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
1174 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1175 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
1176 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1177 # if __WORDSIZE == 64
1178 # define str_l(r0,r1) STG(r1,0,0,r0)
1179 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
1180 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
1181 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
1182 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1183 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
1184 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1185 # endif
1186 # define ltr(r0,r1,r2) crr(CC_L,r0,r1,r2)
1187 # define lti(r0,r1,i0) cri(CC_L,r0,r1,i0)
1188 # define ltr_u(r0,r1,r2) crr_u(CC_L,r0,r1,r2)
1189 # define lti_u(r0,r1,i0) cri_u(CC_L,r0,r1,i0)
1190 # define ler(r0,r1,r2) crr(CC_LE,r0,r1,r2)
1191 # define lei(r0,r1,i0) cri(CC_LE,r0,r1,i0)
1192 # define ler_u(r0,r1,r2) crr_u(CC_LE,r0,r1,r2)
1193 # define lei_u(r0,r1,i0) cri_u(CC_LE,r0,r1,i0)
1194 # define eqr(r0,r1,r2) crr(CC_E,r0,r1,r2)
1195 # define eqi(r0,r1,i0) cri(CC_E,r0,r1,i0)
1196 # define ger(r0,r1,r2) crr(CC_HE,r0,r1,r2)
1197 # define gei(r0,r1,i0) cri(CC_HE,r0,r1,i0)
1198 # define ger_u(r0,r1,r2) crr_u(CC_HE,r0,r1,r2)
1199 # define gei_u(r0,r1,i0) cri_u(CC_HE,r0,r1,i0)
1200 # define gtr(r0,r1,r2) crr(CC_H,r0,r1,r2)
1201 # define gti(r0,r1,i0) cri(CC_H,r0,r1,i0)
1202 # define gtr_u(r0,r1,r2) crr_u(CC_H,r0,r1,r2)
1203 # define gti_u(r0,r1,i0) cri_u(CC_H,r0,r1,i0)
1204 # define ner(r0,r1,r2) crr(CC_NE,r0,r1,r2)
1205 # define nei(r0,r1,i0) cri(CC_NE,r0,r1,i0)
1206 # define bltr(i0,r0,r1) brr(CC_L,i0,r0,r1)
1207 # define bltr_p(i0,r0,r1) brr_p(CC_L,i0,r0,r1)
1208 # define blti(i0,r0,i1) bri(CC_L,i0,r0,i1)
1209 # define blti_p(i0,r0,i1) bri_p(CC_L,i0,r0,i1)
1210 # define bltr_u(i0,r0,r1) brr_u(CC_L,i0,r0,r1)
1211 # define bltr_u_p(i0,r0,r1) brr_u_p(CC_L,i0,r0,r1)
1212 # define blti_u(i0,r0,i1) bri_u(CC_L,i0,r0,i1)
1213 # define blti_u_p(i0,r0,i1) bri_u_p(CC_L,i0,r0,i1)
1214 # define bler(i0,r0,r1) brr(CC_LE,i0,r0,r1)
1215 # define bler_p(i0,r0,r1) brr_p(CC_LE,i0,r0,r1)
1216 # define blei(i0,r0,i1) bri(CC_LE,i0,r0,i1)
1217 # define blei_p(i0,r0,i1) bri_p(CC_LE,i0,r0,i1)
1218 # define bler_u(i0,r0,r1) brr_u(CC_LE,i0,r0,r1)
1219 # define bler_u_p(i0,r0,r1) brr_u_p(CC_LE,i0,r0,r1)
1220 # define blei_u(i0,r0,i1) bri_u(CC_LE,i0,r0,i1)
1221 # define blei_u_p(i0,r0,i1) bri_u_p(CC_LE,i0,r0,i1)
1222 # define beqr(i0,r0,r1) brr(CC_E,i0,r0,r1)
1223 # define beqr_p(i0,r0,r1) brr_p(CC_E,i0,r0,r1)
1224 # define beqi(i0,r0,i1) bri(CC_E,i0,r0,i1)
1225 # define beqi_p(i0,r0,i1) bri_p(CC_E,i0,r0,i1)
1226 # define bger(i0,r0,r1) brr(CC_HE,i0,r0,r1)
1227 # define bger_p(i0,r0,r1) brr_p(CC_HE,i0,r0,r1)
1228 # define bgei(i0,r0,i1) bri(CC_HE,i0,r0,i1)
1229 # define bgei_p(i0,r0,i1) bri_p(CC_HE,i0,r0,i1)
1230 # define bger_u(i0,r0,r1) brr_u(CC_HE,i0,r0,r1)
1231 # define bger_u_p(i0,r0,r1) brr_u_p(CC_HE,i0,r0,r1)
1232 # define bgei_u(i0,r0,i1) bri_u(CC_HE,i0,r0,i1)
1233 # define bgei_u_p(i0,r0,i1) bri_u_p(CC_HE,i0,r0,i1)
1234 # define bgtr(i0,r0,r1) brr(CC_H,i0,r0,r1)
1235 # define bgtr_p(i0,r0,r1) brr_p(CC_H,i0,r0,r1)
1236 # define bgti(i0,r0,i1) bri(CC_H,i0,r0,i1)
1237 # define bgti_p(i0,r0,i1) bri_p(CC_H,i0,r0,i1)
1238 # define bgtr_u(i0,r0,r1) brr_u(CC_H,i0,r0,r1)
1239 # define bgtr_u_p(i0,r0,r1) brr_u_p(CC_H,i0,r0,r1)
1240 # define bgti_u(i0,r0,i1) bri_u(CC_H,i0,r0,i1)
1241 # define bgti_u_p(i0,r0,i1) bri_u_p(CC_H,i0,r0,i1)
1242 # define bner(i0,r0,r1) brr(CC_NE,i0,r0,r1)
1243 # define bner_p(i0,r0,r1) brr_p(CC_NE,i0,r0,r1)
1244 # define bnei(i0,r0,i1) bri(CC_NE,i0,r0,i1)
1245 # define bnei_p(i0,r0,i1) bri_p(CC_NE,i0,r0,i1)
1246 # define boaddr(i0,r0,r1) baddr(CC_O,1,i0,r0,r1)
1247 # define boaddr_p(i0,r0,r1) baddr_p(CC_O,1,i0,r0,r1)
1248 # define boaddi(i0,r0,i1) baddi(CC_O,1,i0,r0,i1)
1249 # define boaddi_p(i0,r0,i1) baddi_p(CC_O,1,i0,r0,i1)
1250 # define boaddr_u(i0,r0,r1) baddr(CC_NLE,0,i0,r0,r1)
1251 # define boaddr_u_p(i0,r0,r1) baddr_p(CC_NLE,0,i0,r0,r1)
1252 # define boaddi_u(i0,r0,i1) baddi(CC_NLE,0,i0,r0,i1)
1253 # define boaddi_u_p(i0,r0,i1) baddi_p(CC_NLE,0,i0,r0,i1)
1254 # define bxaddr(i0,r0,r1) baddr(CC_NO,1,i0,r0,r1)
1255 # define bxaddr_p(i0,r0,r1) baddr_p(CC_NO,1,i0,r0,r1)
1256 # define bxaddi(i0,r0,i1) baddi(CC_NO,1,i0,r0,i1)
1257 # define bxaddi_p(i0,r0,i1) baddi_p(CC_NO,1,i0,r0,i1)
1258 # define bxaddr_u(i0,r0,r1) baddr(CC_LE,0,i0,r0,r1)
1259 # define bxaddr_u_p(i0,r0,r1) baddr_p(CC_LE,0,i0,r0,r1)
1260 # define bxaddi_u(i0,r0,i1) baddi(CC_LE,0,i0,r0,i1)
1261 # define bxaddi_u_p(i0,r0,i1) baddi_p(CC_LE,0,i0,r0,i1)
1262 # define bosubr(i0,r0,r1) bsubr(CC_O,1,i0,r0,r1)
1263 # define bosubr_p(i0,r0,r1) bsubr_p(CC_O,1,i0,r0,r1)
1264 # define bosubi(i0,r0,i1) bsubi(CC_O,1,i0,r0,i1)
1265 # define bosubi_p(i0,r0,i1) bsubi_p(CC_O,1,i0,r0,i1)
1266 # define bosubr_u(i0,r0,r1) bsubr(CC_L,0,i0,r0,r1)
1267 # define bosubr_u_p(i0,r0,r1) bsubr_p(CC_L,0,i0,r0,r1)
1268 # define bosubi_u(i0,r0,i1) bsubi(CC_L,0,i0,r0,i1)
1269 # define bosubi_u_p(i0,r0,i1) bsubi_p(CC_L,0,i0,r0,i1)
1270 # define bxsubr(i0,r0,r1) bsubr(CC_NO,1,i0,r0,r1)
1271 # define bxsubr_p(i0,r0,r1) bsubr_p(CC_NO,1,i0,r0,r1)
1272 # define bxsubi(i0,r0,i1) bsubi(CC_NO,1,i0,r0,i1)
1273 # define bxsubi_p(i0,r0,i1) bsubi_p(CC_NO,1,i0,r0,i1)
1274 # define bxsubr_u(i0,r0,r1) bsubr(CC_NL,0,i0,r0,r1)
1275 # define bxsubr_u_p(i0,r0,r1) bsubr_p(CC_NL,0,i0,r0,r1)
1276 # define bxsubi_u(i0,r0,i1) bsubi(CC_NL,0,i0,r0,i1)
1277 # define bxsubi_u_p(i0,r0,i1) bsubi_p(CC_NL,0,i0,r0,i1)
1278 # define bmsr(i0,r0,r1) bmxr(CC_NE,i0,r0,r1)
1279 # define bmsr_p(i0,r0,r1) bmxr_p(CC_NE,i0,r0,r1)
1280 # define bmsi(i0,r0,i1) bmxi(CC_NE,i0,r0,i1)
1281 # define bmsi_p(i0,r0,i1) bmxi_p(CC_NE,i0,r0,i1)
1282 # define bmcr(i0,r0,r1) bmxr(CC_E,i0,r0,r1)
1283 # define bmcr_p(i0,r0,r1) bmxr_p(CC_E,i0,r0,r1)
1284 # define bmci(i0,r0,i1) bmxi(CC_E,i0,r0,i1)
1285 # define bmci_p(i0,r0,i1) bmxi_p(CC_E,i0,r0,i1)
1286 # define jmpr(r0) BR(r0)
1287 # define jmpi(i0) _jmpi(_jit,i0)
1288 static void _jmpi(jit_state_t*,jit_word_t);
1289 # define jmpi_p(i0) _jmpi_p(_jit,i0)
1290 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
1291 # define callr(r0) BALR(_R14_REGNO,r0)
1292 # define calli(i0) _calli(_jit,i0)
1293 static void _calli(jit_state_t*,jit_word_t);
1294 # define calli_p(i0) _calli_p(_jit,i0)
1295 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
1296 # define prolog(i0) _prolog(_jit,i0)
1297 static void _prolog(jit_state_t*,jit_node_t*);
1298 # define epilog(i0) _epilog(_jit,i0)
1299 static void _epilog(jit_state_t*,jit_node_t*);
1300 # define vastart(r0) _vastart(_jit, r0)
1301 static void _vastart(jit_state_t*, jit_int32_t);
1302 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
1303 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
1304 # define patch_at(instr,label) _patch_at(_jit,instr,label)
1305 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
1306 #endif
1307
1308 #if CODE
1309 # define _us jit_uint16_t
1310 # define _ui jit_uint32_t
1311 static void
_E(jit_state_t * _jit,_ui Op)1312 _E(jit_state_t *_jit, _ui Op)
1313 {
1314 union {
1315 struct {
1316 _us op;
1317 } b;
1318 _us s;
1319 } i0;
1320 i0.b.op = Op;
1321 assert(i0.b.op == Op);
1322 is(i0.s);
1323 }
1324
1325 static void
_I(jit_state_t * _jit,_ui Op,_ui I)1326 _I(jit_state_t *_jit, _ui Op, _ui I)
1327 {
1328 union {
1329 struct {
1330 _us op : 8;
1331 _us i : 8;
1332 } b;
1333 _us s;
1334 } i0;
1335 i0.b.op = Op;
1336 i0.b.i = I;
1337 assert(i0.b.op == Op);
1338 assert(i0.b.i == I);
1339 is(i0.s);
1340 }
1341
1342 static void
_RR(jit_state_t * _jit,_ui Op,_ui R1,_ui R2)1343 _RR(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1344 {
1345 union {
1346 struct {
1347 _us op : 8;
1348 _us r1 : 4;
1349 _us r2 : 4;
1350 } b;
1351 _us s;
1352 } i0;
1353 i0.b.op = Op;
1354 i0.b.r1 = R1;
1355 i0.b.r2 = R2;
1356 assert(i0.b.op == Op);
1357 assert(i0.b.r1 == R1);
1358 assert(i0.b.r2 == R2);
1359 is(i0.s);
1360 }
1361
1362 static void
_RRE(jit_state_t * _jit,_ui Op,_ui R1,_ui R2)1363 _RRE(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1364 {
1365 union {
1366 struct {
1367 _us op;
1368 } b;
1369 _us s;
1370 } i0;
1371 union {
1372 struct {
1373 _us _ : 8;
1374 _us r1 : 4;
1375 _us r2 : 4;
1376 } b;
1377 _us s;
1378 } i1;
1379 i0.b.op = Op;
1380 i1.b._ = 0;
1381 i1.b.r1 = R1;
1382 i1.b.r2 = R2;
1383 assert(i0.b.op == Op);
1384 assert(i1.b.r1 == R1);
1385 assert(i1.b.r2 == R2);
1386 is(i0.s);
1387 is(i1.s);
1388 }
1389
1390 static void
_RRF(jit_state_t * _jit,_ui Op,_ui R3,_ui M4,_ui R1,_ui R2)1391 _RRF(jit_state_t *_jit, _ui Op, _ui R3, _ui M4, _ui R1, _ui R2)
1392 {
1393 union {
1394 struct {
1395 _us op;
1396 } b;
1397 _us s;
1398 } i0;
1399 union {
1400 struct {
1401 _us r3 : 4;
1402 _us m4 : 4;
1403 _us r1 : 4;
1404 _us r2 : 4;
1405 } b;
1406 _us s;
1407 } i1;
1408 i0.b.op = Op;
1409 i1.b.r3 = R3;
1410 i1.b.m4 = M4;
1411 i1.b.r1 = R1;
1412 i1.b.r2 = R2;
1413 assert(i0.b.op == Op);
1414 assert(i1.b.r3 == R3);
1415 assert(i1.b.m4 == M4);
1416 assert(i1.b.r1 == R1);
1417 assert(i1.b.r2 == R2);
1418 is(i0.s);
1419 is(i1.s);
1420 }
1421
1422 static void
_RX(jit_state_t * _jit,_ui Op,_ui R1,_ui X2,_ui B2,_ui D2)1423 _RX(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2)
1424 {
1425 union {
1426 struct {
1427 _us op : 8;
1428 _us r1 : 4;
1429 _us x2 : 4;
1430 } b;
1431 _us s;
1432 } i0;
1433 union {
1434 struct {
1435 _us b2 : 4;
1436 _us d2 : 12;
1437 } b;
1438 _us s;
1439 } i1;
1440 i0.b.op = Op;
1441 i0.b.r1 = R1;
1442 i0.b.x2 = X2;
1443 i1.b.b2 = B2;
1444 i1.b.d2 = D2;
1445 assert(i0.b.op == Op);
1446 assert(i0.b.r1 == R1);
1447 assert(i0.b.x2 == X2);
1448 assert(i1.b.b2 == B2);
1449 assert(i1.b.d2 == D2);
1450 is(i0.s);
1451 is(i1.s);
1452 }
1453
1454 static void
_RXE(jit_state_t * _jit,_ui Op,_ui R1,_ui X2,_ui B2,_ui D2,_ui Op2)1455 _RXE(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1456 {
1457 union {
1458 struct {
1459 _us op : 8;
1460 _us r1 : 4;
1461 _us x2 : 4;
1462 } b;
1463 _us s;
1464 } i0;
1465 union {
1466 struct {
1467 _us b2 : 4;
1468 _us d2 : 12;
1469 } b;
1470 _ui s;
1471 } i1;
1472 union {
1473 struct {
1474 _us _ : 8;
1475 _us op : 8;
1476 } b;
1477 _us s;
1478 } i2;
1479 i2.b._ = 0;
1480 i0.b.op = Op;
1481 i0.b.r1 = R1;
1482 i0.b.x2 = X2;
1483 i1.b.b2 = B2;
1484 i1.b.d2 = D2;
1485 i2.b.op = Op2;
1486 assert(i0.b.op == Op);
1487 assert(i0.b.r1 == R1);
1488 assert(i0.b.x2 == X2);
1489 assert(i1.b.b2 == B2);
1490 assert(i1.b.d2 == D2);
1491 assert(i2.b.op == Op2);
1492 is(i0.s);
1493 is(i1.s);
1494 is(i2.s);
1495 }
1496
1497 static void
_RXF(jit_state_t * _jit,_ui Op,_ui R3,_ui X2,_ui B2,_ui D2,_ui R1,_ui Op2)1498 _RXF(jit_state_t *_jit, _ui Op, _ui R3, _ui X2, _ui B2, _ui D2, _ui R1, _ui Op2)
1499 {
1500 union {
1501 struct {
1502 _us op : 8;
1503 _us r3 : 4;
1504 _us x2 : 4;
1505 } b;
1506 _us s;
1507 } i0;
1508 union {
1509 struct {
1510 _us b2 : 4;
1511 _us d2 : 12;
1512 } b;
1513 _us s;
1514 } i1;
1515 union {
1516 struct {
1517 _us r1 : 4;
1518 _us _ : 4;
1519 _us op : 8;
1520 } b;
1521 _us s;
1522 } i2;
1523 i2.b._ = 0;
1524 i0.b.op = Op;
1525 i0.b.r3 = R3;
1526 i0.b.x2 = X2;
1527 i1.b.b2 = B2;
1528 i1.b.d2 = D2;
1529 i2.b.r1 = R1;
1530 i2.b.op = Op2;
1531 assert(i0.b.op == Op);
1532 assert(i0.b.r3 == R3);
1533 assert(i0.b.x2 == X2);
1534 assert(i1.b.b2 == B2);
1535 assert(i1.b.d2 == D2);
1536 assert(i2.b.r1 == R1);
1537 assert(i2.b.op == Op2);
1538 is(i0.s);
1539 is(i1.s);
1540 is(i2.s);
1541 }
1542
1543 static void
_RXY(jit_state_t * _jit,_ui Op,_ui R1,_ui X2,_ui B2,_ui D2,_ui Op2)1544 _RXY(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1545 {
1546 union {
1547 struct {
1548 _us op : 8;
1549 _us r1 : 4;
1550 _us x2 : 4;
1551 } b;
1552 _us s;
1553 } i0;
1554 union {
1555 struct {
1556 _us b2 : 4;
1557 _us dl : 12;
1558 } b;
1559 _us s;
1560 } i1;
1561 union {
1562 struct {
1563 _us dh : 8;
1564 _us op : 8;
1565 } b;
1566 _us s;
1567 } i2;
1568 i0.s = i1.s = i2.s = 0;
1569 i0.b.op = Op;
1570 i0.b.r1 = R1;
1571 i0.b.x2 = X2;
1572 i1.b.b2 = B2;
1573 i1.b.dl = D2 & 0xfff;
1574 i2.b.dh = D2 >> 12;
1575 i2.b.op = Op2;
1576 assert(i0.b.op == Op);
1577 assert(i0.b.r1 == R1);
1578 assert(i0.b.x2 == X2);
1579 assert(i1.b.b2 == B2);
1580 assert(i2.b.dh == D2 >> 12);
1581 assert(i2.b.op == Op2);
1582 is(i0.s);
1583 is(i1.s);
1584 is(i2.s);
1585 }
1586
1587 static void
_RS(jit_state_t * _jit,_ui Op,_ui R1,_ui R3,_ui B2,_ui D2)1588 _RS(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui B2, _ui D2)
1589 {
1590 union {
1591 struct {
1592 _us op : 8;
1593 _us r1 : 4;
1594 _us r3 : 4;
1595 } b;
1596 _us s;
1597 } i0;
1598 union {
1599 struct {
1600 _us b2 : 4;
1601 _us d2 : 12;
1602 } b;
1603 _us s;
1604 } i1;
1605 i0.s = i1.s = 0;
1606 i0.b.op = Op;
1607 i0.b.r1 = R1;
1608 i0.b.r3 = R3;
1609 i1.b.b2 = B2;
1610 i1.b.d2 = D2;
1611 assert(i0.b.op == Op);
1612 assert(i0.b.r1 == R1);
1613 assert(i0.b.r3 == R3);
1614 assert(i1.b.b2 == B2);
1615 assert(i1.b.d2 == D2);
1616 is(i0.s);
1617 is(i1.s);
1618 }
1619
1620 static void
_RSL(jit_state_t * _jit,_ui Op,_ui L1,_ui B1,_ui D1,_ui Op2)1621 _RSL(jit_state_t *_jit, _ui Op, _ui L1, _ui B1, _ui D1, _ui Op2)
1622 {
1623 union {
1624 struct {
1625 _us op : 8;
1626 _us l1 : 4;
1627 _us _ : 4;
1628 } b;
1629 _us s;
1630 } i0;
1631 union {
1632 struct {
1633 _us b1 : 4;
1634 _us d1 : 12;
1635 } b;
1636 _us s;
1637 } i1;
1638 union {
1639 struct {
1640 _us _ : 8;
1641 _us op : 8;
1642 } b;
1643 _us s;
1644 } i2;
1645 i0.b._ = 0;
1646 i2.b._ = 0;
1647 i0.b.op = Op;
1648 i0.b.l1 = L1;
1649 i1.b.b1 = B1;
1650 i1.b.d1 = D1;
1651 i2.b.op = Op2;
1652 assert(i0.b.op == Op);
1653 assert(i0.b.l1 == L1);
1654 assert(i1.b.b1 == B1);
1655 assert(i1.b.d1 == D1);
1656 assert(i2.b.op == Op2);
1657 is(i0.s);
1658 is(i1.s);
1659 is(i2.s);
1660 }
1661
1662 static void
_RSI(jit_state_t * _jit,_ui Op,_ui R1,_ui R3,_ui I2)1663 _RSI(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2)
1664 {
1665 union {
1666 struct {
1667 _us op : 8;
1668 _us r1 : 4;
1669 _us r3 : 4;
1670 } b;
1671 _us s;
1672 } i0;
1673 union {
1674 struct {
1675 _us i2;
1676 } b;
1677 _us s;
1678 } i1;
1679 i0.b.op = Op;
1680 i0.b.r1 = R1;
1681 i0.b.r3 = R3;
1682 i1.b.i2 = I2;
1683 assert(i0.b.op == Op);
1684 assert(i0.b.r1 == R1);
1685 assert(i0.b.r3 == R3);
1686 assert(i1.b.i2 == I2);
1687 is(i0.s);
1688 is(i1.s);
1689 }
1690
1691 static void
_RIE(jit_state_t * _jit,_ui Op,_ui R1,_ui R3,_ui I2,_ui Op2)1692 _RIE(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2, _ui Op2)
1693 {
1694 union {
1695 struct {
1696 _us op : 8;
1697 _us r1 : 4;
1698 _us r3 : 4;
1699 } b;
1700 _us s;
1701 } i0;
1702 union {
1703 struct {
1704 _us i2;
1705 } b;
1706 _us s;
1707 } i1;
1708 union {
1709 struct {
1710 _us _ : 8;
1711 _us op : 8;
1712 } b;
1713 _us s;
1714 } i2;
1715 i2.b._ = 0;
1716 i0.b.op = Op;
1717 i0.b.r1 = R1;
1718 i0.b.r3 = R3;
1719 i1.b.i2 = I2;
1720 i2.b.op = Op2;
1721 assert(i0.b.op == Op);
1722 assert(i0.b.r1 == R1);
1723 assert(i0.b.r3 == R3);
1724 assert(i1.b.i2 == I2);
1725 assert(i2.b.op == Op2);
1726 is(i0.s);
1727 is(i1.s);
1728 is(i2.s);
1729 }
1730
1731 static void
_RIL(jit_state_t * _jit,_ui Op,_ui R1,_ui Op2,_ui I2)1732 _RIL(jit_state_t *_jit, _ui Op, _ui R1, _ui Op2, _ui I2)
1733 {
1734 union {
1735 struct {
1736 _us o1 : 8;
1737 _us r1 : 4;
1738 _us o2 : 4;
1739 } b;
1740 _us s;
1741 } i0;
1742 union {
1743 struct {
1744 _ui ih : 16;
1745 _ui il : 16;
1746 } b;
1747 _ui i;
1748 } i12;
1749 i0.b.o1 = Op;
1750 i0.b.r1 = R1;
1751 i0.b.o2 = Op2;
1752 i12.i = I2;
1753 assert(i0.b.o1 == Op);
1754 assert(i0.b.r1 == R1);
1755 assert(i0.b.o2 == Op2);
1756 is(i0.s);
1757 is(i12.b.ih);
1758 is(i12.b.il);
1759 }
1760
1761 static void
_SI(jit_state_t * _jit,_ui Op,_ui I2,_ui B1,_ui D1)1762 _SI(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1)
1763 {
1764 union {
1765 struct {
1766 _us op : 8;
1767 _us i2 : 8;
1768 } b;
1769 _us s;
1770 } i0;
1771 union {
1772 struct {
1773 _us b1 : 4;
1774 _us d1 : 12;
1775 } b;
1776 _us s;
1777 } i1;
1778 i0.b.op = Op;
1779 i0.b.i2 = I2;
1780 i1.b.b1 = B1;
1781 i1.b.d1 = D1;
1782 assert(i0.b.op == Op);
1783 assert(i0.b.i2 == I2);
1784 assert(i1.b.b1 == B1);
1785 assert(i1.b.d1 == D1);
1786 is(i0.s);
1787 is(i1.s);
1788 }
1789
1790 static void
_SIY(jit_state_t * _jit,_ui Op,_ui I2,_ui B1,_ui D1,_ui Op2)1791 _SIY(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1, _ui Op2)
1792 {
1793 union {
1794 struct {
1795 _us op : 8;
1796 _us i2 : 8;
1797 } b;
1798 _us s;
1799 } i0;
1800 union {
1801 struct {
1802 _us b1 : 4;
1803 _us dl : 12;
1804 } b;
1805 _us s;
1806 } i1;
1807 union {
1808 struct {
1809 _us dh : 8;
1810 _us op : 8;
1811 } b;
1812 _us s;
1813 } i2;
1814 i0.b.op = Op;
1815 i0.b.i2 = I2;
1816 i1.b.b1 = B1;
1817 i1.b.dl = D1 & 0xfff;
1818 i2.b.dh = D1 >> 8;
1819 i2.b.op = Op2;
1820 assert(i0.b.op == Op);
1821 assert(i0.b.i2 == I2);
1822 assert(i1.b.b1 == B1);
1823 assert(i2.b.dh == D1 >> 8);
1824 assert(i2.b.op == Op2);
1825 is(i0.s);
1826 is(i1.s);
1827 is(i2.s);
1828 }
1829
1830 static void
_S(jit_state_t * _jit,_ui Op,_ui B2,_ui D2)1831 _S(jit_state_t *_jit, _ui Op, _ui B2, _ui D2)
1832 {
1833 union {
1834 struct {
1835 _us op;
1836 } b;
1837 _us s;
1838 } i0;
1839 union {
1840 struct {
1841 _us b2 : 4;
1842 _us d2 : 12;
1843 } b;
1844 _us s;
1845 } i1;
1846 i0.b.op = Op;
1847 i1.b.b2 = B2;
1848 i1.b.d2 = D2;
1849 assert(i0.b.op == Op);
1850 assert(i1.b.b2 == B2);
1851 assert(i1.b.d2 == D2);
1852 is(i0.s);
1853 is(i1.s);
1854 }
1855
1856 static void
_SS(jit_state_t * _jit,_ui Op,_ui LL,_ui LH,_ui B1,_ui D1,_ui B2,_ui D2)1857 _SS(jit_state_t *_jit, _ui Op, _ui LL, _ui LH, _ui B1, _ui D1, _ui B2, _ui D2)
1858 {
1859 union {
1860 struct {
1861 _us op : 8;
1862 _us ll : 4;
1863 _us lh : 4;
1864 } b;
1865 _us s;
1866 } i0;
1867 union {
1868 struct {
1869 _us b1 : 4;
1870 _us d1 : 12;
1871 } b;
1872 _us s;
1873 } i1;
1874 union {
1875 struct {
1876 _us b2 : 4;
1877 _us d2 : 12;
1878 } b;
1879 _us s;
1880 } i2;
1881 i0.b.op = Op;
1882 i0.b.ll = LL;
1883 i0.b.lh = LH;
1884 i1.b.b1 = B1;
1885 i1.b.d1 = D1;
1886 i2.b.b2 = B2;
1887 i2.b.d2 = D2;
1888 assert(i0.b.op == Op);
1889 assert(i0.b.ll == LL);
1890 assert(i0.b.lh == LH);
1891 assert(i1.b.b1 == B1);
1892 assert(i1.b.d1 == D1);
1893 assert(i2.b.b2 == B2);
1894 assert(i2.b.d2 == D2);
1895 is(i0.s);
1896 is(i1.s);
1897 is(i2.s);
1898 }
1899
1900 static void
_SSE(jit_state_t * _jit,_ui Op,_ui B1,_ui D1,_ui B2,_ui D2)1901 _SSE(jit_state_t *_jit, _ui Op, _ui B1, _ui D1, _ui B2, _ui D2)
1902 {
1903 union {
1904 struct {
1905 _us op;
1906 } b;
1907 _us s;
1908 } i0;
1909 union {
1910 struct {
1911 _us b1 : 4;
1912 _us d1 : 12;
1913 } b;
1914 _us s;
1915 } i1;
1916 union {
1917 struct {
1918 _us b2 : 4;
1919 _us d2 : 12;
1920 } b;
1921 _us s;
1922 } i2;
1923 i0.b.op = Op;
1924 i1.b.b1 = B1;
1925 i1.b.d1 = D1;
1926 i2.b.b2 = B2;
1927 i2.b.d2 = D2;
1928 assert(i0.b.op == Op);
1929 assert(i1.b.b1 == B1);
1930 assert(i1.b.d1 == D1);
1931 assert(i2.b.b2 == B2);
1932 assert(i2.b.d2 == D2);
1933 is(i0.s);
1934 is(i1.s);
1935 is(i2.s);
1936 }
1937 # undef _us
1938 # undef _ui
1939
1940 static void
_nop(jit_state_t * _jit,jit_int32_t c)1941 _nop(jit_state_t *_jit, jit_int32_t c)
1942 {
1943 assert(c >= 0 && !(c & 1));
1944 while (c) {
1945 NOPR(_R7_REGNO);
1946 c -= 2;
1947 }
1948 }
1949
1950 static jit_int32_t
_xdivr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)1951 _xdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1952 {
1953 jit_int32_t regno;
1954 regno = jit_get_reg_pair();
1955 #if __WORDSIZE == 32
1956 movr(rn(regno), r0);
1957 SRDA(rn(regno), 32, 0);
1958 #else
1959 movr(rn(regno) + 1, r0);
1960 #endif
1961 DIVREM_(rn(regno), r1);
1962 jit_unget_reg_pair(regno);
1963 return (regno);
1964 }
1965
1966 static jit_int32_t
_xdivr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)1967 _xdivr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1968 {
1969 jit_int32_t regno;
1970 regno = jit_get_reg_pair();
1971 #if __WORDSIZE == 32
1972 movr(rn(regno), r0);
1973 SRDL(rn(regno), 32, 0);
1974 #else
1975 movr(rn(regno) + 1, r0);
1976 #endif
1977 movi(rn(regno), 0);
1978 DIVREMU_(rn(regno), r1);
1979 jit_unget_reg_pair(regno);
1980 return (regno);
1981 }
1982
1983 static jit_int32_t
_xdivi(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)1984 _xdivi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1985 {
1986 jit_int32_t imm, regno;
1987 regno = jit_get_reg_pair();
1988 imm = jit_get_reg(jit_class_gpr);
1989 #if __WORDSIZE == 32
1990 movr(rn(regno), r0);
1991 SRDA(rn(regno), 32, 0);
1992 #else
1993 movr(rn(regno) + 1, r0);
1994 #endif
1995 movi(rn(imm), i0);
1996 DIVREM_(rn(regno), rn(imm));
1997 jit_unget_reg(imm);
1998 jit_unget_reg_pair(regno);
1999 return (regno);
2000 }
2001
2002 static jit_int32_t
_xdivi_u(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2003 _xdivi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2004 {
2005 /* cannot overlap because operand is 128-bit */
2006 jit_int32_t imm, regno;
2007 regno = jit_get_reg_pair();
2008 imm = jit_get_reg(jit_class_gpr);
2009 #if __WORDSIZE == 32
2010 movr(rn(regno), r0);
2011 SRDL(rn(regno), 32, 0);
2012 #else
2013 movr(rn(regno) + 1, r0);
2014 #endif
2015 movi(rn(regno), 0);
2016 movi(rn(imm), i0);
2017 DIVREMU_(rn(regno), rn(imm));
2018 jit_unget_reg(imm);
2019 jit_unget_reg_pair(regno);
2020 return (regno);
2021 }
2022
2023 static void
_crr(jit_state_t * _jit,jit_int32_t cc,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2024 _crr(jit_state_t *_jit, jit_int32_t cc,
2025 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2026 {
2027 jit_word_t w;
2028 jit_int32_t reg, rg;
2029 if (r0 == r1 || r0 == r2) {
2030 reg = jit_get_reg(jit_class_gpr);
2031 rg = rn(reg);
2032 }
2033 else
2034 rg = r0;
2035 movi(rg, 1);
2036 CMP_(r1, r2);
2037 w = _jit->pc.w;
2038 BRC(cc, 0);
2039 movi(rg, 0);
2040 patch_at(w, _jit->pc.w);
2041 if (r0 == r1 || r0 == r2) {
2042 movr(r0, rg);
2043 jit_unget_reg(reg);
2044 }
2045 }
2046
2047 static void
_cri(jit_state_t * _jit,jit_int32_t cc,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2048 _cri(jit_state_t *_jit, jit_int32_t cc,
2049 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2050 {
2051 jit_int32_t reg;
2052 reg = jit_get_reg(jit_class_gpr);
2053 movi(rn(reg), i0);
2054 crr(cc, r0, r1, rn(reg));
2055 jit_unget_reg(reg);
2056 }
2057
2058 static void
_crr_u(jit_state_t * _jit,jit_int32_t cc,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2059 _crr_u(jit_state_t *_jit, jit_int32_t cc,
2060 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2061 {
2062 jit_word_t w;
2063 jit_int32_t reg, rg;
2064 if (r0 == r1 || r0 == r2) {
2065 reg = jit_get_reg(jit_class_gpr);
2066 rg = rn(reg);
2067 }
2068 else
2069 rg = r0;
2070 movi(rg, 1);
2071 CMPU_(r1, r2);
2072 w = _jit->pc.w;
2073 BRC(cc, 0);
2074 movi(rg, 0);
2075 patch_at(w, _jit->pc.w);
2076 if (r0 == r1 || r0 == r2) {
2077 movr(r0, rg);
2078 jit_unget_reg(reg);
2079 }
2080 }
2081
2082 static void
_cri_u(jit_state_t * _jit,jit_int32_t cc,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2083 _cri_u(jit_state_t *_jit, jit_int32_t cc,
2084 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2085 {
2086 jit_int32_t reg;
2087 reg = jit_get_reg(jit_class_gpr);
2088 movi(rn(reg), i0);
2089 crr_u(cc, r0, r1, rn(reg));
2090 jit_unget_reg(reg);
2091 }
2092
2093 static void
_brr(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2094 _brr(jit_state_t *_jit, jit_int32_t cc,
2095 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2096 {
2097 jit_word_t d;
2098 CMP_(r0, r1);
2099 d = (i0 - _jit->pc.w) >> 1;
2100 if (s16_p(d))
2101 BRC(cc, x16(d));
2102 else {
2103 assert(s32_p(d));
2104 BRCL(cc, d);
2105 }
2106 }
2107
2108 static jit_word_t
_brr_p(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2109 _brr_p(jit_state_t *_jit, jit_int32_t cc,
2110 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2111 {
2112 jit_word_t w;
2113 CMP_(r0, r1);
2114 w = _jit->pc.w;
2115 BRCL(cc, 0);
2116 return (w);
2117 }
2118
2119 static void
_bri(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2120 _bri(jit_state_t *_jit, jit_int32_t cc,
2121 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2122 {
2123 jit_int32_t reg;
2124 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2125 movi(rn(reg), i1);
2126 brr(cc, i0, r0, rn(reg));
2127 jit_unget_reg(reg);
2128 }
2129
2130 static jit_word_t
_bri_p(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2131 _bri_p(jit_state_t *_jit, jit_int32_t cc,
2132 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2133 {
2134 jit_word_t w;
2135 jit_int32_t reg;
2136 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2137 movi(rn(reg), i1);
2138 w = brr_p(cc, i0, r0, rn(reg));
2139 jit_unget_reg(reg);
2140 return (w);
2141 }
2142
2143 static void
_brr_u(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2144 _brr_u(jit_state_t *_jit, jit_int32_t cc,
2145 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2146 {
2147 jit_word_t d;
2148 CMPU_(r0, r1);
2149 d = (i0 - _jit->pc.w) >> 1;
2150 if (s16_p(d))
2151 BRC(cc, x16(d));
2152 else {
2153 assert(s32_p(d));
2154 BRCL(cc, d);
2155 }
2156 }
2157
2158 static jit_word_t
_brr_u_p(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2159 _brr_u_p(jit_state_t *_jit, jit_int32_t cc,
2160 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2161 {
2162 jit_word_t w;
2163 CMPU_(r0, r1);
2164 w = _jit->pc.w;
2165 BRCL(cc, 0);
2166 return (w);
2167 }
2168
2169 static void
_bri_u(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2170 _bri_u(jit_state_t *_jit, jit_int32_t cc,
2171 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2172 {
2173 jit_int32_t reg;
2174 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2175 movi(rn(reg), i1);
2176 brr_u(cc, i0, r0, rn(reg));
2177 jit_unget_reg(reg);
2178 }
2179
2180 static jit_word_t
_bri_u_p(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2181 _bri_u_p(jit_state_t *_jit, jit_int32_t cc,
2182 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2183 {
2184 jit_word_t w;
2185 jit_int32_t reg;
2186 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2187 movi(rn(reg), i1);
2188 w = brr_u_p(cc, i0, r0, rn(reg));
2189 jit_unget_reg(reg);
2190 return (w);
2191 }
2192
2193 static void
_baddr(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2194 _baddr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2195 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2196 {
2197 jit_word_t d;
2198 if (s) addr(r0, r0, r1);
2199 else addcr(r0, r0, r1);
2200 d = (i0 - _jit->pc.w) >> 1;
2201 if (s16_p(d))
2202 BRC(c, x16(d));
2203 else {
2204 assert(s32_p(d));
2205 BRCL(c, d);
2206 }
2207 }
2208
2209 static void
_baddi(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2210 _baddi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2211 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2212 {
2213 jit_int32_t reg;
2214 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2215 movi(rn(reg), i1);
2216 baddr(c, s, i0, r0, rn(reg));
2217 jit_unget_reg(reg);
2218 }
2219
2220 static jit_word_t
_baddr_p(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2221 _baddr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2222 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2223 {
2224 jit_word_t d, w;
2225 if (s) addr(r0, r0, r1);
2226 else addcr(r0, r0, r1);
2227 d = (i0 - _jit->pc.w) >> 1;
2228 w = _jit->pc.w;
2229 BRCL(c, d);
2230 return (w);
2231 }
2232
2233 static jit_word_t
_baddi_p(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2234 _baddi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2235 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2236 {
2237 jit_word_t w;
2238 jit_int32_t reg;
2239 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2240 movi(rn(reg), i1);
2241 w = baddr_p(c, s, i0, r0, rn(reg));
2242 jit_unget_reg(reg);
2243 return (w);
2244 }
2245
2246 static void
_bsubr(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2247 _bsubr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2248 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2249 {
2250 jit_word_t d;
2251 if (s) subr(r0, r0, r1);
2252 else subcr(r0, r0, r1);
2253 d = (i0 - _jit->pc.w) >> 1;
2254 if (s16_p(d))
2255 BRC(c, x16(d));
2256 else {
2257 assert(s32_p(d));
2258 BRCL(c, d);
2259 }
2260 }
2261
2262 static void
_bsubi(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2263 _bsubi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2264 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2265 {
2266 jit_int32_t reg;
2267 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2268 movi(rn(reg), i1);
2269 bsubr(c, s, i0, r0, rn(reg));
2270 jit_unget_reg(reg);
2271 }
2272
2273 static jit_word_t
_bsubr_p(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2274 _bsubr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2275 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2276 {
2277 jit_word_t d, w;
2278 if (s) subr(r0, r0, r1);
2279 else subcr(r0, r0, r1);
2280 d = (i0 - _jit->pc.w) >> 1;
2281 w = _jit->pc.w;
2282 BRCL(c, d);
2283 return (w);
2284 }
2285
2286 static jit_word_t
_bsubi_p(jit_state_t * _jit,jit_int32_t c,jit_bool_t s,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2287 _bsubi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2288 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2289 {
2290 jit_word_t w;
2291 jit_int32_t reg;
2292 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2293 movi(rn(reg), i1);
2294 w = bsubr_p(c, s, i0, r0, rn(reg));
2295 jit_unget_reg(reg);
2296 return (w);
2297 }
2298
2299 static void
_bmxr(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2300 _bmxr(jit_state_t *_jit, jit_int32_t cc,
2301 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2302 {
2303 jit_word_t d;
2304 jit_int32_t reg;
2305 reg = jit_get_reg(jit_class_gpr);
2306 movr(rn(reg), r0);
2307 andr(rn(reg), rn(reg), r1);
2308 TEST_(rn(reg), rn(reg));
2309 jit_unget_reg(reg);
2310 d = (i0 - _jit->pc.w) >> 1;
2311 if (s16_p(d))
2312 BRC(cc, x16(d));
2313 else {
2314 assert(s32_p(d));
2315 BRCL(cc, d);
2316 }
2317 }
2318
2319 static jit_word_t
_bmxr_p(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)2320 _bmxr_p(jit_state_t *_jit, jit_int32_t cc,
2321 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2322 {
2323 jit_word_t w;
2324 jit_int32_t reg;
2325 reg = jit_get_reg(jit_class_gpr);
2326 movr(rn(reg), r0);
2327 andr(rn(reg), rn(reg), r1);
2328 TEST_(rn(reg), rn(reg));
2329 jit_unget_reg(reg);
2330 w = _jit->pc.w;
2331 BRCL(cc, 0);
2332 return (w);
2333 }
2334
2335 static void
_bmxi(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2336 _bmxi(jit_state_t *_jit, jit_int32_t cc,
2337 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2338 {
2339 jit_word_t d;
2340 jit_int32_t reg;
2341 reg = jit_get_reg(jit_class_gpr);
2342 movi(rn(reg), i1);
2343 andr(rn(reg), rn(reg), r0);
2344 TEST_(rn(reg), rn(reg));
2345 jit_unget_reg(reg);
2346 d = (i0 - _jit->pc.w) >> 1;
2347 if (s16_p(d))
2348 BRC(cc, x16(d));
2349 else {
2350 assert(s32_p(d));
2351 BRCL(cc, d);
2352 }
2353 }
2354
2355 static jit_word_t
_bmxi_p(jit_state_t * _jit,jit_int32_t cc,jit_word_t i0,jit_int32_t r0,jit_word_t i1)2356 _bmxi_p(jit_state_t *_jit, jit_int32_t cc,
2357 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2358 {
2359 jit_word_t w;
2360 jit_int32_t reg;
2361 reg = jit_get_reg(jit_class_gpr);
2362 movi(rn(reg), i1);
2363 andr(rn(reg), rn(reg), r0);
2364 TEST_(rn(reg), rn(reg));
2365 jit_unget_reg(reg);
2366 w = _jit->pc.w;
2367 BRCL(cc, 0);
2368 return (w);
2369 }
2370
2371 static void
_movr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)2372 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2373 {
2374 #if __WORDSIZE == 32
2375 if (r0 != r1)
2376 LR(r0, r1);
2377 #else
2378 if (r0 != r1)
2379 LGR(r0, r1);
2380 #endif
2381 }
2382
2383 static void
_movi(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2384 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2385 {
2386 jit_word_t d;
2387 #if __WORDSIZE == 64
2388 jit_int32_t bits;
2389 #endif
2390 d = (i0 - _jit->pc.w) >> 1;
2391 if (s16_p(i0)) {
2392 #if __WORDSIZE == 32
2393 LHI(r0, x16(i0));
2394 #else
2395 LGHI(r0, x16(i0));
2396 #endif
2397 }
2398 /* easy way of loading a large amount of 32 bit values and
2399 * usually address of constants */
2400 else if (!(i0 & 1) &&
2401 #if __WORDSIZE == 32
2402 i0 > 0
2403 #else
2404 s32_p(d)
2405 #endif
2406 )
2407 LARL(r0, d);
2408 else {
2409 #if __WORDSIZE == 32
2410 LHI(r0, x16(i0));
2411 IILH(r0, x16((jit_uword_t)i0 >> 16));
2412 #else
2413 bits = 0;
2414 if (i0 & 0xffffL) bits |= 1;
2415 if (i0 & 0xffff0000L) bits |= 2;
2416 if (i0 & 0xffff00000000L) bits |= 4;
2417 if (i0 & 0xffff000000000000L) bits |= 8;
2418 if (bits != 15) LGHI(r0, 0);
2419 if (bits & 1) IILL(r0, x16(i0));
2420 if (bits & 2) IILH(r0, x16((jit_uword_t)i0 >> 16));
2421 if (bits & 4) IIHL(r0, x16((jit_uword_t)i0 >> 32));
2422 if (bits & 8) IIHH(r0, x16((jit_uword_t)i0 >> 48));
2423 #endif
2424 }
2425 }
2426
2427 static jit_word_t
_movi_p(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2428 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2429 {
2430 jit_word_t w;
2431 w = _jit->pc.w;
2432 #if __WORDSIZE == 32
2433 LHI(r0, x16(i0));
2434 #else
2435 IILL(r0, x16(i0));
2436 #endif
2437 IILH(r0, x16((jit_uword_t)i0 >> 16));
2438 #if __WORDSIZE == 64
2439 IIHL(r0, x16((jit_uword_t)i0 >> 32));
2440 IIHH(r0, x16((jit_uword_t)i0 >> 48));
2441 #endif
2442 return (w);
2443 }
2444
2445 static void
_addr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2446 _addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2447 {
2448 if (r0 == r2)
2449 ADD_(r0, r1);
2450 else {
2451 movr(r0, r1);
2452 ADD_(r0, r2);
2453 }
2454 }
2455
2456 static void
_addi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2457 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2458 {
2459 jit_int32_t reg;
2460 if (r0 == r1 && s16_p(i0))
2461 ADDI_(r0, x16(i0));
2462 #if __WORDSIZE == 64
2463 else if (s20_p(i0))
2464 LAY(r0, x20(i0), 0, r1);
2465 #endif
2466 else {
2467 reg = jit_get_reg(jit_class_gpr);
2468 movi(rn(reg), i0);
2469 addr(r0, r1, rn(reg));
2470 jit_unget_reg(reg);
2471 }
2472 }
2473
2474 static void
_addcr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2475 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2476 {
2477 if (r0 == r2)
2478 ADDC_(r0, r1);
2479 else {
2480 movr(r0, r1);
2481 ADDC_(r0, r2);
2482 }
2483 }
2484
2485 static void
_addci(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2486 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2487 {
2488 jit_int32_t reg;
2489 reg = jit_get_reg(jit_class_gpr);
2490 movi(rn(reg), i0);
2491 addcr(r0, r1, rn(reg));
2492 jit_unget_reg(reg);
2493 }
2494
2495 static void
_addxr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2496 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2497 {
2498 if (r0 == r2)
2499 ADDX_(r0, r1);
2500 else {
2501 movr(r0, r1);
2502 ADDX_(r0, r2);
2503 }
2504 }
2505
2506 static void
_addxi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2507 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2508 {
2509 jit_int32_t reg;
2510 reg = jit_get_reg(jit_class_gpr);
2511 movi(rn(reg), i0);
2512 addxr(r0, r1, rn(reg));
2513 jit_unget_reg(reg);
2514 }
2515
2516 static void
_subr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2517 _subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2518 {
2519 jit_int32_t reg;
2520 if (r0 == r2) {
2521 reg = jit_get_reg(jit_class_gpr);
2522 movr(rn(reg), r2);
2523 movr(r0, r1);
2524 SUB_(r0, rn(reg));
2525 jit_unget_reg(reg);
2526 }
2527 else {
2528 movr(r0, r1);
2529 SUB_(r0, r2);
2530 }
2531 }
2532
2533 static void
_subi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2534 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2535 {
2536 jit_int32_t reg;
2537 if (r0 == r1 && s16_p(-i0))
2538 ADDI_(r0, x16(-i0));
2539 #if __WORDSIZE == 64
2540 else if (s20_p(-i0))
2541 LAY(r0, x20(-i0), 0, r1);
2542 #endif
2543 else {
2544 reg = jit_get_reg(jit_class_gpr);
2545 movi(rn(reg), i0);
2546 subr(r0, r1, rn(reg));
2547 jit_unget_reg(reg);
2548 }
2549 }
2550
2551 static void
_subcr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2552 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2553 {
2554 jit_int32_t reg;
2555 if (r0 == r2) {
2556 reg = jit_get_reg(jit_class_gpr);
2557 movr(rn(reg), r2);
2558 movr(r0, r1);
2559 SUBC_(r0, rn(reg));
2560 jit_unget_reg(reg);
2561 }
2562 else {
2563 movr(r0, r1);
2564 SUBC_(r0, r2);
2565 }
2566 }
2567
2568 static void
_subci(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2569 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2570 {
2571 jit_int32_t reg;
2572 reg = jit_get_reg(jit_class_gpr);
2573 movi(rn(reg), i0);
2574 subcr(r0, r1, rn(reg));
2575 jit_unget_reg(reg);
2576 }
2577
2578 static void
_subxr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2579 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2580 {
2581 jit_int32_t reg;
2582 if (r0 == r2) {
2583 reg = jit_get_reg(jit_class_gpr);
2584 movr(rn(reg), r2);
2585 movr(r0, r1);
2586 SUBX_(r0, rn(reg));
2587 jit_unget_reg(reg);
2588 }
2589 else {
2590 movr(r0, r1);
2591 SUBX_(r0, r2);
2592 }
2593 }
2594
2595 static void
_subxi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2596 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2597 {
2598 jit_int32_t reg;
2599 reg = jit_get_reg(jit_class_gpr);
2600 movi(rn(reg), i0);
2601 subxr(r0, r1, rn(reg));
2602 jit_unget_reg(reg);
2603 }
2604
2605 static void
_rsbi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2606 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2607 {
2608 subi(r0, r1, i0);
2609 negr(r0, r0);
2610 }
2611
2612 static void
_mulr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2613 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2614 {
2615 if (r0 == r2)
2616 MUL_(r0, r1);
2617 else {
2618 movr(r0, r1);
2619 MUL_(r0, r2);
2620 }
2621 }
2622
2623 static void
_muli(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2624 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2625 {
2626 jit_int32_t reg;
2627 if (s16_p(i0)) {
2628 movr(r0, r1);
2629 MULI_(r0, x16(i0));
2630 }
2631 else {
2632 reg = jit_get_reg(jit_class_gpr);
2633 movi(rn(reg), i0);
2634 mulr(r0, r1, rn(reg));
2635 jit_unget_reg(reg);
2636 }
2637 }
2638
2639 static void
_qmulr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_int32_t r3)2640 _qmulr(jit_state_t *_jit,
2641 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2642 {
2643 jit_int32_t reg;
2644 /* The only invalid condition is r0 == r1 */
2645 jit_int32_t t2, t3, s2, s3;
2646 if (r2 == r0 || r2 == r1) {
2647 s2 = jit_get_reg(jit_class_gpr);
2648 t2 = rn(s2);
2649 movr(t2, r2);
2650 }
2651 else
2652 t2 = r2;
2653 if (r3 == r0 || r3 == r1) {
2654 s3 = jit_get_reg(jit_class_gpr);
2655 t3 = rn(s3);
2656 movr(t3, r3);
2657 }
2658 else
2659 t3 = r3;
2660 qmulr_u(r0, r1, r2, r3);
2661 reg = jit_get_reg(jit_class_gpr);
2662 /**/
2663 rshi(rn(reg), t2, 63);
2664 mulr(rn(reg), rn(reg), t3);
2665 addr(r1, r1, rn(reg));
2666 /**/
2667 rshi(rn(reg), t3, 63);
2668 mulr(rn(reg), rn(reg), t2);
2669 addr(r1, r1, rn(reg));
2670 jit_unget_reg(reg);
2671 if (t2 != r2)
2672 jit_unget_reg(s2);
2673 if (t3 != r3)
2674 jit_unget_reg(s3);
2675 }
2676
2677 static void
_qmuli(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_word_t i0)2678 _qmuli(jit_state_t *_jit,
2679 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2680 {
2681 jit_int32_t reg;
2682 reg = jit_get_reg(jit_class_gpr);
2683 movi(rn(reg), i0);
2684 qmulr(r0, r1, r2, rn(reg));
2685 jit_unget_reg(reg);
2686 }
2687
2688 static void
_qmulr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_int32_t r3)2689 _qmulr_u(jit_state_t *_jit,
2690 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2691 {
2692 jit_int32_t regno;
2693 regno = jit_get_reg_pair();
2694 movr(rn(regno) + 1, r2);
2695 MULU_(rn(regno), r3);
2696 movr(r0, rn(regno) + 1);
2697 movr(r1, rn(regno));
2698 jit_unget_reg_pair(regno);
2699 }
2700
2701 static void
_qmuli_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_word_t i0)2702 _qmuli_u(jit_state_t *_jit,
2703 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2704 {
2705 jit_int32_t regno;
2706 regno = jit_get_reg_pair();
2707 movr(rn(regno) + 1, r2);
2708 movi(rn(regno), i0);
2709 MULU_(rn(regno), rn(regno));
2710 movr(r0, rn(regno) + 1);
2711 movr(r1, rn(regno));
2712 jit_unget_reg_pair(regno);
2713 }
2714
2715 static void
_divr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2716 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2717 {
2718 jit_int32_t regno;
2719 regno = xdivr(r1, r2);
2720 movr(r0, rn(regno) + 1);
2721 }
2722
2723 static void
_divi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2724 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2725 {
2726 jit_int32_t regno;
2727 regno = xdivi(r1, i0);
2728 movr(r0, rn(regno) + 1);
2729 }
2730
2731 static void
_divr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2732 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2733 {
2734 jit_int32_t regno;
2735 regno = xdivr_u(r1, r2);
2736 movr(r0, rn(regno) + 1);
2737 }
2738
2739 static void
_divi_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2740 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2741 {
2742 jit_int32_t regno;
2743 regno = xdivi_u(r1, i0);
2744 movr(r0, rn(regno) + 1);
2745 }
2746
2747 static void
_remr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2748 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2749 {
2750 jit_int32_t regno;
2751 regno = xdivr(r1, r2);
2752 movr(r0, rn(regno));
2753 }
2754
2755 static void
_remi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2756 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2757 {
2758 jit_int32_t regno;
2759 regno = xdivi(r1, i0);
2760 movr(r0, rn(regno));
2761 }
2762
2763 static void
_remr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2764 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2765 {
2766 jit_int32_t regno;
2767 regno = xdivr_u(r1, r2);
2768 movr(r0, rn(regno));
2769 }
2770
2771 static void
_remi_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2772 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2773 {
2774 jit_int32_t regno;
2775 regno = xdivi_u(r1, i0);
2776 movr(r0, rn(regno));
2777 }
2778
2779 static void
_qdivr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_int32_t r3)2780 _qdivr(jit_state_t *_jit,
2781 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2782 {
2783 jit_int32_t regno;
2784 regno = xdivr(r2, r3);
2785 movr(r0, rn(regno) + 1);
2786 movr(r1, rn(regno));
2787 }
2788
2789 static void
_qdivi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_word_t i0)2790 _qdivi(jit_state_t *_jit,
2791 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2792 {
2793 jit_int32_t regno;
2794 regno = xdivi(r2, i0);
2795 movr(r0, rn(regno) + 1);
2796 movr(r1, rn(regno));
2797 }
2798
2799 static void
_qdivr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_int32_t r3)2800 _qdivr_u(jit_state_t *_jit,
2801 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2802 {
2803 jit_int32_t regno;
2804 regno = xdivr_u(r2, r3);
2805 movr(r0, rn(regno) + 1);
2806 movr(r1, rn(regno));
2807 }
2808
2809 static void
_qdivi_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2,jit_word_t i0)2810 _qdivi_u(jit_state_t *_jit,
2811 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2812 {
2813 jit_int32_t regno;
2814 regno = xdivi_u(r2, i0);
2815 movr(r0, rn(regno) + 1);
2816 movr(r1, rn(regno));
2817 }
2818
2819 # if __WORDSIZE == 32
2820 static void
_lshr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2821 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2822 {
2823 jit_int32_t reg;
2824 if (r0 == r2) {
2825 reg = jit_get_reg_but_zero(0);
2826 movr(rn(reg), r2);
2827 movr(r0, r1);
2828 SLL(r0, 0, rn(reg));
2829 jit_unget_reg_but_zero(reg);
2830 }
2831 else {
2832 movr(r0, r1);
2833 SLL(r0, 0, r2);
2834 }
2835 }
2836 #endif
2837
2838 static void
_lshi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2839 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2840 {
2841 jit_int32_t reg;
2842 reg = jit_get_reg_but_zero(0);
2843 movi(rn(reg), i0);
2844 lshr(r0, r1, rn(reg));
2845 jit_unget_reg_but_zero(reg);
2846 }
2847
2848 # if __WORDSIZE == 32
2849 static void
_rshr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2850 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2851 {
2852 jit_int32_t reg;
2853 if (r0 == r2) {
2854 reg = jit_get_reg_but_zero(0);
2855 movr(rn(reg), r2);
2856 movr(r0, r1);
2857 SRA(r0, 0, rn(reg));
2858 jit_unget_reg_but_zero(reg);
2859 }
2860 else {
2861 movr(r0, r1);
2862 SRA(r0, 0, r2);
2863 }
2864 }
2865 #endif
2866
2867 static void
_rshi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2868 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2869 {
2870 jit_int32_t reg;
2871 reg = jit_get_reg_but_zero(0);
2872 movi(rn(reg), i0);
2873 rshr(r0, r1, rn(reg));
2874 jit_unget_reg_but_zero(reg);
2875 }
2876
2877 # if __WORDSIZE == 32
2878 static void
_rshr_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2879 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2880 {
2881 jit_int32_t reg;
2882 if (r0 == r2) {
2883 reg = jit_get_reg_but_zero(0);
2884 movr(rn(reg), r2);
2885 movr(r0, r1);
2886 SRL(r0, 0, rn(reg));
2887 jit_unget_reg_but_zero(reg);
2888 }
2889 else {
2890 movr(r0, r1);
2891 SRL(r0, 0, r2);
2892 }
2893 }
2894 #endif
2895
2896 static void
_rshi_u(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2897 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2898 {
2899 jit_int32_t reg;
2900 reg = jit_get_reg_but_zero(0);
2901 movi(rn(reg), i0);
2902 rshr_u(r0, r1, rn(reg));
2903 jit_unget_reg_but_zero(reg);
2904 }
2905
2906 static void
_comr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)2907 _comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2908 {
2909 jit_int32_t reg;
2910 reg = jit_get_reg(jit_class_gpr);
2911 movi(rn(reg), -1);
2912 movr(r0, r1);
2913 XOR_(r0, rn(reg));
2914 jit_unget_reg(reg);
2915 }
2916
2917 static void
_andr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2918 _andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2919 {
2920 if (r0 == r2)
2921 AND_(r0, r1);
2922 else {
2923 movr(r0, r1);
2924 AND_(r0, r2);
2925 }
2926 }
2927
2928 static void
_andi(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2929 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2930 {
2931 movr(r0, r1);
2932 NILL(r0, x16(i0));
2933 NILH(r0, x16((jit_uword_t)i0 >> 16));
2934 #if __WORDSIZE == 64
2935 NIHL(r0, x16((jit_uword_t)i0 >> 32));
2936 NIHH(r0, x16((jit_uword_t)i0 >> 48));
2937 #endif
2938 }
2939
2940 static void
_orr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2941 _orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2942 {
2943 if (r0 == r2)
2944 OR_(r0, r1);
2945 else {
2946 movr(r0, r1);
2947 OR_(r0, r2);
2948 }
2949 }
2950
2951 static void
_ori(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2952 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2953 {
2954 movr(r0, r1);
2955 OILL(r0, x16(i0));
2956 OILH(r0, x16((jit_uword_t)i0 >> 16));
2957 #if __WORDSIZE == 64
2958 OIHL(r0, x16((jit_uword_t)i0 >> 32));
2959 OIHH(r0, x16((jit_uword_t)i0 >> 48));
2960 #endif
2961 }
2962
2963 static void
_xorr(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2964 _xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2965 {
2966 if (r0 == r2)
2967 XOR_(r0, r1);
2968 else {
2969 movr(r0, r1);
2970 XOR_(r0, r2);
2971 }
2972 }
2973
2974 static void
_xori(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)2975 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2976 {
2977 jit_int32_t reg;
2978 reg = jit_get_reg(jit_class_gpr);
2979 movi(rn(reg), i0);
2980 xorr(r0, r1, rn(reg));
2981 jit_unget_reg(reg);
2982 }
2983
2984 static void
_ldi_c(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)2985 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2986 {
2987 movi(r0, i0);
2988 ldr_c(r0, r0);
2989 }
2990
2991 static void
_ldxr_c(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)2992 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2993 {
2994 if (r0 == r2) {
2995 addr(r0, r0, r1);
2996 ldr_c(r0, r0);
2997 }
2998 else {
2999 movr(r0, r1);
3000 addr(r0, r0, r2);
3001 ldr_c(r0, r0);
3002 }
3003 }
3004
3005 static void
_ldxi_c(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)3006 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3007 {
3008 jit_int32_t reg;
3009 if (s20_p(i0)) {
3010 #if __WORDSIZE == 32
3011 LB(r0, x20(i0), 0, r1);
3012 #else
3013 LGB(r0, x20(i0), 0, r1);
3014 #endif
3015 }
3016 else if (r0 != r1) {
3017 movi(r0, i0);
3018 addr(r0, r0, r1);
3019 ldr_c(r0, r0);
3020 }
3021 else {
3022 reg = jit_get_reg_but_zero(0);
3023 movi(rn(reg), i0);
3024 addr(rn(reg), rn(reg), r1);
3025 ldr_c(r0, rn(reg));
3026 jit_unget_reg_but_zero(reg);
3027 }
3028 }
3029
3030 static void
_ldi_uc(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)3031 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3032 {
3033 movi(r0, i0);
3034 ldr_uc(r0, r0);
3035 }
3036
3037 static void
_ldxr_uc(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3038 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3039 {
3040 if (r0 == r2) {
3041 addr(r0, r0, r1);
3042 ldr_uc(r0, r0);
3043 }
3044 else {
3045 movr(r0, r1);
3046 addr(r0, r0, r2);
3047 ldr_uc(r0, r0);
3048 }
3049 }
3050
3051 static void
_ldxi_uc(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)3052 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3053 {
3054 jit_int32_t reg;
3055 if (s20_p(i0))
3056 LLGC(r0, x20(i0), 0, r1);
3057 else if (r0 != r1) {
3058 movi(r0, i0);
3059 addr(r0, r0, r1);
3060 ldr_uc(r0, r0);
3061 }
3062 else {
3063 reg = jit_get_reg_but_zero(0);
3064 movi(rn(reg), i0);
3065 addr(rn(reg), rn(reg), r1);
3066 ldr_uc(r0, rn(reg));
3067 jit_unget_reg_but_zero(reg);
3068 }
3069 }
3070
3071 static void
_ldi_s(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)3072 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3073 {
3074 movi(r0, i0);
3075 ldr_s(r0, r0);
3076 }
3077
3078 static void
_ldxr_s(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3079 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3080 {
3081 if (r0 == r2) {
3082 addr(r0, r0, r1);
3083 ldr_s(r0, r0);
3084 }
3085 else {
3086 movr(r0, r1);
3087 addr(r0, r0, r2);
3088 ldr_s(r0, r0);
3089 }
3090 }
3091
3092 static void
_ldxi_s(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)3093 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3094 {
3095 jit_int32_t reg;
3096 #if __WORDSIZE == 32
3097 if (u12_p(i0))
3098 LH(r0, i0, 0, r1);
3099 else
3100 #endif
3101 if (s20_p(i0)) {
3102 #if __WORDSIZE == 32
3103 LHY(r0, x20(i0), 0, r1);
3104 #else
3105 LGH(r0, x20(i0), 0, r1);
3106 #endif
3107 }
3108 else if (r0 != r1) {
3109 movi(r0, i0);
3110 addr(r0, r0, r1);
3111 ldr_s(r0, r0);
3112 }
3113 else {
3114 reg = jit_get_reg_but_zero(0);
3115 movi(rn(reg), i0);
3116 addr(rn(reg), rn(reg), r1);
3117 ldr_s(r0, rn(reg));
3118 jit_unget_reg_but_zero(reg);
3119 }
3120 }
3121
3122 static void
_ldi_us(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)3123 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3124 {
3125 movi(r0, i0);
3126 ldr_us(r0, r0);
3127 }
3128
3129 static void
_ldxr_us(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3130 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3131 {
3132 if (r0 == r2) {
3133 addr(r0, r0, r1);
3134 ldr_us(r0, r0);
3135 }
3136 else {
3137 movr(r0, r1);
3138 addr(r0, r0, r2);
3139 ldr_us(r0, r0);
3140 }
3141 }
3142
3143 static void
_ldxi_us(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)3144 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3145 {
3146 jit_int32_t reg;
3147 if (s20_p(i0))
3148 LLGH(r0, x20(i0), 0, r1);
3149 else if (r0 != r1) {
3150 movi(r0, i0);
3151 addr(r0, r0, r1);
3152 ldr_us(r0, r0);
3153 }
3154 else {
3155 reg = jit_get_reg_but_zero(0);
3156 movi(rn(reg), i0);
3157 addr(rn(reg), rn(reg), r1);
3158 ldr_us(r0, rn(reg));
3159 jit_unget_reg_but_zero(reg);
3160 }
3161 }
3162
3163 static void
_ldi_i(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)3164 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3165 {
3166 movi(r0, i0);
3167 ldr_i(r0, r0);
3168 }
3169
3170 static void
_ldxr_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3171 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3172 {
3173 if (r0 == r2) {
3174 addr(r0, r0, r1);
3175 ldr_i(r0, r0);
3176 }
3177 else {
3178 movr(r0, r1);
3179 addr(r0, r0, r2);
3180 ldr_i(r0, r0);
3181 }
3182 }
3183
3184 static void
_ldxi_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)3185 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3186 {
3187 jit_int32_t reg;
3188 if (s20_p(i0))
3189 LGF(r0, x20(i0), 0, r1);
3190 else if (r0 != r1) {
3191 movi(r0, i0);
3192 addr(r0, r0, r1);
3193 ldr_i(r0, r0);
3194 }
3195 else {
3196 reg = jit_get_reg_but_zero(0);
3197 movi(rn(reg), i0);
3198 addr(rn(reg), rn(reg), r1);
3199 ldr_i(r0, rn(reg));
3200 jit_unget_reg_but_zero(reg);
3201 }
3202 }
3203
3204 #if __WORDSIZE == 64
3205 static void
_ldi_ui(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)3206 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3207 {
3208 movi(r0, i0);
3209 ldr_ui(r0, r0);
3210 }
3211
3212 static void
_ldxr_ui(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3213 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3214 {
3215 if (r0 == r2) {
3216 addr(r0, r0, r1);
3217 ldr_ui(r0, r0);
3218 }
3219 else {
3220 movr(r0, r1);
3221 addr(r0, r0, r2);
3222 ldr_ui(r0, r0);
3223 }
3224 }
3225
3226 static void
_ldxi_ui(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)3227 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3228 {
3229 jit_int32_t reg;
3230 if (s20_p(i0))
3231 LLGF(r0, x20(i0), 0, r1);
3232 else if (r0 != r1) {
3233 movi(r0, i0);
3234 addr(r0, r0, r1);
3235 ldr_ui(r0, r0);
3236 }
3237 else {
3238 reg = jit_get_reg_but_zero(0);
3239 movi(rn(reg), i0);
3240 addr(rn(reg), rn(reg), r1);
3241 ldr_ui(r0, rn(reg));
3242 jit_unget_reg_but_zero(reg);
3243 }
3244 }
3245
3246 static void
_ldi_l(jit_state_t * _jit,jit_int32_t r0,jit_word_t i0)3247 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3248 {
3249 movi(r0, i0);
3250 ldr_l(r0, r0);
3251 }
3252
3253 static void
_ldxr_l(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3254 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3255 {
3256 if (r0 == r2) {
3257 addr(r0, r0, r1);
3258 ldr_l(r0, r0);
3259 }
3260 else {
3261 movr(r0, r1);
3262 addr(r0, r0, r2);
3263 ldr_l(r0, r0);
3264 }
3265 }
3266
3267 static void
_ldxi_l(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_word_t i0)3268 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3269 {
3270 jit_int32_t reg;
3271 if (s20_p(i0))
3272 LG(r0, x20(i0), 0, r1);
3273 else if (r0 != r1) {
3274 movi(r0, i0);
3275 addr(r0, r0, r1);
3276 ldr_l(r0, r0);
3277 }
3278 else {
3279 reg = jit_get_reg_but_zero(0);
3280 movi(rn(reg), i0);
3281 addr(rn(reg), rn(reg), r1);
3282 ldr_l(r0, rn(reg));
3283 jit_unget_reg_but_zero(reg);
3284 }
3285 }
3286 #endif
3287
3288 static void
_sti_c(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)3289 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3290 {
3291 jit_int32_t reg;
3292 reg = jit_get_reg_but_zero(0);
3293 movi(rn(reg), i0);
3294 str_c(rn(reg), r0);
3295 jit_unget_reg_but_zero(reg);
3296 }
3297
3298 static void
_stxr_c(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3299 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3300 {
3301 jit_int32_t reg;
3302 reg = jit_get_reg_but_zero(0);
3303 movr(rn(reg), r0);
3304 addr(rn(reg), rn(reg), r1);
3305 str_c(rn(reg), r2);
3306 jit_unget_reg_but_zero(reg);
3307 }
3308
3309 static void
_stxi_c(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)3310 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3311 {
3312 jit_int32_t reg;
3313 if (u12_p(i0))
3314 STC(r1, i0, 0, r0);
3315 else if (s20_p(i0))
3316 STCY(r1, x20(i0), 0, r0);
3317 else {
3318 reg = jit_get_reg_but_zero(0);
3319 addi(rn(reg), r0, i0);
3320 str_c(rn(reg), r1);
3321 jit_unget_reg_but_zero(reg);
3322 }
3323 }
3324
3325 static void
_sti_s(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)3326 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3327 {
3328 jit_int32_t reg;
3329 reg = jit_get_reg_but_zero(0);
3330 movi(rn(reg), i0);
3331 str_s(rn(reg), r0);
3332 jit_unget_reg_but_zero(reg);
3333 }
3334
3335 static void
_stxr_s(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3336 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3337 {
3338 jit_int32_t reg;
3339 reg = jit_get_reg_but_zero(0);
3340 movr(rn(reg), r0);
3341 addr(rn(reg), rn(reg), r1);
3342 str_s(rn(reg), r2);
3343 jit_unget_reg_but_zero(reg);
3344 }
3345
3346 static void
_stxi_s(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)3347 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3348 {
3349 jit_int32_t reg;
3350 if (u12_p(i0))
3351 STH(r1, i0, 0, r0);
3352 else if (s20_p(i0))
3353 STHY(r1, x20(i0), 0, r0);
3354 else {
3355 reg = jit_get_reg_but_zero(0);
3356 addi(rn(reg), r0, i0);
3357 str_s(rn(reg), r1);
3358 jit_unget_reg_but_zero(reg);
3359 }
3360 }
3361
3362 static void
_sti_i(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)3363 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3364 {
3365 jit_int32_t reg;
3366 reg = jit_get_reg_but_zero(0);
3367 movi(rn(reg), i0);
3368 str_i(rn(reg), r0);
3369 jit_unget_reg_but_zero(reg);
3370 }
3371
3372 static void
_stxr_i(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3373 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3374 {
3375 jit_int32_t reg;
3376 reg = jit_get_reg_but_zero(0);
3377 movr(rn(reg), r0);
3378 addr(rn(reg), rn(reg), r1);
3379 str_i(rn(reg), r2);
3380 jit_unget_reg_but_zero(reg);
3381 }
3382
3383 static void
_stxi_i(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)3384 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3385 {
3386 jit_int32_t reg;
3387 if (u12_p(i0))
3388 ST(r1, i0, 0, r0);
3389 else if (s20_p(i0))
3390 STY(r1, x20(i0), 0, r0);
3391 else {
3392 reg = jit_get_reg_but_zero(0);
3393 addi(rn(reg), r0, i0);
3394 str_i(rn(reg), r1);
3395 jit_unget_reg_but_zero(reg);
3396 }
3397 }
3398
3399 #if __WORDSIZE == 64
3400 static void
_sti_l(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0)3401 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3402 {
3403 jit_int32_t reg;
3404 reg = jit_get_reg_but_zero(0);
3405 movi(rn(reg), i0);
3406 str_l(rn(reg), r0);
3407 jit_unget_reg_but_zero(reg);
3408 }
3409
3410 static void
_stxr_l(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1,jit_int32_t r2)3411 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3412 {
3413 jit_int32_t reg;
3414 reg = jit_get_reg_but_zero(0);
3415 movr(rn(reg), r0);
3416 addr(rn(reg), rn(reg), r1);
3417 str_l(rn(reg), r2);
3418 jit_unget_reg_but_zero(reg);
3419 }
3420
3421 static void
_stxi_l(jit_state_t * _jit,jit_word_t i0,jit_int32_t r0,jit_int32_t r1)3422 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3423 {
3424 jit_int32_t reg;
3425 if (s20_p(i0))
3426 STG(r1, x20(i0), 0, r0);
3427 else {
3428 reg = jit_get_reg_but_zero(0);
3429 addi(rn(reg), r0, i0);
3430 str_l(rn(reg), r1);
3431 jit_unget_reg_but_zero(reg);
3432 }
3433 }
3434 #endif
3435
3436 static void
_jmpi(jit_state_t * _jit,jit_word_t i0)3437 _jmpi(jit_state_t *_jit, jit_word_t i0)
3438 {
3439 jit_word_t d;
3440 jit_int32_t reg;
3441 d = (i0 - _jit->pc.w) >> 1;
3442 if (s16_p(d))
3443 J(x16(d));
3444 else if (s32_p(d))
3445 BRL(d);
3446 else {
3447 reg = jit_get_reg_but_zero(jit_class_nospill);
3448 movi(rn(reg), i0);
3449 jmpr(rn(reg));
3450 jit_unget_reg_but_zero(reg);
3451 }
3452 }
3453
3454 static jit_word_t
_jmpi_p(jit_state_t * _jit,jit_word_t i0)3455 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3456 {
3457 jit_word_t w;
3458 jit_int32_t reg;
3459 reg = jit_get_reg_but_zero(jit_class_nospill);
3460 w = movi_p(rn(reg), i0);
3461 jmpr(rn(reg));
3462 jit_unget_reg_but_zero(reg);
3463 return (w);
3464 }
3465
3466 static void
_calli(jit_state_t * _jit,jit_word_t i0)3467 _calli(jit_state_t *_jit, jit_word_t i0)
3468 {
3469 jit_word_t d;
3470 jit_int32_t reg;
3471 d = (i0 - _jit->pc.w) >> 1;
3472 if (s32_p(d))
3473 BRASL(_R14_REGNO, d);
3474 else {
3475 reg = jit_get_reg_but_zero(0);
3476 movi(rn(reg), i0);
3477 callr(rn(reg));
3478 jit_unget_reg_but_zero(reg);
3479 }
3480 }
3481
3482 static jit_word_t
_calli_p(jit_state_t * _jit,jit_word_t i0)3483 _calli_p(jit_state_t *_jit, jit_word_t i0)
3484 {
3485 jit_word_t w;
3486 jit_int32_t reg;
3487 reg = jit_get_reg_but_zero(0);
3488 w = movi_p(rn(reg), i0);
3489 callr(rn(reg));
3490 jit_unget_reg_but_zero(reg);
3491 return (w);
3492 }
3493
3494 static jit_int32_t gprs[] = {
3495 _R2, _R3, _R4, _R5,
3496 _R6, _R7, _R8, _R9, _R10, _R11, _R12, _R13
3497 };
3498
3499 static void
_prolog(jit_state_t * _jit,jit_node_t * i0)3500 _prolog(jit_state_t *_jit, jit_node_t *i0)
3501 {
3502 jit_int32_t regno, offset;
3503 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3504 jit_int32_t frame = -_jitc->function->frame;
3505 assert(_jitc->function->self.aoff >= frame);
3506 if (_jitc->function->assume_frame)
3507 return;
3508 _jitc->function->self.aoff = frame;
3509 }
3510 if (_jitc->function->allocar)
3511 _jitc->function->self.aoff &= -8;
3512 _jitc->function->stack = ((_jitc->function->self.alen -
3513 /* align stack at 8 bytes */
3514 _jitc->function->self.aoff) + 7) & -8;
3515 /* *IFF* a non variadic function,
3516 * Lightning does not reserve stack space for spilling arguments
3517 * in registers.
3518 * S390x, as per gcc, has 8 stack slots for spilling arguments,
3519 * (%r6 is callee save) and uses an alloca like approach to save
3520 * callee save fpr registers.
3521 * Since argument registers are not saved in any lightning port,
3522 * use the 8 slots to spill any modified fpr register, and still
3523 * use the same stack frame logic as gcc.
3524 * Save at least %r13 to %r15, as %r13 is used as frame pointer.
3525 * *IFF* a variadic function, a "standard" stack frame, with
3526 * fpr registers saved in an alloca'ed area, is used.
3527 */
3528 if ((_jitc->function->self.call & jit_call_varargs) &&
3529 jit_arg_reg_p(_jitc->function->vagp))
3530 regno = _jitc->function->vagp;
3531 else {
3532 for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3533 if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3534 break;
3535 }
3536 }
3537 #if __WORDSIZE == 32
3538 # define FP_OFFSET 64
3539 if (_jitc->function->self.call & jit_call_varargs)
3540 offset = regno * 4 + 8;
3541 else
3542 offset = (regno - 4) * 4 + 32;
3543 STM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3544 #else
3545 # define FP_OFFSET 128
3546 if (_jitc->function->self.call & jit_call_varargs)
3547 offset = regno * 8 + 16;
3548 else
3549 offset = (regno - 4) * 8 + 48;
3550 STMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3551 #endif
3552
3553 #define SPILL(R, O) \
3554 do { \
3555 if (jit_regset_tstbit(&_jitc->function->regset, R)) \
3556 stxi_d(O, _R15_REGNO, rn(R)); \
3557 } while (0)
3558 if (_jitc->function->self.call & jit_call_varargs) {
3559 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3560 stxi_d(FP_OFFSET + regno * 8, _R15_REGNO, rn(_F0 - regno));
3561 SPILL(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3562 SPILL(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3563 SPILL(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3564 SPILL(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3565 SPILL(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3566 SPILL(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3567 SPILL(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3568 }
3569 else {
3570 /* First 4 in low address */
3571 #if __WORDSIZE == 32
3572 SPILL(_F10, 0);
3573 SPILL(_F11, 8);
3574 SPILL(_F12, 16);
3575 SPILL(_F13, 24);
3576 /* gpr registers here */
3577 SPILL(_F14, 72);
3578 SPILL(_F8, 80);
3579 SPILL(_F9, 88);
3580 #else
3581 SPILL(_F10, 16);
3582 SPILL(_F11, 24);
3583 SPILL(_F12, 32);
3584 SPILL(_F13, 48);
3585 /* Last 3 in high address */
3586 SPILL(_F14, 136);
3587 SPILL(_F8, 144);
3588 SPILL(_F9, 152);
3589 #endif
3590 }
3591 #undef SPILL
3592 movr(_R13_REGNO, _R15_REGNO);
3593 subi(_R15_REGNO, _R15_REGNO, stack_framesize + _jitc->function->stack);
3594 if (_jitc->function->allocar) {
3595 regno = jit_get_reg(jit_class_gpr);
3596 movi(rn(regno), _jitc->function->self.aoff);
3597 stxi_i(_jitc->function->aoffoff, _R13_REGNO, rn(regno));
3598 jit_unget_reg(regno);
3599 }
3600 }
3601
3602 static void
_epilog(jit_state_t * _jit,jit_node_t * i0)3603 _epilog(jit_state_t *_jit, jit_node_t *i0)
3604 {
3605 jit_int32_t regno, offset;
3606 if (_jitc->function->assume_frame)
3607 return;
3608 if ((_jitc->function->self.call & jit_call_varargs) &&
3609 jit_arg_reg_p(_jitc->function->vagp))
3610 regno = _jitc->function->vagp;
3611 else {
3612 for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3613 if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3614 break;
3615 }
3616 }
3617 #if __WORDSIZE == 32
3618 if (_jitc->function->self.call & jit_call_varargs)
3619 offset = regno * 4 + 8;
3620 else
3621 offset = (regno - 4) * 4 + 32;
3622 #else
3623 if (_jitc->function->self.call & jit_call_varargs)
3624 offset = regno * 8 + 16;
3625 else
3626 offset = (regno - 4) * 8 + 48;
3627 #endif
3628 movr(_R15_REGNO, _R13_REGNO);
3629
3630 #define LOAD(R, O) \
3631 do { \
3632 if (jit_regset_tstbit(&_jitc->function->regset, R)) \
3633 ldxi_d(rn(R), _R15_REGNO, O); \
3634 } while (0)
3635 if (_jitc->function->self.call & jit_call_varargs) {
3636 LOAD(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3637 LOAD(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3638 LOAD(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3639 LOAD(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3640 LOAD(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3641 LOAD(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3642 LOAD(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3643 }
3644 else {
3645 #if __WORDSIZE == 32
3646 LOAD(_F10, 0);
3647 LOAD(_F11, 8);
3648 LOAD(_F12, 16);
3649 LOAD(_F13, 24);
3650 LOAD(_F14, 72);
3651 LOAD(_F8, 80);
3652 LOAD(_F9, 88);
3653 #else
3654 LOAD(_F10, 16);
3655 LOAD(_F11, 24);
3656 LOAD(_F12, 32);
3657 LOAD(_F13, 48);
3658 LOAD(_F14, 136);
3659 LOAD(_F8, 144);
3660 LOAD(_F9, 152);
3661 #endif
3662 }
3663 #undef LOAD
3664 #if __WORDSIZE == 32
3665 LM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3666 #else
3667 LMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3668 #endif
3669 BR(_R14_REGNO);
3670 }
3671
3672 static void
_vastart(jit_state_t * _jit,jit_int32_t r0)3673 _vastart(jit_state_t *_jit, jit_int32_t r0)
3674 {
3675 jit_int32_t reg;
3676
3677 assert(_jitc->function->self.call & jit_call_varargs);
3678
3679 /* Return jit_va_list_t in the register argument */
3680 addi(r0, _R13_REGNO, _jitc->function->vaoff);
3681 reg = jit_get_reg(jit_class_gpr);
3682
3683 /* Initialize gp offset in the save area. */
3684 movi(rn(reg), _jitc->function->vagp);
3685 stxi(offsetof(jit_va_list_t, gpoff), r0, rn(reg));
3686
3687 /* Initialize fp offset in the save area. */
3688 movi(rn(reg), _jitc->function->vafp);
3689 stxi(offsetof(jit_va_list_t, fpoff), r0, rn(reg));
3690
3691 /* Initialize overflow pointer to the first stack argument. */
3692 addi(rn(reg), _R13_REGNO, _jitc->function->self.size);
3693 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3694
3695 /* Initialize register save area pointer. */
3696 stxi(offsetof(jit_va_list_t, save), r0, _R13_REGNO);
3697
3698 jit_unget_reg(reg);
3699 }
3700
3701 static void
_vaarg(jit_state_t * _jit,jit_int32_t r0,jit_int32_t r1)3702 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3703 {
3704 jit_int32_t rg0;
3705 jit_int32_t rg1;
3706 jit_int32_t rg2;
3707 jit_word_t ge_code;
3708 jit_word_t lt_code;
3709
3710 assert(_jitc->function->self.call & jit_call_varargs);
3711
3712 rg0 = jit_get_reg_but_zero(0);
3713 rg1 = jit_get_reg_but_zero(0);
3714
3715 /* Load the gp offset in save area in the first temporary. */
3716 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, gpoff));
3717
3718 /* Jump over if there are no remaining arguments in the save area. */
3719 ge_code = bgei_p(_jit->pc.w, rn(rg0), 5);
3720
3721 /* Load the save area pointer in the second temporary. */
3722 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
3723
3724 /* Scale offset */
3725 rg2 = jit_get_reg_but_zero(0);
3726 lshi(rn(rg2), rn(rg0),
3727 #if __WORDSIZE == 32
3728 2
3729 #else
3730 3
3731 #endif
3732 );
3733 /* Add offset to saved area. */
3734 addi(rn(rg2), rn(rg2), 2 * sizeof(jit_word_t));
3735
3736 /* Load the vararg argument in the first argument. */
3737 ldxr(r0, rn(rg1), rn(rg2));
3738 jit_unget_reg_but_zero(rg2);
3739
3740 /* Update the gp offset. */
3741 addi(rn(rg0), rn(rg0), 1);
3742 stxi(offsetof(jit_va_list_t, gpoff), r1, rn(rg0));
3743
3744 /* Will only need one temporary register below. */
3745 jit_unget_reg_but_zero(rg1);
3746
3747 /* Jump over overflow code. */
3748 lt_code = jmpi_p(_jit->pc.w);
3749
3750 /* Where to land if argument is in overflow area. */
3751 patch_at(ge_code, _jit->pc.w);
3752
3753 /* Load overflow pointer. */
3754 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
3755
3756 /* Load argument. */
3757 ldr(r0, rn(rg0));
3758
3759 /* Update overflow pointer. */
3760 addi(rn(rg0), rn(rg0), sizeof(jit_word_t));
3761 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
3762
3763 /* Where to land if argument is in save area. */
3764 patch_at(lt_code, _jit->pc.w);
3765
3766 jit_unget_reg_but_zero(rg0);
3767 }
3768
3769 static void
_patch_at(jit_state_t * _jit,jit_word_t instr,jit_word_t label)3770 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
3771 {
3772 jit_word_t d;
3773 union {
3774 jit_uint16_t *s;
3775 jit_word_t w;
3776 } u;
3777 u.w = instr;
3778 union {
3779 struct {
3780 jit_uint16_t op : 8;
3781 jit_uint16_t r1 : 4;
3782 jit_uint16_t r3 : 4;
3783 } b;
3784 jit_uint16_t s;
3785 } i0;
3786 union {
3787 struct {
3788 jit_uint16_t i2;
3789 } b;
3790 jit_uint16_t s;
3791 } i1;
3792 union {
3793 struct {
3794 jit_uint32_t ih : 16;
3795 jit_uint32_t il : 16;
3796 } b;
3797 jit_uint32_t i;
3798 } i12;
3799 i0.s = u.s[0];
3800 /* movi_p */
3801 if (i0.b.op ==
3802 #if __WORDSIZE == 32
3803 0xA7 && i0.b.r3 == 8
3804 #else
3805 0xA5
3806 #endif
3807 ) {
3808 #if __WORDSIZE == 64
3809 assert(i0.b.r3 == 3);
3810 #endif
3811 i1.b.i2 = (jit_uword_t)label;
3812 u.s[1] = i1.s;
3813 i0.s = u.s[2];
3814 assert(i0.b.op == 0xA5 && i0.b.r3 == 2);
3815 i1.b.i2 = (jit_uword_t)label >> 16;
3816 u.s[3] = i1.s;
3817 #if __WORDSIZE == 64
3818 i0.s = u.s[4];
3819 assert(i0.b.op == 0xA5 && i0.b.r3 == 1);
3820 i1.b.i2 = (jit_uword_t)label >> 32;
3821 u.s[5] = i1.s;
3822 i0.s = u.s[6];
3823 assert(i0.b.op == 0xA5 && i0.b.r3 == 0);
3824 i1.b.i2 = (jit_uword_t)label >> 48;
3825 u.s[7] = i1.s;
3826 #endif
3827 }
3828 /* BRC */
3829 else if (i0.b.op == 0xA7) {
3830 assert(i0.b.r3 == 0x4);
3831 d = (label - instr) >> 1;
3832 assert(s16_p(d));
3833 i1.b.i2 = d;
3834 u.s[1] = i1.s;
3835 }
3836 /* BRCL */
3837 else if (i0.b.op == 0xC0) {
3838 assert(i0.b.r3 == 0x4);
3839 d = (label - instr) >> 1;
3840 assert(s32_p(d));
3841 i12.i = d;
3842 u.s[1] = i12.b.ih;
3843 u.s[2] = i12.b.il;
3844 }
3845 else
3846 abort();
3847 }
3848 #endif
3849