2 * Copyright (C) 2013-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
17 * Paulo Cesar Pereira de Andrade
22 # define ldr(r0,r1) ldr_i(r0,r1)
23 # define ldi(r0,i0) ldi_i(r0,i0)
24 # define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2)
25 # define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0)
26 # define str(r0,r1) str_i(r0,r1)
27 # define sti(i0,r0) sti_i(i0,r0)
28 # define stxr(r0,r1,r2) stxr_i(r0,r1,r2)
29 # define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
31 # define ldr(r0,r1) ldr_l(r0,r1)
32 # define ldi(r0,i0) ldi_l(r0,i0)
33 # define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2)
34 # define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0)
35 # define str(r0,r1) str_l(r0,r1)
36 # define sti(i0,r0) sti_l(i0,r0)
37 # define stxr(r0,r1,r2) stxr_l(r0,r1,r2)
38 # define stxi(i0,r0,r1) stxi_l(i0,r0,r1)
40 # define is(i) *_jit->pc.us++ = i
42 # define stack_framesize 96
44 # define stack_framesize 160
49 # define _R13_REGNO 13
50 # define _FP_REGNO _R13_REGNO
51 # define _R14_REGNO 14
52 # define _R15_REGNO 15
53 # define u12_p(i0) ((i0) >= 0 && (i0) <= 4095)
54 # define s16_p(i0) ((i0) >= -32768 && (i0) <= 32767)
55 # define x16(i0) ((i0) & 0xffff)
56 # define s20_p(i0) ((i0) >= -524288 && (i0) <= 524287)
57 # define x20(i0) ((i0) & 0xfffff)
62 ((i0) >= -2147483648L && (i0) < 2147483647L)
66 Condition Code Instruction (Mask) Bit Mask Value
79 14 -> no overflow CC_NO
97 14 -> no overflow CC_NO
103 3 Not zero, no borrow
106 11 -> no borrow CC_NL
125 # define _us jit_uint16_t
126 # define _ui jit_uint32_t
127 # define E_(Op) _E(_jit,Op)
128 static void _E(jit_state_t*,_ui);
129 # define I_(Op,I) _I(_jit,Op,I)
130 static void _I(jit_state_t*,_ui,_ui);
131 # define RR_(Op,R1,R2) _RR(_jit,Op,R1,R2)
132 static void _RR(jit_state_t*,_ui,_ui,_ui);
133 # define RRE_(Op,R1,R2) _RRE(_jit,Op,R1,R2)
134 static void _RRE(jit_state_t*,_ui,_ui,_ui);
135 # define RRF_(Op,R3,M4,R1,R2) _RRF(_jit,Op,R3,M4,R1,R2)
136 static void _RRF(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
137 # define RX_(Op,R1,X2,B2,D2) _RX(_jit,Op,R1,X2,B2,D2)
138 static void _RX(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
139 # define RXE_(Op,R1,X2,B2,D2,Op2) _RXE(_jit,Op,R1,X2,B2,D2,Op2)
140 static void _RXE(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui);
141 # define RXF_(Op,R3,X2,B2,D2,R1,Op2) _RXF(_jit,Op,R3,X2,B2,D2,R1,Op2)
142 static void _RXF(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui,_ui);
143 # define RXY_(Op,R1,X2,B2,D2,Op2) _RXY(_jit,Op,R1,X2,B2,D2,Op2)
144 static void _RXY(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui);
145 # define RS_(Op,R1,R3,B2,D2) _RS(_jit,Op,R1,R3,B2,D2)
146 static void _RS(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
147 # define RSY_(Op,R1,R3,B2,D2,Op2) RXY_(Op,R1,R3,B2,D2,Op2)
148 # define RSL_(Op,L1,B1,D1,Op2) _RSL(_jit,Op,L1,B1,D1,Op2)
149 static void _RSL(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
150 # define RSI_(Op,R1,R3,I2) _RSI(_jit,Op,R1,R3,I2)
151 static void _RSI(jit_state_t*,_ui,_ui,_ui,_ui);
152 # define RI_(Op,R1,Op2,I2) RSI_(Op,R1,Op2,I2)
153 # define RIE_(Op,R1,R3,I2,Op2) _RIE(_jit,Op,R1,R3,I2,Op2)
154 static void _RIE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
155 # define RIL_(Op,R1,Op2,I2) _RIL(_jit,Op,R1,Op2,I2)
156 static void _RIL(jit_state_t*,_ui,_ui,_ui,_ui);
157 # define SI_(Op,I2,B1,D1) _SI(_jit,Op,I2,B1,D1)
158 static void _SI(jit_state_t*,_ui,_ui,_ui,_ui);
159 # define SIY_(Op,I2,B1,D1,Op2) _SIY(_jit,Op,I2,B1,D1,Op2)
160 static void _SIY(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
161 # define S_(Op,B2,D2) _S(_jit,Op,B2,D2)
162 static void _S(jit_state_t*,_ui,_ui,_ui);
163 # define SSL_(Op,L,B1,D1,B2,D2) SS_(Op,(L)>>4,(L)&0xF,B1,D1,B2,D2)
164 # define SS_(Op,LL,LH,B1,D1,B2,D2) _SS(_jit,Op,LL,LH,B1,D1,B2,D2)
165 static void _SS(jit_state_t*,_ui,_ui,_ui,_ui,_ui,_ui,_ui);
166 # define SSE_(Op,B1,D1,B2,D2) _SSE(_jit,Op,B1,D1,B2,D2)
167 static void _SSE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
170 # define nop(c) _nop(_jit,c)
171 static void _nop(jit_state_t*,jit_int32_t);
172 # if __WORDSIZE == 32
173 # define ADD_(r0,r1) AR(r0,r1)
174 # define ADDI_(r0,i0) AHI(r0,i0)
175 # define ADDC_(r0,r1) ALR(r0,r1)
176 # define ADDX_(r0,r1) ALCR(r0,r1)
177 # define AND_(r0,r1) NR(r0,r1)
178 # define CMP_(r0,r1) CR(r0,r1)
179 # define CMPU_(r0,r1) CLR(r0,r1)
180 # define DIVREM_(r0,r1) DR(r0,r1)
181 # define DIVREMU_(r0,r1) DLR(r0,r1)
182 # define OR_(r0,r1) OR(r0,r1)
183 # define MUL_(r0,r1) MSR(r0,r1)
184 # define MULI_(r0,i0) MHI(r0,i0)
185 # define MULU_(r0,r1) MLR(r0,r1)
186 # define SUB_(r0,r1) SR(r0,r1)
187 # define SUBC_(r0,r1) SLR(r0,r1)
188 # define SUBX_(r0,r1) SLBR(r0,r1)
189 # define TEST_(r0,r1) LTR(r0,r1)
190 # define XOR_(r0,r1) XR(r0,r1)
192 # define ADD_(r0,r1) AGR(r0,r1)
193 # define ADDI_(r0,i0) AGHI(r0,i0)
194 # define ADDC_(r0,r1) ALGR(r0,r1)
195 # define ADDX_(r0,r1) ALCGR(r0,r1)
196 # define AND_(r0,r1) NGR(r0,r1)
197 # define CMP_(r0,r1) CGR(r0,r1)
198 # define CMPU_(r0,r1) CLGR(r0,r1)
199 # define DIVREM_(r0,r1) DSGR(r0,r1)
200 # define DIVREMU_(r0,r1) DLGR(r0,r1)
201 # define MUL_(r0,r1) MSGR(r0,r1)
202 # define MULI_(r0,i0) MGHI(r0,i0)
203 # define MULU_(r0,r1) MLGR(r0,r1)
204 # define OR_(r0,r1) OGR(r0,r1)
205 # define SUB_(r0,r1) SGR(r0,r1)
206 # define SUBC_(r0,r1) SLGR(r0,r1)
207 # define SUBX_(r0,r1) SLBGR(r0,r1)
208 # define TEST_(r0,r1) LTGR(r0,r1)
209 # define XOR_(r0,r1) XGR(r0,r1)
211 /****************************************************************
212 * General Instructions *
213 ****************************************************************/
215 # define AR(R1,R2) RR_(0x1A,R1,R2)
216 # define AGR(R1,R2) RRE_(0xB908,R1,R2)
217 # define AGFR(R1,R2) RRE_(0xB918,R1,R2)
218 # define A(R1,D2,X2,B2) RX_(0x5A,R1,X2,B2,D2)
219 # define AY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5A)
220 # define AG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x08)
221 # define AGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x18)
223 # define AH(R1,D2,X2,B2) RX_(0x4A,R1,X2,B2,D2)
224 # define AHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x7A)
225 /* ADD HALFWORD IMMEDIATE */
226 # define AHI(R1,I2) RI_(0xA7,R1,0xA,I2)
227 # define AGHI(R1,I2) RI_(0xA7,R1,0xB,I2)
229 # define ALR(R1,R2) RR_(0x1E,R1,R2)
230 # define ALGR(R1,R2) RRE_(0xB90A,R1,R2)
231 # define ALGFR(R1,R2) RRE_(0xB91A,R1,R2)
232 # define AL(R1,D2,X2,B2) RX_(0x5E,R1,X2,B2,D2)
233 # define ALY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5E)
234 # define ALG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0A)
235 # define ALGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1A)
236 /* ADD LOGICAL WITH CARRY */
237 # define ALCR(R1,R2) RRE_(0xB998,R1,R2)
238 # define ALCGR(R1,R2) RRE_(0xB988,R1,R2)
239 # define ALC(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x98)
240 # define ALCG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x88)
242 # define NR(R1,R2) RR_(0x14,R1,R2)
243 # define NGR(R1,R2) RRE_(0xB980,R1,R2)
244 # define N(R1,D2,X2,B2) RX_(0x54,R1,X2,B2,D2)
245 # define NY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x54)
246 # define NG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x80)
247 # define NI(D1,B1,I2) SI_(0x94,I2,B1,D1)
248 # define NIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x54)
249 # define NC(D1,L,B1,D2,B2) SSL_(0xD4,L,B1,D1,B2,D2)
251 # define NIHH(R1,I2) RI_(0xA5,R1,0x4,I2)
252 # define NIHL(R1,I2) RI_(0xA5,R1,0x5,I2)
253 # define NILH(R1,I2) RI_(0xA5,R1,0x6,I2)
254 # define NILL(R1,I2) RI_(0xA5,R1,0x7,I2)
255 /* BRANCH AND LINK */
256 # define BALR(R1,R2) RR_(0x05,R1,R2)
257 # define BAL(R1,D2,X2,B2) RX_(0x45,R1,X2,B2,D2)
258 /* BRANCH AND SAVE */
259 # define BASR(R1,R2) RR_(0x0D,R1,R2)
260 # define BAS(R1,D2,X2,B2) RX_(0x4D,R1,X2,B2,D2)
261 /* BRANCH AND SAVE AND SET MODE */
262 # define BASSM(R1,R2) RR_(0x0C,R1,R2)
263 /* BRANCH AND SET MODE */
264 # define BSM(R1,R2) RR_(0x0B,R1,R2)
265 /* BRANCH ON CONDITION */
266 # define BCR(M1,R2) RR_(0x07,M1,R2)
267 # define BR(R2) BCR(CC_AL,R2)
268 # define NOPR(R2) BCR(CC_NV,R2)
269 # define BC(M1,D2,X2,B2) RX_(0x47,M1,X2,B2,D2)
270 /* BRANCH ON COUNT */
271 # define BCTR(R1,R2) RR_(0x06,R1,R2)
272 # define BCTGR(R1,R2) RRE_(0xB946,R1,R2)
273 # define BCT(R1,D2,X2,B2) RX_(0x46,R1,X2,B2,D2)
274 # define BCTG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x46)
275 /* BRANCH ON INDEX HIGH */
276 # define BXH(R1,R3,D2,B2) RS_(0x86,R1,R3,B2,D2)
277 # define BXHG(R1,R3,B2,D2) RSY_(0xEB,R1,R3,B2,D2,0x44)
278 /* BRANCH ON INDEX LOW OR EQUAL */
279 # define BXLE(R1,R3,D2,B2) RS_(0x87,R1,R3,B2,D2)
280 # define BXLEG(R1,R3,B2,D2) RSY_(0xEB,R1,R3,B2,D2,0x45)
281 /* BRANCH RELATIVE AND SAVE */
282 # define BRAS(R1,I2) RI_(0xA7,R1,0x5,I2)
283 /* BRANCH RELATIVE AND SAVE LONG */
284 # define BRASL(R1,I2) RIL_(0xC0,R1,0x5,I2)
285 /* BRANCH RELATIVE ON CONDITION */
286 # define BRC(M1,I2) RI_(0xA7,M1,0x4,I2)
287 # define J(I2) BRC(CC_AL,I2)
288 /* BRANCH RELATIVE ON CONDITION LONG */
289 # define BRCL(M1,I2) RIL_(0xC0,M1,0x4,I2)
290 # define BRL(I2) BRCL(CC_AL,I2)
291 /* BRANCH RELATIVE ON COUNT */
292 # define BRCT(M1,I2) RI_(0xA7,M1,0x6,I2)
293 # define BRCTG(M1,I2) RI_(0xA7,M1,0x7,I2)
294 /* BRANCH RELATIVE ON INDEX HIGH */
295 # define BRXH(R1,R3,I2) RSI_(0x84,R1,R3,I2)
296 # define BRXHG(R1,R3,I2) RIE_(0xEC,R1,R3,I2,0x44)
297 /* BRANCH RELATIVE ON INDEX LOW OR EQUAL */
298 # define BRXLE(R1,R3,I2) RSI_(0x85,R1,R3,I2)
299 # define BRXLEG(R1,R3,I2) RIE_(0xEC,R1,R3,I2,0x45)
301 # define CKSUM(R1,R2) RRE_(0xB241,R1,R2)
302 /* CIPHER MESAGE (KM) */
303 # define KM(R1,R2) RRE_(0xB92E,R1,R2)
304 /* CIPHER MESAGE WITH CHAINING (KMC) */
305 # define KMC(R1,R2) RRE_(0xB92F,R1,R2)
307 # define CR(R1,R2) RR_(0x19,R1,R2)
308 # define CGR(R1,R2) RRE_(0xB920,R1,R2)
309 # define CGFR(R1,R2) RRE_(0xB930,R1,R2)
310 # define C(R1,D2,X2,B2) RX_(0x59,R1,X2,B2,D2)
311 # define CY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x59)
312 # define CG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x20)
313 # define CGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x30)
314 /* COMPARE AND FORM CODEWORD */
315 # define CFC(D2,B2) S_(0xB21A,B2,D2)
316 /* COMPARE AND SWAP */
317 # define CS(R1,R3,D2,B2) RS_(0xBA,R1,R3,B2,D2)
318 # define CSY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x14)
319 # define CSG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x30)
320 /* COMPARE DOUBLE AND SWAP */
321 # define CDS(R1,R3,D2,B2) RS_(0xBB,R1,R3,B2,D2)
322 # define CSDY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x31)
323 # define CSDG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x3E)
324 /* COMPARE HALFWORD */
325 # define CH(R1,D2,X2,B2) RX_(0x49,R1,X2,B2,D2)
326 # define CHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x79)
327 /* COMPARE HALFWORD IMMEDIATE */
328 # define CHI(R1,I2) RI_(0xA7,R1,0xE,I2)
329 # define CGHI(R1,I2) RI_(0xA7,R1,0xF,I2)
330 /* COMPARE LOGICAL */
331 # define CLR(R1,R2) RR_(0x15,R1,R2)
332 # define CLGR(R1,R2) RRE_(0xB921,R1,R2)
333 # define CLGFR(R1,R2) RRE_(0xB931,R1,R2)
334 # define CL(R1,D2,X2,B2) RX_(0x55,R1,X2,B2,D2)
335 # define CLY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x55)
336 # define CLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x21)
337 # define CLGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x31)
338 # define CLI(D1,B1,I2) SI_(0x95,I2,B1,D1)
339 # define CLIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x55)
340 # define CLC(D1,L,B1,D2,B2) SSL_(0xD5,L,B1,D1,B2,D2)
341 /* COMPARE LOGICAL CHARACTERS UNDER MASK */
342 # define CLM(R1,M3,D2,B2) RS_(0xBD,R1,M3,B2,D2)
343 # define CLMY(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x21)
344 # define CLMH(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x20)
345 /* COMPARE LOGICAL LONG */
346 # define CLCL(R1,R2) RR_(0x0F,R1,R2)
347 /* COMPARE LOGICAL LONG EXTENDED */
348 # define CLCLE(R1,R3,D2,B2) RS_(0xA9,R1,R3,B2,D2)
349 /* COMPARE LOGICAL LONG UNICODE */
350 # define CLCLU(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x8F)
351 /* COMPARE LOGICAL STRING */
352 # define CLST(R1,R2) RRE_(0xB25D,R1,R2)
353 /* COMPARE UNTIL SUBSTRING EQUAL */
354 # define CUSE(R1,R2) RRE_(0xB257,R1,R2)
355 /* COMPRESSION CALL */
356 # define CMPSC(R1,R2) RRE_(0xB263,R1,R2)
357 /* COMPUTE INTERMEDIATE MESSAGE DIGEST (KIMD) */
358 # define KIMD(R1,R2) RRE_(0xB93E,R1,R2)
359 /* COMPUTE LAST MESSAGE DIGEST (KIMD) */
360 # define KLMD(R1,R2) RRE_(0xB93F,R1,R2)
361 /* COMPUTE MESSAGE AUTHENTICATION CODE (KMAC) */
362 # define KMAC(R1,R2) RRE_(0xB91E,R1,R2)
363 /* CONVERT TO BINARY */
364 # define CVB(R1,D2,X2,B2) RX_(0x4F,R1,X2,B2,D2)
365 # define CVBY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x06)
366 # define CVBG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0e)
367 /* CONVERT TO DECIMAL */
368 # define CVD(R1,D2,X2,B2) RX_(0x4E,R1,X2,B2,D2)
369 # define CVDY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x26)
370 # define CVDG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x2E)
371 /* CONVERT UNICODE TO UTF-8 */
372 # define CUUTF(R1,R2) RRE_(0xB2A6,R1,R2)
373 /* CONVERT UTF-8 TO UNICODE */
374 # define CUTFU(R1,R2) RRE_(0xB2A7,R1,R2)
376 # define CPYA(R1,R2) RRE_(0xB24D,R1,R2)
378 # define DR(R1,R2) RR_(0x1D,R1,R2)
379 # define D(R1,D2,X2,B2) RX_(0x5D,R1,X2,B2,D2)
381 # define DLR(R1,R2) RRE_(0xB997,R1,R2)
382 # define DLGR(R1,R2) RRE_(0xB987,R1,R2)
383 # define DL(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x97)
384 # define DLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x87)
386 # define DSGR(R1,R2) RRE_(0xB90D,R1,R2)
387 # define DSGFR(R1,R2) RRE_(0xB91D,R1,R2)
388 # define DSG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0D)
389 # define DSGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1D)
391 # define XR(R1,R2) RR_(0x17,R1,R2)
392 # define XGR(R1,R2) RRE_(0xB982,R1,R2)
393 # define X(R1,D2,X2,B2) RX_(0x57,R1,X2,B2,D2)
394 # define XY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x57)
395 # define XG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x82)
396 # define XI(D1,B1,I2) SI_(0x97,I2,B1,D1)
397 # define XIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x57)
398 # define XC(D1,L,B1,D2,B2) SSL_(0xD7,L,B1,D1,B2,D2)
400 # define EX(R1,D2,X2,B2) RX_(0x44,R1,X2,B2,D2)
402 # define EAR(R1,R2) RRE_(0xB24F,R1,R2)
404 # define EPSW(R1,R2) RRE_(0xB98D,R1,R2)
405 /* FIND LEFTMOST ONE */
406 # define FLOGR(R1,R2) RRE_(0xB983,R1,R2)
407 /* INSERT CHARACTER */
408 # define IC(R1,D2,X2,B2) RX_(0x43,R1,X2,B2,D2)
409 # define ICY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x73)
410 /* INSERT CHARACTERS UNDER MASK */
411 # define ICM(R1,M3,D2,B2) RS_(0xBF,R1,M3,B2,D2)
412 # define ICMY(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x81)
413 # define ICMH(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x80)
414 /* INSERT IMMEDIATE */
415 # define IIHH(R1,I2) RI_(0xA5,R1,0x0,I2)
416 # define IIHL(R1,I2) RI_(0xA5,R1,0x1,I2)
417 # define IILH(R1,I2) RI_(0xA5,R1,0x2,I2)
418 # define IILL(R1,I2) RI_(0xA5,R1,0x3,I2)
419 /* INSERT PROGRAM MASK */
420 # define IPM(R1) RRE_(0xB222,R1,0)
422 # define LR(R1,R2) RR_(0x18,R1,R2)
423 # define LGR(R1,R2) RRE_(0xB904,R1,R2)
424 # define LGFR(R1,R2) RRE_(0xB914,R1,R2)
425 # define L(R1,D2,X2,B2) RX_(0x58,R1,X2,B2,D2)
426 # define LY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x58)
427 # define LG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x04)
428 # define LGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x14)
429 /* LOAD ACCESS MULTIPLE */
430 # define LAM(R1,R3,D2,B2) RS_(0x9A,R1,R3,B2,D2)
431 # define LAMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x9A)
433 # define LA(R1,D2,X2,B2) RX_(0x41,R1,X2,B2,D2)
434 # define LAY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x71)
435 /* LOAD ADDRESS EXTENDED */
436 # define LAE(R1,D2,X2,B2) RX_(0x51,R1,X2,B2,D2)
437 /* LOAD ADDRESS RELATIVE LONG */
438 # define LARL(R1,I2) RIL_(0xC0,R1,0x0,I2)
440 # define LTR(R1,R2) RR_(0x12,R1,R2)
441 # define LTGR(R1,R2) RRE_(0xB902,R1,R2)
442 # define LTGFR(R1,R2) RRE_(0xB912,R1,R2)
444 # define LGBR(R1,R2) RRE_(0xB906,R1,R2) /* disasm */
445 # define LB(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x76)
446 # define LGB(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x77)
447 /* LOAD COMPLEMENT */
448 # define LCR(R1,R2) RR_(0x13,R1,R2)
449 # define LCGR(R1,R2) RRE_(0xB903,R1,R2)
450 # define LCGFR(R1,R2) RRE_(0xB913,R1,R2)
452 # define LH(R1,D2,X2,B2) RX_(0x48,R1,X2,B2,D2)
453 # define LHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x78)
454 # define LGHR(R1,R2) RRE_(0xB907,R1,R2) /* disasm */
455 # define LGH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x15)
456 /* LOAD HALFWORD IMMEDIATE */
457 # define LHI(R1,I2) RI_(0xA7,R1,0x8,I2)
458 # define LGHI(R1,I2) RI_(0xA7,R1,0x9,I2)
460 # define LLGFR(R1,R2) RRE_(0xB916,R1,R2)
461 # define LLGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x16)
462 /* LOAD LOGICAL CHARACTER */
463 # define LLGCR(R1,R2) RRE_(0xB984,R1,R2) /* disasm */
464 # define LLGC(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x90)
465 /* LOAD LOGICAL HALFWORD */
466 # define LLGHR(R1,R2) RRE_(0xB985,R1,R2) /* disasm */
467 # define LLGH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x91)
468 /* LOAD LOGICAL IMMEDIATE */
469 # define LLIHH(R1,I2) RI_(0xA5,R1,0xC,I2)
470 # define LLIHL(R1,I2) RI_(0xA5,R1,0xD,I2)
471 # define LLILH(R1,I2) RI_(0xA5,R1,0xE,I2)
472 # define LLILL(R1,I2) RI_(0xA5,R1,0xF,I2)
473 /* LOAD LOGICAL THIRTY ONE BITS */
474 # define LLGTR(R1,R2) RRE_(0xB917,R1,R2)
475 # define LLGT(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x17)
477 # define LM(R1,R3,D2,B2) RS_(0x98,R1,R3,B2,D2)
478 # define LMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x98)
479 # define LMG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x04)
480 /* LOAD MULTIPLE DISJOINT */
481 # define LMD(R1,R3,D2,B2,D4,B4) SS_(0xEF,R1,R3,B2,D2,B4,D4)
482 /* LOAD MULTIPLE HIGH */
483 # define LMH(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x96)
485 # define LNR(R1,R2) RR_(0x11,R1,R2)
486 # define LNGR(R1,R2) RRE_(0xB901,R1,R2)
487 # define LNGFR(R1,R2) RRE_(0xB911,R1,R2)
488 /* LOAD PAIR FROM QUADWORD */
489 # define LPQ(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x8F)
491 # define LPR(R1,R2) RR_(0x10,R1,R2)
492 # define LPGR(R1,R2) RRE_(0xB900,R1,R2)
493 # define LPGFR(R1,R2) RRE_(0xB910,R1,R2)
495 # define LRVR(R1,R2) RRE_(0xB91F,R1,R2)
496 # define LRVGR(R1,R2) RRE_(0xB90F,R1,R2)
497 # define LRVH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1F)
498 # define LRV(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1E)
499 # define LRVG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0F)
501 # define MC(D1,B1,I2) SI_(0xAF,I2,B1,D1)
503 # define MVI(D1,B1,I2) SI_(0x92,I2,B1,D1)
504 # define MVIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x52)
505 # define MVC(D1,L,B1,D2,B2) SSL_(0xD2,L,B1,D1,B2,D2)
507 # define MVCIN(D1,L,B1,D2,B2) SSL_(0xE8,L,B1,D1,B2,D2)
509 # define MVCL(R1,R2) RR_(0x0E,R1,R2)
510 /* MOVE LONG EXTENDED */
511 # define MVCLE(R1,R3,D2,B2) RS_(0xA8,R1,R3,B2,D2)
512 /* MOVE LONG UNICODE */
513 # define MVCLU(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x8E)
515 # define MVN(D1,L,B1,D2,B2) SSL_(0xD1,L,B1,D1,B2,D2)
517 # define MVST(R1,R2) RRE_(0xB255,R1,R2)
518 /* MOVE WITH OFFSET */
519 # define MVO(D1,L1,B1,D2,L2,B2) SS_(0xF1,L1,L2,B1,D1,B2,D2)
521 # define MVZ(D1,L,B1,D2,B2) SSL_(0xD3,L,B1,D1,B2,D2)
523 # define MR(R1,R2) RR_(0x1C,R1,R2)
524 # define M(R1,D2,X2,B2) RX_(0x5C,R1,X2,B2,D2)
525 /* MULTIPLY HALFWORD */
526 # define MH(R1,D2,X2,B2) RX_(0x4C,R1,X2,B2,D2)
527 /* MULTIPLY HALFWORD IMMEDIATE */
528 # define MHI(R1,I2) RI_(0xA7,R1,0xC,I2)
529 # define MGHI(R1,I2) RI_(0xA7,R1,0xD,I2)
530 /* MULTIPLY LOGICAL */
531 # define MLR(R1,R2) RRE_(0xB996,R1,R2)
532 # define MLGR(R1,R2) RRE_(0xB986,R1,R2)
533 # define ML(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x96)
534 # define MLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x86)
535 /* MULTIPLY SINGLE */
536 # define MSR(R1,R2) RRE_(0xB252,R1,R2)
537 # define MSGR(R1,R2) RRE_(0xB90C,R1,R2)
538 # define MSGFR(R1,R2) RRE_(0xB91C,R1,R2)
539 # define MS(R1,D2,X2,B2) RX_(0x71,R1,X2,B2,D2)
540 # define MSY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x51)
541 # define MSG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0C)
542 # define MSGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1C)
544 # define OR(R1,R2) RR_(0x16,R1,R2)
545 # define OGR(R1,R2) RRE_(0xB981,R1,R2)
546 # define O(R1,D2,X2,B2) RX_(0x56,R1,X2,B2,D2)
547 # define OY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x56)
548 # define OG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x81)
549 # define OI(D1,B1,I2) SI_(0x96,I2,B1,D1)
550 # define OIY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x56)
551 # define OC(D1,L,B1,D2,B2) SSL_(0xD6,L,B1,D1,B2,D2)
553 # define OIHH(R1,I2) RI_(0xA5,R1,0x8,I2)
554 # define OIHL(R1,I2) RI_(0xA5,R1,0x9,I2)
555 # define OILH(R1,I2) RI_(0xA5,R1,0xA,I2)
556 # define OILL(R1,I2) RI_(0xA5,R1,0xB,I2)
558 # define PACK(D1,L1,B1,D2,L2,B2) SS_(0xF2,L1,L2,B1,D1,B2,D2)
560 # define PKA(D1,B1,D2,L2,B2) SSL_(0xE9,L2,B1,D1,B2,D2)
562 # define PKU(D1,B1,D2,L2,B2) SSL_(0xE1,L2,B1,D1,B2,D2)
563 /* PERFORM LOCKED OPERATION */
564 # define PLO(R1,D2,B2,R3,D4,B4) SS_(0xEE,R1,R3,B2,D2,B4,D4)
565 /* ROTATE LEFT SINGLE LOGICAL */
566 # define RLL(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x1D)
567 # define RLLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x1C)
569 # define SRST(R1,R2) RRE_(0xB25E,R1,R2)
571 # define SAR(R1,R2) RRE_(0xB24E,R1,R2)
572 /* SET ADDRESSING MODE */
573 # define SAM24() E_(0x10C)
574 # define SAM31() E_(0x10D)
575 # define SAM64() E_(0x10E)
576 /* SET PROGRAM MASK */
577 # define SPM(R1) RR_(0x04,R1,0)
578 /* SHIFT LEFT DOUBLE */
579 # define SLDA(R1,D2,B2) RS_(0x8F,R1,0,B2,D2)
580 /* SHIFT LEFT DOUBLE LOGICAL */
581 # define SLDL(R1,D2,B2) RS_(0x8D,R1,0,B2,D2)
582 /* SHIFT LEFT SINGLE */
583 # define SLA(R1,D2,B2) RS_(0x8B,R1,0,B2,D2)
584 # define SLAG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0B)
585 /* SHIFT LEFT SINGLE LOGICAL */
586 # define SLL(R1,D2,B2) RS_(0x89,R1,0,B2,D2)
587 # define SLLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0D)
588 /* SHIFT RIGHT DOUBLE */
589 # define SRDA(R1,D2,B2) RS_(0x8E,R1,0,B2,D2)
590 /* SHIFT RIGHT DOUBLE LOGICAL */
591 # define SRDL(R1,D2,B2) RS_(0x8C,R1,0,B2,D2)
592 /* SHIFT RIGHT SINGLE */
593 # define SRA(R1,D2,B2) RS_(0x8A,R1,0,B2,D2)
594 # define SRAG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0A)
595 /* SHIFT RIGHT SINGLE LOGICAL */
596 # define SRL(R1,D2,B2) RS_(0x88,R1,0,B2,D2)
597 # define SRLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0C)
599 # define ST(R1,D2,X2,B2) RX_(0x50,R1,X2,B2,D2)
600 # define STY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x50)
601 # define STG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x24)
602 /* STORE ACCESS MULTIPLE */
603 # define STAM(R1,R3,D2,B2) RS_(0x9B,R1,R3,B2,D2)
604 # define STAMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x9B)
605 /* STORE CHARACTER */
606 # define STC(R1,D2,X2,B2) RX_(0x42,R1,X2,B2,D2)
607 # define STCY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x72)
608 /* STORE CHARACTERS UNDER MASK */
609 # define STCM(R1,M3,D2,B2) RS_(0xBE,R1,M3,B2,D2)
610 # define STCMY(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x2D)
611 # define STCMH(R1,M3,D2,B2) RSY_(0xEB,R1,M3,B2,D2,0x2C)
613 # define STCK(D2,B2) S_(0xB205,B2,D2)
614 /* STORE CLOCK EXTENDED */
615 # define STCKE(D2,B2) S_(0xB278,B2,D2)
617 # define STH(R1,D2,X2,B2) RX_(0x40,R1,X2,B2,D2)
618 # define STHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x70)
620 # define STM(R1,R3,D2,B2) RS_(0x90,R1,R3,B2,D2)
621 # define STMY(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x90)
622 # define STMG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x24)
623 /* STORE MULTIPLE HIGH */
624 # define STMH(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x26)
625 /* STORE PAIR TO QUADWORD */
626 # define STPQ(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x8E)
628 # define STRVH(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x3F)
629 # define STRV(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x3E)
630 # define STRVG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x2F)
632 # define SR(R1,R2) RR_(0x1B,R1,R2)
633 # define SGR(R1,R2) RRE_(0xB909,R1,R2)
634 # define SGFR(R1,R2) RRE_(0xB919,R1,R2)
635 # define S(R1,D2,X2,B2) RX_(0x5B,R1,X2,B2,D2)
636 # define SY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5B)
637 # define SG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x09)
638 # define SGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x19)
639 /* SUBTRACT HALFWORD */
640 # define SH(R1,D2,X2,B2) RX_(0x4B,R1,X2,B2,D2)
641 # define SHY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x7B)
642 /* SUBTRACT LOGICAL */
643 # define SLR(R1,R2) RR_(0x1F,R1,R2)
644 # define SLGR(R1,R2) RRE_(0xB90B,R1,R2)
645 # define SLGFR(R1,R2) RRE_(0xB91B,R1,R2)
646 # define SL(R1,D2,X2,B2) RX_(0x5F,R1,X2,B2,D2)
647 # define SLY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x5F)
648 # define SLG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x0B)
649 # define SLGF(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x1B)
650 /* SUBTRACT LOGICAL WITH BORROW */
651 # define SLBR(R1,R2) RRE_(0xB999,R1,R2)
652 # define SLBGR(R1,R2) RRE_(0xB989,R1,R2)
653 # define SLB(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x99)
654 # define SLBG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x89)
655 /* SUPERVISOR CALL */
656 # define SVC(I) I_(0xA,I)
657 /* TEST ADDRESSING MODE */
658 # define TAM() E_(0x10B)
660 # define TS(D2,B2) RS_(0x93,0,0,B2,D2)
661 /* TEST UNDER MASK (TEST UNDER MASK HIGH, TEST UNDER MASK LOW) */
662 # define TM(D1,B1,I2) SI_(0x91,I2,B1,D1)
663 # define TMY(D1,B1,I2) SIY_(0xEB,I2,B1,D1,0x51)
664 # define TMHH(R1,I2) RI_(0xA7,R1,0x2,I2)
665 # define TMHL(R1,I2) RI_(0xA7,R1,0x3,I2)
666 # define TMLH(R1,I2) RI_(0xA7,R1,0x0,I2)
667 # define TMH(R1,I2) TMLH(R1,I2)
668 # define TMLL(R1,I2) RI_(0xA7,R1,0x1,I2)
669 # define TML(R1,I2) TMLL(R1,I2)
671 # define TR(D1,L,B1,D2,B2) SSL_(0xDC,L,B1,D1,B2,D2)
672 /* TRANSLATE AND TEST */
673 # define TRT(D1,L,B1,D2,B2) SSL_(0xDD,L,B1,D1,B2,D2)
674 /* TRANSLATE EXTENDED */
675 # define TRE(R1,R2) RRE_(0xB2A5,R1,R2)
676 /* TRANSLATE ONE TO ONE */
677 # define TROO(R1,R2) RRE_(0xB993,R1,R2)
678 /* TRANSLATE ONE TO TWO */
679 # define TROT(R1,R2) RRE_(0xB992,R1,R2)
680 /* TRANSLATE TWO TO ONE */
681 # define TRTO(R1,R2) RRE_(0xB991,R1,R2)
682 /* TRANSLATE TWO TO TWO */
683 # define TRTT(R1,R2) RRE_(0xB990,R1,R2)
685 # define UNPK(D1,L1,B1,D2,L2,B2) SS_(0xF3,L1,L2,B1,D1,B2,D2)
687 # define UNPKA(D1,L1,B1,D2,L2,B2) SS_(0xEA,L1,L2,B1,D1,B2,D2)
689 # define UNPKU(D1,L1,B1,D2,L2,B2) SS_(0xE2,L1,L2,B1,D1,B2,D2)
691 # define UPT() E_(0x0102)
692 /****************************************************************
693 * Decimal Instructions *
694 ****************************************************************/
696 # define AP(D1,L1,B1,D2,L2,B2) SS_(0xFA,L1,L2,B1,D1,B2,D2)
697 /* COMPARE DECIMAL */
698 # define CP(D1,L1,B1,D2,L2,B2) SS_(0xF9,L1,L2,B1,D1,B2,D2)
700 # define DP(D1,L1,B1,D2,L2,B2) SS_(0xFD,L1,L2,B1,D1,B2,D2)
702 # define ED(D1,L,B1,D2,B2) SSL_(0xDE,L,B1,D1,B2,D2)
704 # define EDMK(D1,L,B1,D2,B2) SSL_(0xDE,L,B1,D1,B2,D2)
705 /* MULTIPLY DECIMAL */
706 # define MP(D1,L1,B1,D2,L2,B2) SS_(0xFC,L1,L2,B1,D1,B2,D2)
707 /* SHIFT AND ROUND DECIMAL */
708 # define SRP(D1,L1,B1,D2,L2,B2) SS_(0xF0,L1,L2,B1,D1,B2,D2)
709 /* SUBTRACE DECIMAL */
710 # define SP(D1,L1,B1,D2,L2,B2) SS_(0xFB,L1,L2,B1,D1,B2,D2)
712 # define TP(D1,L1,B1) RSL_(0xEB,L1,B1,D1,0xC0)
714 # define ZAP(D1,L1,B1,D2,L2,B2) SS_(0xF8,L1,L2,B1,D1,B2,D2)
715 /****************************************************************
716 * Control Instructions *
717 ****************************************************************/
718 /* BRANCH AND SET AUTHORITY */
719 # define BSA(R1,R2) RRE_(0xB25A,R1,R2)
720 /* BRANCH AND STACK */
721 # define BAKR(R1,R2) RRE_(0xB240,R1,R2)
722 /* BRANCH IN SUBSPACE GROUP */
723 # define BSG(R1,R2) RRE_(0xB258,R1,R2)
724 /* COMPARE AND SWAP AND PURGE */
725 # define CSP(R1,R2) RRE_(0xB250,R1,R2)
726 # define CSPG(R1,R2) RRE_(0xB98A,R1,R2)
728 # define DIAG() SI_(0x83,0,0,0)
729 /* EXTRACT AND SET EXTENDED AUTHORITY */
730 # define ESEA(R1) RRE_(0xB99D,R1,0)
731 /* EXTRACT PRIMARY ASN */
732 # define EPAR(R1) RRE_(0xB226,R1,0)
733 /* EXTRACT SECONDARY ASN */
734 # define ESAR(R1) RRE_(0xB227,R1,0)
735 /* EXTRACT STACKED REGISTERS */
736 # define EREG(R1,R2) RRE_(0xB249,R1,R2)
737 # define EREGG(R1,R2) RRE_(0xB90E,R1,R2)
738 /* EXTRACT STACKED STATE */
739 # define ESTA(R1,R2) RRE_(0xB24A,R1,R2)
740 /* INSERT ADDRESS SPACE CONTROL */
741 # define IAC(R1) RRE_(0xB224,R1,0)
743 # define IPK() S_(0xB20B,0,0)
744 /* INSERT STORAGE KEY EXTENDED */
745 # define ISKE(R1,R2) RRE_(0xB229,R1,R2)
746 /* INSERT VIRTUAL STORAGE KEY */
747 # define IVSK(R1,R2) RRE_(0xB223,R1,R2)
748 /* INVALIDATE DAT TABLE ENTRY */
749 # define IDTE(R1,R2,R3) RRF_(0xB98E,R3,0,R1,R2)
750 /* INVALIDATE PAGE TABLE ENTRY */
751 # define IPTE(R1,R2) RRE_(0xB221,R1,R2)
752 /* LOAD ADDRESS SPACE PARAMETER */
753 # define LASP(D1,B1,D2,B2) SSE_(0xE500,B1,D1,B2,D2)
755 # define LCTL(R1,R3,D2,B2) RS_(0xB7,R1,R3,B2,D2)
756 # define LCTLG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x2F)
758 # define LPSW(D2,B2) SI_(0x82,0,B2,D2)
759 /* LOAD PSW EXTENDED */
760 # define LPSWE(D2,B2) S_(0xB2B2,B2,D2)
761 /* LOAD REAL ADDRESS */
762 # define LRA(R1,D2,X2,B2) RX_(0xB1,R1,X2,B2,D2)
763 # define LRAY(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x13)
764 # define LRAG(R1,D2,X2,B2) RXY_(0xE3,R1,X2,B2,D2,0x03)
765 /* LOAD USING REAL ADDRESS */
766 # define LURA(R1,R2) RRE_(0xB24B,R1,R2)
767 # define LURAG(R1,R2) RRE_(0xB905,R1,R2)
768 /* MODIFY STACKED STATE */
769 # define MSTA(R1) RRE_(0xB247,R1,0)
771 # define MVPG(R1,R2) RRE_(0xB254,R1,R2)
772 /* MOVE TO PRIMARY */
773 # define MVCP(D1,R1,B1,D2,B2,R3) SS_(0xDA,R1,R3,B1,D1,B2,D2)
774 /* MOVE TO SECONDARY */
775 # define MVCS(D1,R1,B1,D2,B2,R3) SS_(0xDB,R1,R3,B1,D1,B2,D2)
776 /* MOVE WITH DESTINATION KEY */
777 # define MVCDK(D1,B1,D2,B2) SSE_(0xE50F,B1,D1,B2,D2)
779 # define MVCK(D1,R1,B1,D2,B2,R3) SS_(0xD9,R1,R3,B1,D1,B2,D2)
780 /* MOVE WITH SOURCE KEY */
781 # define MVCSK(D1,B1,D2,B2) SSE_(0xE50E,B1,D1,B2,D2)
783 # define PGIN(R1,R2) RRE_(0xB22E,R1,R2)
785 # define PGOUT(R1,R2) RRE_(0xB22F,R1,R2)
787 # define PC(D2,B2) S_(0xB218,B2,D2)
789 # define PR() E_(0x0101)
790 /* PROGRAM TRANSFER */
791 # define PT(R1,R2) RRE_(0xB228,R1,R2)
793 # define PALB() RRE_(0xB248,0,0)
795 # define PTLB() S_(0xB20D,0,0)
796 /* RESET REFERENCE BIT EXTENDED */
797 # define RRBE(R1,R2) RRE_(0xB22A,R1,R2)
799 # define RP(D2,B2) S_(0xB277,B2,D2)
800 /* SET ADDRESS SPACE CONTROL */
801 # define SAC(D2,B2) S_(0xB219,B2,D2)
802 /* SET ADDRESS SPACE CONTROL FAST */
803 # define SACF(D2,B2) S_(0xB279,B2,D2)
805 # define SCK(D2,B2) S_(0xB204,B2,D2)
806 /* SET CLOCK COMPARATOR */
807 # define SCKC(D2,B2) S_(0xB206,B2,D2)
808 /* SET CLOCK PROGRAMMABLE FIELD */
809 # define SCKPF() E_(0x0107)
811 # define SPT(D2,B2) S_(0xB208,B2,D2)
813 # define SPX(D2,B2) S_(0xB210,B2,D2)
814 /* SET PSW FROM ADDRESS */
815 # define SPKA(D2,B2) S_(0xB20A,B2,D2)
816 /* SET SECONDARY ASN */
817 # define SSAR(R1) RRE_(0xB225,R1,0)
818 /* SET STORAGE KEY EXTENDED */
819 # define SSKE(R1,R2) RRE_(0xB22B,R1,R2)
820 /* SET SYSTEM MASK */
821 # define SSM(D2,B2) SI_(0x80,0,B2,D2)
822 /* SIGNAL PROCESSOR */
823 # define SIGP(R1,R3,D2,B2) RS_(0xAE,R1,R3,B2,D2)
824 /* STORE CLOCK COMPARATOR */
825 # define STCKC(D2,B2) S_(0xB207,B2,D2)
827 # define STCTL(R1,R3,D2,B2) RS_(0xB6,R1,R3,B2,D2)
828 # define STCTG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x25)
829 /* STORE CPU ADDRESS */
830 # define STAP(D2,B2) S_(0xB212,B2,D2)
832 # define STIDP(D2,B2) S_(0xB202,B2,D2)
833 /* STORE CPU TIMER */
834 # define STPT(D2,B2) S_(0xB209,B2,D2)
835 /* STORE FACILITY LIST */
836 # define STFL(D2,B2) S_(0xB2B1,B2,D2)
838 # define STPX(D2,B2) S_(0xB211,B2,D2)
839 /* STORE REAL ADDRES */
840 # define STRAG(D1,B1,D2,B2) SSE_(0xE502,B1,D1,B2,D2)
841 /* STORE SYSTEM INFORMATION */
842 # define STSI(D2,B2) S_(0xB27D,B2,D2)
843 /* STORE THEN AND SYSTEM MASK */
844 # define STNSM(D1,B1,I2) SI_(0xAC,I2,B1,D1)
845 /* STORE THEN OR SYSTEM MASK */
846 # define STOSM(D1,B1,I2) SI_(0xAD,I2,B1,D1)
847 /* STORE USING REAL ADDRESS */
848 # define STURA(R1,R2) RRE_(0xB246,R1,R2)
849 # define STURG(R1,R2) RRE_(0xB925,R1,R2)
851 # define TAR(R1,R2) RRE_(0xB24C,R1,R2)
853 # define TB(R1,R2) RRE_(0xB22C,R1,R2)
854 /* TEST PROTECTION */
855 # define TPROT(D1,B1,D2,B2) SSE_(0xE501,B1,D1,B2,D2)
857 # define TRACE(R1,R3,D2,B2) RS_(0x99,R1,R3,B2,D2)
858 # define TRACG(R1,R3,D2,B2) RSY_(0xEB,R1,R3,B2,D2,0x0F)
860 # define TRAP2() E_(0x01FF)
861 # define TRAP4(D2,B2) S_(0xB2FF,B2,D2)
862 /****************************************************************
864 ****************************************************************/
865 /* CANCEL SUBCHANNEL */
866 # define XSCH() S_(0xB276,0,0)
867 /* CLEAR SUBCHANNEL */
868 # define CSCH() S_(0xB230,0,0)
869 /* HALT SUBCHANNEL */
870 # define HSCH() S_(0xB231,0,0)
871 /* MODIFY SUBCHANNEL */
872 # define MSCH(D2,B2) S_(0xB232,B2,D2)
873 /* RESET CHANNEL PATH */
874 # define RCHP() S_(0xB23B,0,0)
875 /* RESUME SUBCHANNEL */
876 # define RSCH() S_(0xB238,0,0)
877 /* SET ADDRESS LIMIT */
878 # define SAL() S_(0xB237,0,0)
879 /* SET CHANNEL MONITOR */
880 # define SCHM() S_(0xB23C,0,0)
881 /* START SUBCHANNEL */
882 # define SSCH(D2,B2) S_(0xB233,B2,D2)
883 /* STORE CHANNEL PATH STATUS */
884 # define STCPS(D2,B2) S_(0xB23A,B2,D2)
885 /* STORE CHANNEL REPORT WORD */
886 # define STCRW(D2,B2) S_(0xB239,B2,D2)
887 /* STORE SUBCHANNEL */
888 # define STSCH(D2,B2) S_(0xB234,B2,D2)
889 /* TEST PENDING INTERRUPTION */
890 # define TPI(D2,B2) S_(0xB236,B2,D2)
891 /* TEST SUBCHANNEL */
892 # define TSCH(D2,B2) S_(0xB235,B2,D2)
893 # define xdivr(r0,r1) _xdivr(_jit,r0,r1)
894 static jit_int32_t _xdivr(jit_state_t*,jit_int32_t,jit_int32_t);
895 # define xdivr_u(r0,r1) _xdivr_u(_jit,r0,r1)
896 static jit_int32_t _xdivr_u(jit_state_t*,jit_int32_t,jit_int32_t);
897 # define xdivi(r0,i0) _xdivi(_jit,r0,i0)
898 static jit_int32_t _xdivi(jit_state_t*,jit_int32_t,jit_word_t);
899 # define xdivi_u(r0,i0) _xdivi_u(_jit,r0,i0)
900 static jit_int32_t _xdivi_u(jit_state_t*,jit_int32_t,jit_word_t);
901 # define crr(cc,r0,r1,r2) _crr(_jit,cc,r0,r1,r2)
902 static void _crr(jit_state_t*,
903 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
904 # define cri(cc,r0,r1,i0) _cri(_jit,cc,r0,r1,i0)
905 static void _cri(jit_state_t*,
906 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
907 # define crr_u(cc,r0,r1,r2) _crr_u(_jit,cc,r0,r1,r2)
908 static void _crr_u(jit_state_t*,
909 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
910 # define cri_u(cc,r0,r1,i0) _cri_u(_jit,cc,r0,r1,i0)
911 static void _cri_u(jit_state_t*,
912 jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
913 # define brr(cc,i0,r0,r1) _brr(_jit,cc,i0,r0,r1)
914 static void _brr(jit_state_t*,jit_int32_t,
915 jit_word_t,jit_int32_t,jit_int32_t);
916 # define brr_p(cc,i0,r0,r1) _brr_p(_jit,cc,i0,r0,r1)
917 static jit_word_t _brr_p(jit_state_t*,jit_int32_t,
918 jit_word_t,jit_int32_t,jit_int32_t);
919 # define bri(cc,i0,r0,i1) _bri(_jit,cc,i0,r0,i1)
920 static void _bri(jit_state_t*,jit_int32_t,
921 jit_word_t,jit_int32_t,jit_word_t);
922 # define bri_p(cc,i0,r0,i1) _bri_p(_jit,cc,i0,r0,i1)
923 static jit_word_t _bri_p(jit_state_t*,jit_int32_t,
924 jit_word_t,jit_int32_t,jit_word_t);
925 # define brr_u(cc,i0,r0,r1) _brr_u(_jit,cc,i0,r0,r1)
926 static void _brr_u(jit_state_t*,jit_int32_t,
927 jit_word_t,jit_int32_t,jit_int32_t);
928 # define brr_u_p(cc,i0,r0,r1) _brr_u_p(_jit,cc,i0,r0,r1)
929 static jit_word_t _brr_u_p(jit_state_t*,jit_int32_t,
930 jit_word_t,jit_int32_t,jit_int32_t);
931 # define bri_u(cc,i0,r0,i1) _bri_u(_jit,cc,i0,r0,i1)
932 static void _bri_u(jit_state_t*,jit_int32_t,
933 jit_word_t,jit_int32_t,jit_word_t);
934 # define bri_u_p(cc,i0,r0,i1) _bri_u_p(_jit,cc,i0,r0,i1)
935 static jit_word_t _bri_u_p(jit_state_t*,jit_int32_t,
936 jit_word_t,jit_int32_t,jit_word_t);
937 # define baddr(c,s,i0,r0,r1) _baddr(_jit,c,s,i0,r0,r1)
938 static void _baddr(jit_state_t*,jit_int32_t,jit_bool_t,
939 jit_word_t,jit_int32_t,jit_int32_t);
940 # define baddr_p(c,s,i0,r0,r1) _baddr_p(_jit,c,s,i0,r0,r1)
941 static jit_word_t _baddr_p(jit_state_t*,jit_int32_t,jit_bool_t,
942 jit_word_t,jit_int32_t,jit_int32_t);
943 # define baddi(c,s,i0,r0,i1) _baddi(_jit,c,s,i0,r0,i1)
944 static void _baddi(jit_state_t*,jit_int32_t,jit_bool_t,
945 jit_word_t,jit_int32_t,jit_word_t);
946 # define baddi_p(c,s,i0,r0,i1) _baddi_p(_jit,c,s,i0,r0,i1)
947 static jit_word_t _baddi_p(jit_state_t*,jit_int32_t,jit_bool_t,
948 jit_word_t,jit_int32_t,jit_word_t);
949 # define bsubr(c,s,i0,r0,r1) _bsubr(_jit,c,s,i0,r0,r1)
950 static void _bsubr(jit_state_t*,jit_int32_t,jit_bool_t,
951 jit_word_t,jit_int32_t,jit_int32_t);
952 # define bsubr_p(c,s,i0,r0,r1) _bsubr_p(_jit,c,s,i0,r0,r1)
953 static jit_word_t _bsubr_p(jit_state_t*,jit_int32_t,jit_bool_t,
954 jit_word_t,jit_int32_t,jit_int32_t);
955 # define bsubi(c,s,i0,r0,i1) _bsubi(_jit,c,s,i0,r0,i1)
956 static void _bsubi(jit_state_t*,jit_int32_t,jit_bool_t,
957 jit_word_t,jit_int32_t,jit_word_t);
958 # define bsubi_p(c,s,i0,r0,i1) _bsubi_p(_jit,c,s,i0,r0,i1)
959 static jit_word_t _bsubi_p(jit_state_t*,jit_int32_t,jit_bool_t,
960 jit_word_t,jit_int32_t,jit_word_t);
961 # define bmxr(cc,i0,r0,r1) _bmxr(_jit,cc,i0,r0,r1)
962 static void _bmxr(jit_state_t*,jit_int32_t,
963 jit_word_t,jit_int32_t,jit_int32_t);
964 # define bmxr_p(cc,i0,r0,r1) _bmxr_p(_jit,cc,i0,r0,r1)
965 static jit_word_t _bmxr_p(jit_state_t*,jit_int32_t,
966 jit_word_t,jit_int32_t,jit_int32_t);
967 # define bmxi(cc,i0,r0,i1) _bmxi(_jit,cc,i0,r0,i1)
968 static void _bmxi(jit_state_t*,jit_int32_t,
969 jit_word_t,jit_int32_t,jit_word_t);
970 # define bmxi_p(cc,i0,r0,i1) _bmxi_p(_jit,cc,i0,r0,i1)
971 static jit_word_t _bmxi_p(jit_state_t*,jit_int32_t,
972 jit_word_t,jit_int32_t,jit_word_t);
973 # define movr(r0,r1) _movr(_jit,r0,r1)
974 static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
975 # define movi(r0,i0) _movi(_jit,r0,i0)
976 static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
977 # define movi_p(r0,i0) _movi_p(_jit,r0,i0)
978 static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
979 # define bswapr_us(r0, r1) _bswapr_us(_jit, r0, r1)
980 static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
981 # define bswapr_ui(r0, r1) _bswapr_ui(_jit, r0, r1)
982 static void _bswapr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
983 # if __WORDSIZE == 64
984 #define bswapr_ul(r0, r1) _bswapr_ul(_jit, r0, r1)
985 static void _bswapr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
987 # define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
988 static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
989 # define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
990 static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
991 # define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
992 static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
993 jit_int32_t,jit_int32_t,jit_word_t);
994 #define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
995 #define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
996 # define addr(r0,r1,r2) _addr(_jit,r0,r1,r2)
997 static void _addr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
998 # define addi(r0,r1,i0) _addi(_jit,r0,r1,i0)
999 static void _addi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1000 # define addcr(r0,r1,r2) _addcr(_jit,r0,r1,r2)
1001 static void _addcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1002 # define addci(r0,r1,i0) _addci(_jit,r0,r1,i0)
1003 static void _addci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1004 # define addxr(r0,r1,r2) _addxr(_jit,r0,r1,r2)
1005 static void _addxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1006 # define addxi(r0,r1,i0) _addxi(_jit,r0,r1,i0)
1007 static void _addxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1008 # define subr(r0,r1,r2) _subr(_jit,r0,r1,r2)
1009 static void _subr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1010 # define subi(r0,r1,i0) _subi(_jit,r0,r1,i0)
1011 static void _subi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1012 # define subcr(r0,r1,r2) _subcr(_jit,r0,r1,r2)
1013 static void _subcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1014 # define subci(r0,r1,i0) _subci(_jit,r0,r1,i0)
1015 static void _subci(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1016 # define subxr(r0,r1,r2) _subxr(_jit,r0,r1,r2)
1017 static void _subxr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1018 # define subxi(r0,r1,i0) _subxi(_jit,r0,r1,i0)
1019 static void _subxi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1020 # define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
1021 static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1022 # define mulr(r0,r1,r2) _mulr(_jit,r0,r1,r2)
1023 static void _mulr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1024 # define muli(r0,r1,i0) _muli(_jit,r0,r1,i0)
1025 static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1026 # define hmulr(r0, r1, r2) qmulr(JIT_NOREG, r0, r1, r2)
1027 # define hmuli(r0, r1, i0) qmuli(JIT_NOREG, r0, r1, i0)
1028 # define hmulr_u(r0, r1, r2) qmulr_u(JIT_NOREG, r0, r1, r2)
1029 # define hmuli_u(r0, r1, i0) qmuli_u(JIT_NOREG, r0, r1, i0)
1030 # define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
1031 static void _qmulr(jit_state_t*,jit_int32_t,
1032 jit_int32_t,jit_int32_t,jit_int32_t);
1033 # define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
1034 static void _qmuli(jit_state_t*,jit_int32_t,
1035 jit_int32_t,jit_int32_t,jit_word_t);
1036 # define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
1037 static void _qmulr_u(jit_state_t*,jit_int32_t,
1038 jit_int32_t,jit_int32_t,jit_int32_t);
1039 # define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
1040 static void _qmuli_u(jit_state_t*,jit_int32_t,
1041 jit_int32_t,jit_int32_t,jit_word_t);
1042 # define divr(r0,r1,r2) _divr(_jit,r0,r1,r2)
1043 static void _divr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1044 # define divi(r0,r1,i0) _divi(_jit,r0,r1,i0)
1045 static void _divi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1046 # define divr_u(r0,r1,r2) _divr_u(_jit,r0,r1,r2)
1047 static void _divr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1048 # define divi_u(r0,r1,i0) _divi_u(_jit,r0,r1,i0)
1049 static void _divi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1050 # define remr(r0,r1,r2) _remr(_jit,r0,r1,r2)
1051 static void _remr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1052 # define remi(r0,r1,i0) _remi(_jit,r0,r1,i0)
1053 static void _remi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1054 # define remr_u(r0,r1,r2) _remr_u(_jit,r0,r1,r2)
1055 static void _remr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1056 # define remi_u(r0,r1,i0) _remi_u(_jit,r0,r1,i0)
1057 static void _remi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1058 # define qdivr(r0,r1,r2,r3) _qdivr(_jit,r0,r1,r2,r3)
1059 static void _qdivr(jit_state_t*,jit_int32_t,
1060 jit_int32_t,jit_int32_t,jit_int32_t);
1061 # define qdivi(r0,r1,r2,i0) _qdivi(_jit,r0,r1,r2,i0)
1062 static void _qdivi(jit_state_t*,jit_int32_t,
1063 jit_int32_t,jit_int32_t,jit_word_t);
1064 # define qdivr_u(r0,r1,r2,r3) _qdivr_u(_jit,r0,r1,r2,r3)
1065 static void _qdivr_u(jit_state_t*,jit_int32_t,
1066 jit_int32_t,jit_int32_t,jit_int32_t);
1067 # define qdivi_u(r0,r1,r2,i0) _qdivi_u(_jit,r0,r1,r2,i0)
1068 static void _qdivi_u(jit_state_t*,jit_int32_t,
1069 jit_int32_t,jit_int32_t,jit_word_t);
1070 # if __WORDSIZE == 32
1071 # define lshr(r0,r1,r2) _lshr(_jit,r0,r1,r2)
1072 static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1073 # define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
1074 static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1075 # define rshr(r0,r1,r2) _rshr(_jit,r0,r1,r2)
1076 static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1077 # define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0);
1078 static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1079 # define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2)
1080 static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1081 # define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
1082 static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1084 # define lshr(r0,r1,r2) SLLG(r0,r1,0,r2)
1085 # define lshi(r0,r1,i0) SLLG(r0,r1,i0,0)
1086 # define rshr(r0,r1,r2) SRAG(r0,r1,0,r2)
1087 # define rshi(r0,r1,i0) SRAG(r0,r1,i0,0)
1088 # define rshr_u(r0,r1,r2) SRLG(r0,r1,0,r2)
1089 # define rshi_u(r0,r1,i0) SRLG(r0,r1,i0,0)
1091 # if __WORDSIZE == 32
1092 # define negr(r0,r1) LCR(r0,r1)
1093 # define lrotr(r0,r1,r2) RLL(r0,r1,0,r2)
1094 # define lroti(r0,r1,i0) RLL(r0,r1,i0,0)
1096 # define negr(r0,r1) LCGR(r0,r1)
1097 # define lrotr(r0,r1,r2) RLLG(r0,r1,0,r2)
1098 # define lroti(r0,r1,i0) RLLG(r0,r1,i0,0)
1100 # define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2)
1101 static void _rrotr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1102 # define rroti(r0,r1,i0) lroti(r0,r1,__WORDSIZE-i0)
1103 # define clor(r0, r1) _clor(_jit, r0, r1)
1104 static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
1105 # define clzr(r0, r1) _clzr(_jit, r0, r1)
1106 static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
1107 # define ctor(r0, r1) _ctor(_jit, r0, r1)
1108 static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
1109 # define ctzr(r0, r1) _ctzr(_jit, r0, r1)
1110 static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
1111 # define comr(r0,r1) _comr(_jit,r0,r1)
1112 static void _comr(jit_state_t*,jit_int32_t,jit_int32_t);
1113 # define andr(r0,r1,r2) _andr(_jit,r0,r1,r2)
1114 static void _andr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1115 # define andi(r0,r1,i0) _andi(_jit,r0,r1,i0)
1116 static void _andi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1117 # define orr(r0,r1,r2) _orr(_jit,r0,r1,r2)
1118 static void _orr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1119 # define ori(r0,r1,i0) _ori(_jit,r0,r1,i0)
1120 static void _ori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1121 # define xorr(r0,r1,r2) _xorr(_jit,r0,r1,r2)
1122 static void _xorr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1123 # define xori(r0,r1,i0) _xori(_jit,r0,r1,i0)
1124 static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1125 #define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1)
1126 static void _extr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
1127 #define extr_u(r0,r1,i0,i1) _extr_u(_jit,r0,r1,i0,i1)
1128 static void _extr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
1129 #define depr(r0,r1,i0,i1) _depr(_jit,r0,r1,i0,i1)
1130 static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
1131 # define extr_c(r0,r1) LGBR(r0,r1)
1132 # define extr_uc(r0,r1) LLGCR(r0,r1)
1133 # define extr_s(r0,r1) LGHR(r0,r1)
1134 # define extr_us(r0,r1) LLGHR(r0,r1)
1135 # if __WORDSIZE == 64
1136 # define extr_i(r0,r1) LGFR(r0,r1)
1137 # define extr_ui(r0,r1) LLGFR(r0,r1)
1139 # define ldr_c(r0,r1) LGB(r0,0,0,r1)
1140 # define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
1141 static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
1142 # define ldxr_c(r0,r1,r2) _ldxr_c(_jit,r0,r1,r2)
1143 static void _ldxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1144 # define ldxi_c(r0,r1,i0) _ldxi_c(_jit,r0,r1,i0)
1145 static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1146 # define ldr_uc(r0,r1) LLGC(r0,0,0,r1)
1147 # define ldi_uc(r0,i0) _ldi_uc(_jit,r0,i0)
1148 static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
1149 # define ldxr_uc(r0,r1,r2) _ldxr_uc(_jit,r0,r1,r2)
1150 static void _ldxr_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1151 # define ldxi_uc(r0,r1,i0) _ldxi_uc(_jit,r0,r1,i0)
1152 static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1153 # if __WORDSIZE == 32
1154 # define ldr_s(r0,r1) LH(r0,0,0,r1)
1156 # define ldr_s(r0,r1) LGH(r0,0,0,r1)
1158 # define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
1159 static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
1160 # define ldxr_s(r0,r1,r2) _ldxr_s(_jit,r0,r1,r2)
1161 static void _ldxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1162 # define ldxi_s(r0,r1,i0) _ldxi_s(_jit,r0,r1,i0)
1163 static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1164 # define ldr_us(r0,r1) LLGH(r0,0,0,r1)
1165 # define ldi_us(r0,i0) _ldi_us(_jit,r0,i0)
1166 static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
1167 # define ldxr_us(r0,r1,r2) _ldxr_us(_jit,r0,r1,r2)
1168 static void _ldxr_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1169 # define ldxi_us(r0,r1,i0) _ldxi_us(_jit,r0,r1,i0)
1170 static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1171 # if __WORDSIZE == 32
1172 # define ldr_i(r0,r1) LLGF(r0,0,0,r1)
1174 # define ldr_i(r0,r1) LGF(r0,0,0,r1)
1176 # define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
1177 static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
1178 # define ldxr_i(r0,r1,r2) _ldxr_i(_jit,r0,r1,r2)
1179 static void _ldxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1180 # define ldxi_i(r0,r1,i0) _ldxi_i(_jit,r0,r1,i0)
1181 static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1182 # if __WORDSIZE == 64
1183 # define ldr_ui(r0,r1) LLGF(r0,0,0,r1)
1184 # define ldi_ui(r0,i0) _ldi_ui(_jit,r0,i0)
1185 static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
1186 # define ldxr_ui(r0,r1,r2) _ldxr_ui(_jit,r0,r1,r2)
1187 static void _ldxr_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1188 # define ldxi_ui(r0,r1,i0) _ldxi_ui(_jit,r0,r1,i0)
1189 static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1190 # define ldr_l(r0,r1) LG(r0,0,0,r1)
1191 # define ldi_l(r0,i0) _ldi_l(_jit,r0,i0)
1192 static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
1193 # define ldxr_l(r0,r1,r2) _ldxr_l(_jit,r0,r1,r2)
1194 static void _ldxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1195 # define ldxi_l(r0,r1,i0) _ldxi_l(_jit,r0,r1,i0)
1196 static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1198 # define str_c(r0,r1) STC(r1,0,0,r0)
1199 # define sti_c(i0,r0) _sti_c(_jit,i0,r0)
1200 static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
1201 # define stxr_c(r0,r1,r2) _stxr_c(_jit,r0,r1,r2)
1202 static void _stxr_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1203 # define stxi_c(i0,r0,r1) _stxi_c(_jit,i0,r0,r1)
1204 static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1205 # define str_s(r0,r1) STH(r1,0,0,r0)
1206 # define sti_s(i0,r0) _sti_s(_jit,i0,r0)
1207 static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
1208 # define stxr_s(r0,r1,r2) _stxr_s(_jit,r0,r1,r2)
1209 static void _stxr_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1210 # define stxi_s(i0,r0,r1) _stxi_s(_jit,i0,r0,r1)
1211 static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1212 # define str_i(r0,r1) ST(r1,0,0,r0)
1213 # define sti_i(i0,r0) _sti_i(_jit,i0,r0)
1214 static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
1215 # define stxr_i(r0,r1,r2) _stxr_i(_jit,r0,r1,r2)
1216 static void _stxr_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1217 # define stxi_i(i0,r0,r1) _stxi_i(_jit,i0,r0,r1)
1218 static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1219 # if __WORDSIZE == 64
1220 # define str_l(r0,r1) STG(r1,0,0,r0)
1221 # define sti_l(i0,r0) _sti_l(_jit,i0,r0)
1222 static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
1223 # define stxr_l(r0,r1,r2) _stxr_l(_jit,r0,r1,r2)
1224 static void _stxr_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
1225 # define stxi_l(i0,r0,r1) _stxi_l(_jit,i0,r0,r1)
1226 static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1228 # define ltr(r0,r1,r2) crr(CC_L,r0,r1,r2)
1229 # define lti(r0,r1,i0) cri(CC_L,r0,r1,i0)
1230 # define ltr_u(r0,r1,r2) crr_u(CC_L,r0,r1,r2)
1231 # define lti_u(r0,r1,i0) cri_u(CC_L,r0,r1,i0)
1232 # define ler(r0,r1,r2) crr(CC_LE,r0,r1,r2)
1233 # define lei(r0,r1,i0) cri(CC_LE,r0,r1,i0)
1234 # define ler_u(r0,r1,r2) crr_u(CC_LE,r0,r1,r2)
1235 # define lei_u(r0,r1,i0) cri_u(CC_LE,r0,r1,i0)
1236 # define eqr(r0,r1,r2) crr(CC_E,r0,r1,r2)
1237 # define eqi(r0,r1,i0) cri(CC_E,r0,r1,i0)
1238 # define ger(r0,r1,r2) crr(CC_HE,r0,r1,r2)
1239 # define gei(r0,r1,i0) cri(CC_HE,r0,r1,i0)
1240 # define ger_u(r0,r1,r2) crr_u(CC_HE,r0,r1,r2)
1241 # define gei_u(r0,r1,i0) cri_u(CC_HE,r0,r1,i0)
1242 # define gtr(r0,r1,r2) crr(CC_H,r0,r1,r2)
1243 # define gti(r0,r1,i0) cri(CC_H,r0,r1,i0)
1244 # define gtr_u(r0,r1,r2) crr_u(CC_H,r0,r1,r2)
1245 # define gti_u(r0,r1,i0) cri_u(CC_H,r0,r1,i0)
1246 # define ner(r0,r1,r2) crr(CC_NE,r0,r1,r2)
1247 # define nei(r0,r1,i0) cri(CC_NE,r0,r1,i0)
1248 # define bltr(i0,r0,r1) brr(CC_L,i0,r0,r1)
1249 # define bltr_p(i0,r0,r1) brr_p(CC_L,i0,r0,r1)
1250 # define blti(i0,r0,i1) bri(CC_L,i0,r0,i1)
1251 # define blti_p(i0,r0,i1) bri_p(CC_L,i0,r0,i1)
1252 # define bltr_u(i0,r0,r1) brr_u(CC_L,i0,r0,r1)
1253 # define bltr_u_p(i0,r0,r1) brr_u_p(CC_L,i0,r0,r1)
1254 # define blti_u(i0,r0,i1) bri_u(CC_L,i0,r0,i1)
1255 # define blti_u_p(i0,r0,i1) bri_u_p(CC_L,i0,r0,i1)
1256 # define bler(i0,r0,r1) brr(CC_LE,i0,r0,r1)
1257 # define bler_p(i0,r0,r1) brr_p(CC_LE,i0,r0,r1)
1258 # define blei(i0,r0,i1) bri(CC_LE,i0,r0,i1)
1259 # define blei_p(i0,r0,i1) bri_p(CC_LE,i0,r0,i1)
1260 # define bler_u(i0,r0,r1) brr_u(CC_LE,i0,r0,r1)
1261 # define bler_u_p(i0,r0,r1) brr_u_p(CC_LE,i0,r0,r1)
1262 # define blei_u(i0,r0,i1) bri_u(CC_LE,i0,r0,i1)
1263 # define blei_u_p(i0,r0,i1) bri_u_p(CC_LE,i0,r0,i1)
1264 # define beqr(i0,r0,r1) brr(CC_E,i0,r0,r1)
1265 # define beqr_p(i0,r0,r1) brr_p(CC_E,i0,r0,r1)
1266 # define beqi(i0,r0,i1) bri(CC_E,i0,r0,i1)
1267 # define beqi_p(i0,r0,i1) bri_p(CC_E,i0,r0,i1)
1268 # define bger(i0,r0,r1) brr(CC_HE,i0,r0,r1)
1269 # define bger_p(i0,r0,r1) brr_p(CC_HE,i0,r0,r1)
1270 # define bgei(i0,r0,i1) bri(CC_HE,i0,r0,i1)
1271 # define bgei_p(i0,r0,i1) bri_p(CC_HE,i0,r0,i1)
1272 # define bger_u(i0,r0,r1) brr_u(CC_HE,i0,r0,r1)
1273 # define bger_u_p(i0,r0,r1) brr_u_p(CC_HE,i0,r0,r1)
1274 # define bgei_u(i0,r0,i1) bri_u(CC_HE,i0,r0,i1)
1275 # define bgei_u_p(i0,r0,i1) bri_u_p(CC_HE,i0,r0,i1)
1276 # define bgtr(i0,r0,r1) brr(CC_H,i0,r0,r1)
1277 # define bgtr_p(i0,r0,r1) brr_p(CC_H,i0,r0,r1)
1278 # define bgti(i0,r0,i1) bri(CC_H,i0,r0,i1)
1279 # define bgti_p(i0,r0,i1) bri_p(CC_H,i0,r0,i1)
1280 # define bgtr_u(i0,r0,r1) brr_u(CC_H,i0,r0,r1)
1281 # define bgtr_u_p(i0,r0,r1) brr_u_p(CC_H,i0,r0,r1)
1282 # define bgti_u(i0,r0,i1) bri_u(CC_H,i0,r0,i1)
1283 # define bgti_u_p(i0,r0,i1) bri_u_p(CC_H,i0,r0,i1)
1284 # define bner(i0,r0,r1) brr(CC_NE,i0,r0,r1)
1285 # define bner_p(i0,r0,r1) brr_p(CC_NE,i0,r0,r1)
1286 # define bnei(i0,r0,i1) bri(CC_NE,i0,r0,i1)
1287 # define bnei_p(i0,r0,i1) bri_p(CC_NE,i0,r0,i1)
1288 # define boaddr(i0,r0,r1) baddr(CC_O,1,i0,r0,r1)
1289 # define boaddr_p(i0,r0,r1) baddr_p(CC_O,1,i0,r0,r1)
1290 # define boaddi(i0,r0,i1) baddi(CC_O,1,i0,r0,i1)
1291 # define boaddi_p(i0,r0,i1) baddi_p(CC_O,1,i0,r0,i1)
1292 # define boaddr_u(i0,r0,r1) baddr(CC_NLE,0,i0,r0,r1)
1293 # define boaddr_u_p(i0,r0,r1) baddr_p(CC_NLE,0,i0,r0,r1)
1294 # define boaddi_u(i0,r0,i1) baddi(CC_NLE,0,i0,r0,i1)
1295 # define boaddi_u_p(i0,r0,i1) baddi_p(CC_NLE,0,i0,r0,i1)
1296 # define bxaddr(i0,r0,r1) baddr(CC_NO,1,i0,r0,r1)
1297 # define bxaddr_p(i0,r0,r1) baddr_p(CC_NO,1,i0,r0,r1)
1298 # define bxaddi(i0,r0,i1) baddi(CC_NO,1,i0,r0,i1)
1299 # define bxaddi_p(i0,r0,i1) baddi_p(CC_NO,1,i0,r0,i1)
1300 # define bxaddr_u(i0,r0,r1) baddr(CC_LE,0,i0,r0,r1)
1301 # define bxaddr_u_p(i0,r0,r1) baddr_p(CC_LE,0,i0,r0,r1)
1302 # define bxaddi_u(i0,r0,i1) baddi(CC_LE,0,i0,r0,i1)
1303 # define bxaddi_u_p(i0,r0,i1) baddi_p(CC_LE,0,i0,r0,i1)
1304 # define bosubr(i0,r0,r1) bsubr(CC_O,1,i0,r0,r1)
1305 # define bosubr_p(i0,r0,r1) bsubr_p(CC_O,1,i0,r0,r1)
1306 # define bosubi(i0,r0,i1) bsubi(CC_O,1,i0,r0,i1)
1307 # define bosubi_p(i0,r0,i1) bsubi_p(CC_O,1,i0,r0,i1)
1308 # define bosubr_u(i0,r0,r1) bsubr(CC_L,0,i0,r0,r1)
1309 # define bosubr_u_p(i0,r0,r1) bsubr_p(CC_L,0,i0,r0,r1)
1310 # define bosubi_u(i0,r0,i1) bsubi(CC_L,0,i0,r0,i1)
1311 # define bosubi_u_p(i0,r0,i1) bsubi_p(CC_L,0,i0,r0,i1)
1312 # define bxsubr(i0,r0,r1) bsubr(CC_NO,1,i0,r0,r1)
1313 # define bxsubr_p(i0,r0,r1) bsubr_p(CC_NO,1,i0,r0,r1)
1314 # define bxsubi(i0,r0,i1) bsubi(CC_NO,1,i0,r0,i1)
1315 # define bxsubi_p(i0,r0,i1) bsubi_p(CC_NO,1,i0,r0,i1)
1316 # define bxsubr_u(i0,r0,r1) bsubr(CC_NL,0,i0,r0,r1)
1317 # define bxsubr_u_p(i0,r0,r1) bsubr_p(CC_NL,0,i0,r0,r1)
1318 # define bxsubi_u(i0,r0,i1) bsubi(CC_NL,0,i0,r0,i1)
1319 # define bxsubi_u_p(i0,r0,i1) bsubi_p(CC_NL,0,i0,r0,i1)
1320 # define bmsr(i0,r0,r1) bmxr(CC_NE,i0,r0,r1)
1321 # define bmsr_p(i0,r0,r1) bmxr_p(CC_NE,i0,r0,r1)
1322 # define bmsi(i0,r0,i1) bmxi(CC_NE,i0,r0,i1)
1323 # define bmsi_p(i0,r0,i1) bmxi_p(CC_NE,i0,r0,i1)
1324 # define bmcr(i0,r0,r1) bmxr(CC_E,i0,r0,r1)
1325 # define bmcr_p(i0,r0,r1) bmxr_p(CC_E,i0,r0,r1)
1326 # define bmci(i0,r0,i1) bmxi(CC_E,i0,r0,i1)
1327 # define bmci_p(i0,r0,i1) bmxi_p(CC_E,i0,r0,i1)
1328 # define jmpr(r0) BR(r0)
1329 # define jmpi(i0,i1) _jmpi(_jit,i0,i1)
1330 static jit_word_t _jmpi(jit_state_t*,jit_word_t, jit_bool_t);
1331 # define jmpi_p(i0) _jmpi_p(_jit,i0)
1332 static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
1333 # define callr(r0) BALR(_R14_REGNO,r0)
1334 # define calli(i0,i1) _calli(_jit,i0,i1)
1335 static jit_word_t _calli(jit_state_t*,jit_word_t, jit_bool_t);
1336 # define calli_p(i0) _calli_p(_jit,i0)
1337 static jit_word_t _calli_p(jit_state_t*,jit_word_t);
1338 # define prolog(i0) _prolog(_jit,i0)
1339 static void _prolog(jit_state_t*,jit_node_t*);
1340 # define epilog(i0) _epilog(_jit,i0)
1341 static void _epilog(jit_state_t*,jit_node_t*);
1342 # define vastart(r0) _vastart(_jit, r0)
1343 static void _vastart(jit_state_t*, jit_int32_t);
1344 # define vaarg(r0, r1) _vaarg(_jit, r0, r1)
1345 static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
1346 # define patch_at(instr,label) _patch_at(_jit,instr,label)
1347 static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
1351 # define _us jit_uint16_t
1352 # define _ui jit_uint32_t
1354 _E(jit_state_t *_jit, _ui Op)
1363 assert(i0.b.op == Op);
1368 _I(jit_state_t *_jit, _ui Op, _ui I)
1379 assert(i0.b.op == Op);
1380 assert(i0.b.i == I);
1385 _RR(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1398 assert(i0.b.op == Op);
1399 assert(i0.b.r1 == R1);
1400 assert(i0.b.r2 == R2);
1405 _RRE(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1425 assert(i0.b.op == Op);
1426 assert(i1.b.r1 == R1);
1427 assert(i1.b.r2 == R2);
1433 _RRF(jit_state_t *_jit, _ui Op, _ui R3, _ui M4, _ui R1, _ui R2)
1455 assert(i0.b.op == Op);
1456 assert(i1.b.r3 == R3);
1457 assert(i1.b.m4 == M4);
1458 assert(i1.b.r1 == R1);
1459 assert(i1.b.r2 == R2);
1465 _RX(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2)
1487 assert(i0.b.op == Op);
1488 assert(i0.b.r1 == R1);
1489 assert(i0.b.x2 == X2);
1490 assert(i1.b.b2 == B2);
1491 assert(i1.b.d2 == D2);
1497 _RXE(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1528 assert(i0.b.op == Op);
1529 assert(i0.b.r1 == R1);
1530 assert(i0.b.x2 == X2);
1531 assert(i1.b.b2 == B2);
1532 assert(i1.b.d2 == D2);
1533 assert(i2.b.op == Op2);
1540 _RXF(jit_state_t *_jit, _ui Op, _ui R3, _ui X2, _ui B2, _ui D2, _ui R1, _ui Op2)
1573 assert(i0.b.op == Op);
1574 assert(i0.b.r3 == R3);
1575 assert(i0.b.x2 == X2);
1576 assert(i1.b.b2 == B2);
1577 assert(i1.b.d2 == D2);
1578 assert(i2.b.r1 == R1);
1579 assert(i2.b.op == Op2);
1586 _RXY(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1610 i0.s = i1.s = i2.s = 0;
1615 i1.b.dl = D2 & 0xfff;
1618 assert(i0.b.op == Op);
1619 assert(i0.b.r1 == R1);
1620 assert(i0.b.x2 == X2);
1621 assert(i1.b.b2 == B2);
1622 assert(i2.b.dh == D2 >> 12);
1623 assert(i2.b.op == Op2);
1630 _RS(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui B2, _ui D2)
1653 assert(i0.b.op == Op);
1654 assert(i0.b.r1 == R1);
1655 assert(i0.b.r3 == R3);
1656 assert(i1.b.b2 == B2);
1657 assert(i1.b.d2 == D2);
1663 _RSL(jit_state_t *_jit, _ui Op, _ui L1, _ui B1, _ui D1, _ui Op2)
1694 assert(i0.b.op == Op);
1695 assert(i0.b.l1 == L1);
1696 assert(i1.b.b1 == B1);
1697 assert(i1.b.d1 == D1);
1698 assert(i2.b.op == Op2);
1705 _RSI(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2)
1725 assert(i0.b.op == Op);
1726 assert(i0.b.r1 == R1);
1727 assert(i0.b.r3 == R3);
1728 assert(i1.b.i2 == I2);
1734 _RIE(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2, _ui Op2)
1763 assert(i0.b.op == Op);
1764 assert(i0.b.r1 == R1);
1765 assert(i0.b.r3 == R3);
1766 assert(i1.b.i2 == I2);
1767 assert(i2.b.op == Op2);
1774 _RIL(jit_state_t *_jit, _ui Op, _ui R1, _ui Op2, _ui I2)
1795 assert(i0.b.o1 == Op);
1796 assert(i0.b.r1 == R1);
1797 assert(i0.b.o2 == Op2);
1804 _SI(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1)
1824 assert(i0.b.op == Op);
1825 assert(i0.b.i2 == I2);
1826 assert(i1.b.b1 == B1);
1827 assert(i1.b.d1 == D1);
1833 _SIY(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1, _ui Op2)
1859 i1.b.dl = D1 & 0xfff;
1862 assert(i0.b.op == Op);
1863 assert(i0.b.i2 == I2);
1864 assert(i1.b.b1 == B1);
1865 assert(i2.b.dh == D1 >> 8);
1866 assert(i2.b.op == Op2);
1873 _S(jit_state_t *_jit, _ui Op, _ui B2, _ui D2)
1891 assert(i0.b.op == Op);
1892 assert(i1.b.b2 == B2);
1893 assert(i1.b.d2 == D2);
1899 _SS(jit_state_t *_jit, _ui Op, _ui LL, _ui LH, _ui B1, _ui D1, _ui B2, _ui D2)
1930 assert(i0.b.op == Op);
1931 assert(i0.b.ll == LL);
1932 assert(i0.b.lh == LH);
1933 assert(i1.b.b1 == B1);
1934 assert(i1.b.d1 == D1);
1935 assert(i2.b.b2 == B2);
1936 assert(i2.b.d2 == D2);
1943 _SSE(jit_state_t *_jit, _ui Op, _ui B1, _ui D1, _ui B2, _ui D2)
1970 assert(i0.b.op == Op);
1971 assert(i1.b.b1 == B1);
1972 assert(i1.b.d1 == D1);
1973 assert(i2.b.b2 == B2);
1974 assert(i2.b.d2 == D2);
1983 _nop(jit_state_t *_jit, jit_int32_t c)
1985 assert(c >= 0 && !(c & 1));
1993 _xdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1996 regno = jit_get_reg_pair();
1997 #if __WORDSIZE == 32
1998 movr(rn(regno), r0);
1999 SRDA(rn(regno), 32, 0);
2001 movr(rn(regno) + 1, r0);
2003 DIVREM_(rn(regno), r1);
2004 jit_unget_reg_pair(regno);
2009 _xdivr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2012 regno = jit_get_reg_pair();
2013 #if __WORDSIZE == 32
2014 movr(rn(regno), r0);
2015 SRDL(rn(regno), 32, 0);
2017 movr(rn(regno) + 1, r0);
2020 DIVREMU_(rn(regno), r1);
2021 jit_unget_reg_pair(regno);
2026 _xdivi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2028 jit_int32_t imm, regno;
2029 regno = jit_get_reg_pair();
2030 imm = jit_get_reg(jit_class_gpr);
2031 #if __WORDSIZE == 32
2032 movr(rn(regno), r0);
2033 SRDA(rn(regno), 32, 0);
2035 movr(rn(regno) + 1, r0);
2038 DIVREM_(rn(regno), rn(imm));
2040 jit_unget_reg_pair(regno);
2045 _xdivi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2047 /* cannot overlap because operand is 128-bit */
2048 jit_int32_t imm, regno;
2049 regno = jit_get_reg_pair();
2050 imm = jit_get_reg(jit_class_gpr);
2051 #if __WORDSIZE == 32
2052 movr(rn(regno), r0);
2053 SRDL(rn(regno), 32, 0);
2055 movr(rn(regno) + 1, r0);
2059 DIVREMU_(rn(regno), rn(imm));
2061 jit_unget_reg_pair(regno);
2066 _crr(jit_state_t *_jit, jit_int32_t cc,
2067 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2070 jit_int32_t reg, rg;
2071 if (r0 == r1 || r0 == r2) {
2072 reg = jit_get_reg(jit_class_gpr);
2082 patch_at(w, _jit->pc.w);
2083 if (r0 == r1 || r0 == r2) {
2090 _cri(jit_state_t *_jit, jit_int32_t cc,
2091 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2094 reg = jit_get_reg(jit_class_gpr);
2096 crr(cc, r0, r1, rn(reg));
2101 _crr_u(jit_state_t *_jit, jit_int32_t cc,
2102 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2105 jit_int32_t reg, rg;
2106 if (r0 == r1 || r0 == r2) {
2107 reg = jit_get_reg(jit_class_gpr);
2117 patch_at(w, _jit->pc.w);
2118 if (r0 == r1 || r0 == r2) {
2125 _cri_u(jit_state_t *_jit, jit_int32_t cc,
2126 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2129 reg = jit_get_reg(jit_class_gpr);
2131 crr_u(cc, r0, r1, rn(reg));
2136 _brr(jit_state_t *_jit, jit_int32_t cc,
2137 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2141 d = (i0 - _jit->pc.w) >> 1;
2151 _brr_p(jit_state_t *_jit, jit_int32_t cc,
2152 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2162 _bri(jit_state_t *_jit, jit_int32_t cc,
2163 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2166 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2168 brr(cc, i0, r0, rn(reg));
2173 _bri_p(jit_state_t *_jit, jit_int32_t cc,
2174 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2178 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2180 w = brr_p(cc, i0, r0, rn(reg));
2186 _brr_u(jit_state_t *_jit, jit_int32_t cc,
2187 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2191 d = (i0 - _jit->pc.w) >> 1;
2201 _brr_u_p(jit_state_t *_jit, jit_int32_t cc,
2202 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2212 _bri_u(jit_state_t *_jit, jit_int32_t cc,
2213 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2216 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2218 brr_u(cc, i0, r0, rn(reg));
2223 _bri_u_p(jit_state_t *_jit, jit_int32_t cc,
2224 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2228 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2230 w = brr_u_p(cc, i0, r0, rn(reg));
2236 _baddr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2237 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2240 if (s) addr(r0, r0, r1);
2241 else addcr(r0, r0, r1);
2242 d = (i0 - _jit->pc.w) >> 1;
2252 _baddi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2253 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2256 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2258 baddr(c, s, i0, r0, rn(reg));
2263 _baddr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2264 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2267 if (s) addr(r0, r0, r1);
2268 else addcr(r0, r0, r1);
2269 d = (i0 - _jit->pc.w) >> 1;
2276 _baddi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2277 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2281 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2283 w = baddr_p(c, s, i0, r0, rn(reg));
2289 _bsubr(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2290 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2293 if (s) subr(r0, r0, r1);
2294 else subcr(r0, r0, r1);
2295 d = (i0 - _jit->pc.w) >> 1;
2305 _bsubi(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2306 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2309 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2311 bsubr(c, s, i0, r0, rn(reg));
2316 _bsubr_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2317 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2320 if (s) subr(r0, r0, r1);
2321 else subcr(r0, r0, r1);
2322 d = (i0 - _jit->pc.w) >> 1;
2329 _bsubi_p(jit_state_t *_jit, jit_int32_t c, jit_bool_t s,
2330 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2334 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2336 w = bsubr_p(c, s, i0, r0, rn(reg));
2342 _bmxr(jit_state_t *_jit, jit_int32_t cc,
2343 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2347 reg = jit_get_reg(jit_class_gpr);
2349 andr(rn(reg), rn(reg), r1);
2350 TEST_(rn(reg), rn(reg));
2352 d = (i0 - _jit->pc.w) >> 1;
2362 _bmxr_p(jit_state_t *_jit, jit_int32_t cc,
2363 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2367 reg = jit_get_reg(jit_class_gpr);
2369 andr(rn(reg), rn(reg), r1);
2370 TEST_(rn(reg), rn(reg));
2378 _bmxi(jit_state_t *_jit, jit_int32_t cc,
2379 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2383 reg = jit_get_reg(jit_class_gpr);
2385 andr(rn(reg), rn(reg), r0);
2386 TEST_(rn(reg), rn(reg));
2388 d = (i0 - _jit->pc.w) >> 1;
2398 _bmxi_p(jit_state_t *_jit, jit_int32_t cc,
2399 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2403 reg = jit_get_reg(jit_class_gpr);
2405 andr(rn(reg), rn(reg), r0);
2406 TEST_(rn(reg), rn(reg));
2414 _movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2416 #if __WORDSIZE == 32
2426 _movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2429 #if __WORDSIZE == 64
2432 d = (i0 - _jit->pc.w) >> 1;
2434 #if __WORDSIZE == 32
2440 /* easy way of loading a large amount of 32 bit values and
2441 * usually address of constants */
2442 else if (!(i0 & 1) &&
2443 #if __WORDSIZE == 32
2451 #if __WORDSIZE == 32
2453 IILH(r0, x16((jit_uword_t)i0 >> 16));
2456 if (i0 & 0xffffL) bits |= 1;
2457 if (i0 & 0xffff0000L) bits |= 2;
2458 if (i0 & 0xffff00000000L) bits |= 4;
2459 if (i0 & 0xffff000000000000L) bits |= 8;
2460 if (bits != 15) LGHI(r0, 0);
2461 if (bits & 1) IILL(r0, x16(i0));
2462 if (bits & 2) IILH(r0, x16((jit_uword_t)i0 >> 16));
2463 if (bits & 4) IIHL(r0, x16((jit_uword_t)i0 >> 32));
2464 if (bits & 8) IIHH(r0, x16((jit_uword_t)i0 >> 48));
2470 _movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2474 #if __WORDSIZE == 32
2479 IILH(r0, x16((jit_uword_t)i0 >> 16));
2480 #if __WORDSIZE == 64
2481 IIHL(r0, x16((jit_uword_t)i0 >> 32));
2482 IIHH(r0, x16((jit_uword_t)i0 >> 48));
2488 _movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2491 w = beqi_p(_jit->pc.w, r2, 0);
2492 #if __WORDSIZE == 32
2497 patch_at(w, _jit->pc.w);
2501 _movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2504 w = bnei_p(_jit->pc.w, r2, 0);
2505 #if __WORDSIZE == 32
2510 patch_at(w, _jit->pc.w);
2514 _bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2522 _bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2525 # if __WORDSIZE == 64
2530 #if __WORDSIZE == 64
2532 _bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2539 _casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
2540 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
2542 jit_int32_t iscasi, r1_reg;
2543 if ((iscasi = (r1 == _NOREG))) {
2544 r1_reg = jit_get_reg_but_zero(0);
2548 /* Do not clobber r2 */
2550 /* The CS and CSG instructions below effectively do atomically:
2555 * So, we do not need to check cpu flags to know if it did work,
2556 * just compare if values are different.
2557 * Obviously it is somewhat of undefined behavior if old_value (r2)
2558 * and new_value (r3) have the same value, but should still work
2559 * as expected as a noop.
2561 # if __WORDSIZE == 32
2568 jit_unget_reg(r1_reg);
2572 _addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2583 _addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2586 if (r0 == r1 && s16_p(i0))
2588 #if __WORDSIZE == 64
2590 LAY(r0, x20(i0), 0, r1);
2593 reg = jit_get_reg(jit_class_gpr);
2595 addr(r0, r1, rn(reg));
2601 _addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2612 _addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2615 reg = jit_get_reg(jit_class_gpr);
2617 addcr(r0, r1, rn(reg));
2622 _addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2633 _addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2636 reg = jit_get_reg(jit_class_gpr);
2638 addxr(r0, r1, rn(reg));
2643 _subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2647 reg = jit_get_reg(jit_class_gpr);
2660 _subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2663 if (r0 == r1 && s16_p(-i0))
2664 ADDI_(r0, x16(-i0));
2665 #if __WORDSIZE == 64
2666 else if (s20_p(-i0))
2667 LAY(r0, x20(-i0), 0, r1);
2670 reg = jit_get_reg(jit_class_gpr);
2672 subr(r0, r1, rn(reg));
2678 _subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2682 reg = jit_get_reg(jit_class_gpr);
2695 _subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2698 reg = jit_get_reg(jit_class_gpr);
2700 subcr(r0, r1, rn(reg));
2705 _subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2709 reg = jit_get_reg(jit_class_gpr);
2722 _subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2725 reg = jit_get_reg(jit_class_gpr);
2727 subxr(r0, r1, rn(reg));
2732 _rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2739 _mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2750 _muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2758 reg = jit_get_reg(jit_class_gpr);
2760 mulr(r0, r1, rn(reg));
2766 _qmulr(jit_state_t *_jit,
2767 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2770 /* The only invalid condition is r0 == r1 */
2771 jit_int32_t t2, t3, s2, s3;
2772 if ((r0 != JIT_NOREG && r2 == r0) || r2 == r1) {
2773 s2 = jit_get_reg(jit_class_gpr);
2779 if ((r0 != JIT_NOREG && r3 == r0) || r3 == r1) {
2780 s3 = jit_get_reg(jit_class_gpr);
2786 qmulr_u(r0, r1, r2, r3);
2787 reg = jit_get_reg(jit_class_gpr);
2789 rshi(rn(reg), t2, 63);
2790 mulr(rn(reg), rn(reg), t3);
2791 addr(r1, r1, rn(reg));
2793 rshi(rn(reg), t3, 63);
2794 mulr(rn(reg), rn(reg), t2);
2795 addr(r1, r1, rn(reg));
2804 _qmuli(jit_state_t *_jit,
2805 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2808 reg = jit_get_reg(jit_class_gpr);
2810 qmulr(r0, r1, r2, rn(reg));
2815 _qmulr_u(jit_state_t *_jit,
2816 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2819 regno = jit_get_reg_pair();
2820 movr(rn(regno) + 1, r2);
2821 MULU_(rn(regno), r3);
2822 if (r0 != JIT_NOREG)
2823 movr(r0, rn(regno) + 1);
2824 movr(r1, rn(regno));
2825 jit_unget_reg_pair(regno);
2829 _qmuli_u(jit_state_t *_jit,
2830 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2833 regno = jit_get_reg_pair();
2834 movr(rn(regno) + 1, r2);
2835 movi(rn(regno), i0);
2836 MULU_(rn(regno), rn(regno));
2837 if (r0 != JIT_NOREG)
2838 movr(r0, rn(regno) + 1);
2839 movr(r1, rn(regno));
2840 jit_unget_reg_pair(regno);
2844 _divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2847 regno = xdivr(r1, r2);
2848 movr(r0, rn(regno) + 1);
2852 _divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2855 regno = xdivi(r1, i0);
2856 movr(r0, rn(regno) + 1);
2860 _divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2863 regno = xdivr_u(r1, r2);
2864 movr(r0, rn(regno) + 1);
2868 _divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2871 regno = xdivi_u(r1, i0);
2872 movr(r0, rn(regno) + 1);
2876 _remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2879 regno = xdivr(r1, r2);
2880 movr(r0, rn(regno));
2884 _remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2887 regno = xdivi(r1, i0);
2888 movr(r0, rn(regno));
2892 _remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2895 regno = xdivr_u(r1, r2);
2896 movr(r0, rn(regno));
2900 _remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2903 regno = xdivi_u(r1, i0);
2904 movr(r0, rn(regno));
2908 _qdivr(jit_state_t *_jit,
2909 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2912 regno = xdivr(r2, r3);
2913 movr(r0, rn(regno) + 1);
2914 movr(r1, rn(regno));
2918 _qdivi(jit_state_t *_jit,
2919 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2922 regno = xdivi(r2, i0);
2923 movr(r0, rn(regno) + 1);
2924 movr(r1, rn(regno));
2928 _qdivr_u(jit_state_t *_jit,
2929 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2932 regno = xdivr_u(r2, r3);
2933 movr(r0, rn(regno) + 1);
2934 movr(r1, rn(regno));
2938 _qdivi_u(jit_state_t *_jit,
2939 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2942 regno = xdivi_u(r2, i0);
2943 movr(r0, rn(regno) + 1);
2944 movr(r1, rn(regno));
2947 # if __WORDSIZE == 32
2949 _lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2953 reg = jit_get_reg_but_zero(0);
2956 SLL(r0, 0, rn(reg));
2957 jit_unget_reg_but_zero(reg);
2966 _lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2973 _rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2977 reg = jit_get_reg_but_zero(0);
2980 SRA(r0, 0, rn(reg));
2981 jit_unget_reg_but_zero(reg);
2990 _rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2997 _rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3001 reg = jit_get_reg_but_zero(0);
3004 SRL(r0, 0, rn(reg));
3005 jit_unget_reg_but_zero(reg);
3014 _rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3022 _rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3025 if (r0 != r1 && r0 != r2) {
3026 rsbi(r0, r2, __WORDSIZE);
3030 reg = jit_get_reg_but_zero(0);
3031 rsbi(rn(reg), r2, __WORDSIZE);
3032 lrotr(r0, r1, rn(reg));
3038 _clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3041 if (jit_cpu.flogr) {
3048 fallback_clo(r0, r1);
3053 _clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3056 if (jit_cpu.flogr) {
3058 #if __WORDSIZE == 32
3062 regno = jit_get_reg_pair();
3063 #if __WORDSIZE == 32
3064 SLLG(rn(regno), r1, 32, 0);
3066 movr(rn(regno), r1);
3068 FLOGR(rn(regno), rn(regno));
3069 movr(r0, rn(regno));
3070 #if __WORDSIZE == 32
3071 w = blei_p(_jit->pc.w, r0, 31);
3072 rshi(r0, r0, 1); /* r0 is 64 */
3073 patch_at(w, _jit->pc.w);
3075 jit_unget_reg_pair(regno);
3079 fallback_clz(r0, r1);
3084 _ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3087 if (jit_cpu.flogr) {
3094 fallback_cto(r0, r1);
3099 _ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3103 if (jit_cpu.flogr) {
3105 t0 = jit_get_reg_but_zero(0);
3106 t1 = jit_get_reg_but_zero(0);
3108 andr(rn(t0), rn(t0), r1);
3110 xori(rn(t1), r0, __WORDSIZE - 1);
3111 movnr(r0, rn(t1), rn(t0));
3117 fallback_ctz(r0, r1);
3122 _extr(jit_state_t *_jit,
3123 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3125 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3126 /* Big Endian always */
3127 i0 = __WORDSIZE - (i0 + i1);
3128 if (i1 == __WORDSIZE)
3131 if (__WORDSIZE - (i0 + i1)) {
3132 lshi(r0, r1, __WORDSIZE - (i0 + i1));
3133 rshi(r0, r0, __WORDSIZE - i1);
3136 rshi(r0, r1, __WORDSIZE - i1);
3141 _extr_u(jit_state_t *_jit,
3142 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3144 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3145 /* Big Endian always */
3146 i0 = __WORDSIZE - (i0 + i1);
3147 if (i1 == __WORDSIZE)
3152 andi(r0, r0, (1L << i1) - 1);
3157 _depr(jit_state_t *_jit,
3158 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3162 /* Big Endian always */
3163 i0 = __WORDSIZE - (i0 + i1);
3164 if (i1 == __WORDSIZE)
3167 mask = (1L << i1) - 1;
3168 t0 = jit_get_reg(jit_class_gpr);
3169 andi(rn(t0), r1, mask);
3171 lshi(rn(t0), rn(t0), i0);
3174 andi(r0, r0, ~mask);
3175 orr(r0, r0, rn(t0));
3181 _comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3184 reg = jit_get_reg(jit_class_gpr);
3192 _andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3203 _andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3207 NILH(r0, x16((jit_uword_t)i0 >> 16));
3208 #if __WORDSIZE == 64
3209 NIHL(r0, x16((jit_uword_t)i0 >> 32));
3210 NIHH(r0, x16((jit_uword_t)i0 >> 48));
3215 _orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3226 _ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3230 OILH(r0, x16((jit_uword_t)i0 >> 16));
3231 #if __WORDSIZE == 64
3232 OIHL(r0, x16((jit_uword_t)i0 >> 32));
3233 OIHH(r0, x16((jit_uword_t)i0 >> 48));
3238 _xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3249 _xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3252 reg = jit_get_reg(jit_class_gpr);
3254 xorr(r0, r1, rn(reg));
3259 _ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3266 _ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3280 _ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3284 #if __WORDSIZE == 32
3285 LB(r0, x20(i0), 0, r1);
3287 LGB(r0, x20(i0), 0, r1);
3290 else if (r0 != r1) {
3296 reg = jit_get_reg_but_zero(0);
3298 addr(rn(reg), rn(reg), r1);
3300 jit_unget_reg_but_zero(reg);
3305 _ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3312 _ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3326 _ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3330 LLGC(r0, x20(i0), 0, r1);
3331 else if (r0 != r1) {
3337 reg = jit_get_reg_but_zero(0);
3339 addr(rn(reg), rn(reg), r1);
3340 ldr_uc(r0, rn(reg));
3341 jit_unget_reg_but_zero(reg);
3346 _ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3353 _ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3367 _ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3370 #if __WORDSIZE == 32
3376 #if __WORDSIZE == 32
3377 LHY(r0, x20(i0), 0, r1);
3379 LGH(r0, x20(i0), 0, r1);
3382 else if (r0 != r1) {
3388 reg = jit_get_reg_but_zero(0);
3390 addr(rn(reg), rn(reg), r1);
3392 jit_unget_reg_but_zero(reg);
3397 _ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3404 _ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3418 _ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3422 LLGH(r0, x20(i0), 0, r1);
3423 else if (r0 != r1) {
3429 reg = jit_get_reg_but_zero(0);
3431 addr(rn(reg), rn(reg), r1);
3432 ldr_us(r0, rn(reg));
3433 jit_unget_reg_but_zero(reg);
3438 _ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3445 _ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3459 _ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3463 LGF(r0, x20(i0), 0, r1);
3464 else if (r0 != r1) {
3470 reg = jit_get_reg_but_zero(0);
3472 addr(rn(reg), rn(reg), r1);
3474 jit_unget_reg_but_zero(reg);
3478 #if __WORDSIZE == 64
3480 _ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3487 _ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3501 _ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3505 LLGF(r0, x20(i0), 0, r1);
3506 else if (r0 != r1) {
3512 reg = jit_get_reg_but_zero(0);
3514 addr(rn(reg), rn(reg), r1);
3515 ldr_ui(r0, rn(reg));
3516 jit_unget_reg_but_zero(reg);
3521 _ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3528 _ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3542 _ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3546 LG(r0, x20(i0), 0, r1);
3547 else if (r0 != r1) {
3553 reg = jit_get_reg_but_zero(0);
3555 addr(rn(reg), rn(reg), r1);
3557 jit_unget_reg_but_zero(reg);
3563 _sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3566 reg = jit_get_reg_but_zero(0);
3569 jit_unget_reg_but_zero(reg);
3573 _stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3576 reg = jit_get_reg_but_zero(0);
3578 addr(rn(reg), rn(reg), r1);
3580 jit_unget_reg_but_zero(reg);
3584 _stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3590 STCY(r1, x20(i0), 0, r0);
3592 reg = jit_get_reg_but_zero(0);
3593 addi(rn(reg), r0, i0);
3595 jit_unget_reg_but_zero(reg);
3600 _sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3603 reg = jit_get_reg_but_zero(0);
3606 jit_unget_reg_but_zero(reg);
3610 _stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3613 reg = jit_get_reg_but_zero(0);
3615 addr(rn(reg), rn(reg), r1);
3617 jit_unget_reg_but_zero(reg);
3621 _stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3627 STHY(r1, x20(i0), 0, r0);
3629 reg = jit_get_reg_but_zero(0);
3630 addi(rn(reg), r0, i0);
3632 jit_unget_reg_but_zero(reg);
3637 _sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3640 reg = jit_get_reg_but_zero(0);
3643 jit_unget_reg_but_zero(reg);
3647 _stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3650 reg = jit_get_reg_but_zero(0);
3652 addr(rn(reg), rn(reg), r1);
3654 jit_unget_reg_but_zero(reg);
3658 _stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3664 STY(r1, x20(i0), 0, r0);
3666 reg = jit_get_reg_but_zero(0);
3667 addi(rn(reg), r0, i0);
3669 jit_unget_reg_but_zero(reg);
3673 #if __WORDSIZE == 64
3675 _sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3678 reg = jit_get_reg_but_zero(0);
3681 jit_unget_reg_but_zero(reg);
3685 _stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3688 reg = jit_get_reg_but_zero(0);
3690 addr(rn(reg), rn(reg), r1);
3692 jit_unget_reg_but_zero(reg);
3696 _stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3700 STG(r1, x20(i0), 0, r0);
3702 reg = jit_get_reg_but_zero(0);
3703 addi(rn(reg), r0, i0);
3705 jit_unget_reg_but_zero(reg);
3711 _jmpi(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
3722 reg = jit_get_reg_but_zero(jit_class_nospill);
3725 jit_unget_reg_but_zero(reg);
3731 _jmpi_p(jit_state_t *_jit, jit_word_t i0)
3735 reg = jit_get_reg_but_zero(jit_class_nospill);
3736 w = movi_p(rn(reg), i0);
3738 jit_unget_reg_but_zero(reg);
3743 _calli(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
3750 BRAS(_R14_REGNO, x16(d));
3752 BRASL(_R14_REGNO, d);
3754 reg = jit_get_reg_but_zero(0);
3757 jit_unget_reg_but_zero(reg);
3763 _calli_p(jit_state_t *_jit, jit_word_t i0)
3767 reg = jit_get_reg_but_zero(0);
3768 w = movi_p(rn(reg), i0);
3770 jit_unget_reg_but_zero(reg);
3774 static jit_int32_t gprs[] = {
3776 _R6, _R7, _R8, _R9, _R10, _R11, _R12, _R13
3780 _prolog(jit_state_t *_jit, jit_node_t *i0)
3782 jit_int32_t regno, offset;
3783 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
3784 jit_int32_t frame = -_jitc->function->frame;
3785 assert(_jitc->function->self.aoff >= frame);
3786 if (_jitc->function->assume_frame)
3788 _jitc->function->self.aoff = frame;
3790 if (_jitc->function->allocar)
3791 _jitc->function->self.aoff &= -8;
3792 _jitc->function->stack = ((_jitc->function->self.alen -
3793 /* align stack at 8 bytes */
3794 _jitc->function->self.aoff) + 7) & -8;
3795 /* *IFF* a non variadic function,
3796 * Lightning does not reserve stack space for spilling arguments
3798 * S390x, as per gcc, has 8 stack slots for spilling arguments,
3799 * (%r6 is callee save) and uses an alloca like approach to save
3800 * callee save fpr registers.
3801 * Since argument registers are not saved in any lightning port,
3802 * use the 8 slots to spill any modified fpr register, and still
3803 * use the same stack frame logic as gcc.
3804 * Save at least %r13 to %r15, as %r13 is used as frame pointer.
3805 * *IFF* a variadic function, a "standard" stack frame, with
3806 * fpr registers saved in an alloca'ed area, is used.
3808 if ((_jitc->function->self.call & jit_call_varargs) &&
3809 jit_arg_reg_p(_jitc->function->vagp))
3810 regno = _jitc->function->vagp;
3812 for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3813 if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3817 #if __WORDSIZE == 32
3818 # define FP_OFFSET 64
3819 if (_jitc->function->self.call & jit_call_varargs)
3820 offset = regno * 4 + 8;
3822 offset = (regno - 4) * 4 + 32;
3823 STM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3825 # define FP_OFFSET 128
3826 if (_jitc->function->self.call & jit_call_varargs)
3827 offset = regno * 8 + 16;
3829 offset = (regno - 4) * 8 + 48;
3830 STMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3833 #define SPILL(R, O) \
3835 if (jit_regset_tstbit(&_jitc->function->regset, R)) \
3836 stxi_d(O, _R15_REGNO, rn(R)); \
3838 if (_jitc->function->self.call & jit_call_varargs) {
3839 for (regno = _jitc->function->vafp; jit_arg_f_reg_p(regno); ++regno)
3840 stxi_d(FP_OFFSET + regno * 8, _R15_REGNO, rn(_F0 - regno));
3841 SPILL(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3842 SPILL(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3843 SPILL(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3844 SPILL(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3845 SPILL(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3846 SPILL(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3847 SPILL(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3850 /* First 4 in low address */
3851 #if __WORDSIZE == 32
3856 /* gpr registers here */
3865 /* Last 3 in high address */
3872 movr(_R13_REGNO, _R15_REGNO);
3873 subi(_R15_REGNO, _R15_REGNO, stack_framesize + _jitc->function->stack);
3874 if (_jitc->function->allocar) {
3875 regno = jit_get_reg(jit_class_gpr);
3876 movi(rn(regno), _jitc->function->self.aoff);
3877 stxi_i(_jitc->function->aoffoff, _R13_REGNO, rn(regno));
3878 jit_unget_reg(regno);
3883 _epilog(jit_state_t *_jit, jit_node_t *i0)
3885 jit_int32_t regno, offset;
3886 if (_jitc->function->assume_frame)
3888 if ((_jitc->function->self.call & jit_call_varargs) &&
3889 jit_arg_reg_p(_jitc->function->vagp))
3890 regno = _jitc->function->vagp;
3892 for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3893 if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3897 #if __WORDSIZE == 32
3898 if (_jitc->function->self.call & jit_call_varargs)
3899 offset = regno * 4 + 8;
3901 offset = (regno - 4) * 4 + 32;
3903 if (_jitc->function->self.call & jit_call_varargs)
3904 offset = regno * 8 + 16;
3906 offset = (regno - 4) * 8 + 48;
3908 movr(_R15_REGNO, _R13_REGNO);
3910 #define LOAD(R, O) \
3912 if (jit_regset_tstbit(&_jitc->function->regset, R)) \
3913 ldxi_d(rn(R), _R15_REGNO, O); \
3915 if (_jitc->function->self.call & jit_call_varargs) {
3916 LOAD(_F8, _jitc->function->vaoff + offsetof(jit_va_list_t, f8));
3917 LOAD(_F9, _jitc->function->vaoff + offsetof(jit_va_list_t, f9));
3918 LOAD(_F10, _jitc->function->vaoff + offsetof(jit_va_list_t, f10));
3919 LOAD(_F11, _jitc->function->vaoff + offsetof(jit_va_list_t, f11));
3920 LOAD(_F12, _jitc->function->vaoff + offsetof(jit_va_list_t, f12));
3921 LOAD(_F13, _jitc->function->vaoff + offsetof(jit_va_list_t, f13));
3922 LOAD(_F14, _jitc->function->vaoff + offsetof(jit_va_list_t, f14));
3925 #if __WORDSIZE == 32
3944 #if __WORDSIZE == 32
3945 LM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3947 LMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3953 _vastart(jit_state_t *_jit, jit_int32_t r0)
3957 assert(_jitc->function->self.call & jit_call_varargs);
3959 /* Return jit_va_list_t in the register argument */
3960 addi(r0, _R13_REGNO, _jitc->function->vaoff);
3961 reg = jit_get_reg(jit_class_gpr);
3963 /* Initialize gp offset in the save area. */
3964 movi(rn(reg), _jitc->function->vagp);
3965 stxi(offsetof(jit_va_list_t, gpoff), r0, rn(reg));
3967 /* Initialize fp offset in the save area. */
3968 movi(rn(reg), _jitc->function->vafp);
3969 stxi(offsetof(jit_va_list_t, fpoff), r0, rn(reg));
3971 /* Initialize overflow pointer to the first stack argument. */
3972 addi(rn(reg), _R13_REGNO, _jitc->function->self.size);
3973 stxi(offsetof(jit_va_list_t, over), r0, rn(reg));
3975 /* Initialize register save area pointer. */
3976 stxi(offsetof(jit_va_list_t, save), r0, _R13_REGNO);
3982 _vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3990 assert(_jitc->function->self.call & jit_call_varargs);
3992 rg0 = jit_get_reg_but_zero(0);
3993 rg1 = jit_get_reg_but_zero(0);
3995 /* Load the gp offset in save area in the first temporary. */
3996 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, gpoff));
3998 /* Jump over if there are no remaining arguments in the save area. */
3999 ge_code = bgei_p(_jit->pc.w, rn(rg0), 5);
4001 /* Load the save area pointer in the second temporary. */
4002 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
4005 rg2 = jit_get_reg_but_zero(0);
4006 lshi(rn(rg2), rn(rg0),
4007 #if __WORDSIZE == 32
4013 /* Add offset to saved area. */
4014 addi(rn(rg2), rn(rg2), 2 * sizeof(jit_word_t));
4016 /* Load the vararg argument in the first argument. */
4017 ldxr(r0, rn(rg1), rn(rg2));
4018 jit_unget_reg_but_zero(rg2);
4020 /* Update the gp offset. */
4021 addi(rn(rg0), rn(rg0), 1);
4022 stxi(offsetof(jit_va_list_t, gpoff), r1, rn(rg0));
4024 /* Will only need one temporary register below. */
4025 jit_unget_reg_but_zero(rg1);
4027 /* Jump over overflow code. */
4028 lt_code = jmpi_p(_jit->pc.w);
4030 /* Where to land if argument is in overflow area. */
4031 patch_at(ge_code, _jit->pc.w);
4033 /* Load overflow pointer. */
4034 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
4036 /* Load argument. */
4039 /* Update overflow pointer. */
4040 addi(rn(rg0), rn(rg0), sizeof(jit_word_t));
4041 stxi(offsetof(jit_va_list_t, over), r1, rn(rg0));
4043 /* Where to land if argument is in save area. */
4044 patch_at(lt_code, _jit->pc.w);
4046 jit_unget_reg_but_zero(rg0);
4050 _patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
4060 jit_uint16_t op : 8;
4061 jit_uint16_t r1 : 4;
4062 jit_uint16_t r3 : 4;
4074 jit_uint32_t ih : 16;
4075 jit_uint32_t il : 16;
4082 #if __WORDSIZE == 32
4083 0xA7 && i0.b.r3 == 8
4088 #if __WORDSIZE == 64
4089 assert(i0.b.r3 == 3);
4091 i1.b.i2 = (jit_uword_t)label;
4094 assert(i0.b.op == 0xA5 && i0.b.r3 == 2);
4095 i1.b.i2 = (jit_uword_t)label >> 16;
4097 #if __WORDSIZE == 64
4099 assert(i0.b.op == 0xA5 && i0.b.r3 == 1);
4100 i1.b.i2 = (jit_uword_t)label >> 32;
4103 assert(i0.b.op == 0xA5 && i0.b.r3 == 0);
4104 i1.b.i2 = (jit_uword_t)label >> 48;
4109 else if (i0.b.op == 0xA7) {
4110 assert(i0.b.r3 == 0x4 || i0.b.r3 == 0x5);
4111 d = (label - instr) >> 1;
4117 else if (i0.b.op == 0xC0) {
4118 assert(i0.b.r3 == 0x4 || i0.b.r3 == 0x5);
4119 d = (label - instr) >> 1;