notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
release r24
[pcsx_rearmed.git] / deps / lightning / lib / jit_s390-cpu.c
CommitLineData
4a71579b 1/*
79bfeef6 2 * Copyright (C) 2013-2023 Free Software Foundation, Inc.
4a71579b
PC		 3 *
4 * This file is part of GNU lightning.
5 *
6 * GNU lightning is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU Lesser General Public License as published
8 * by the Free Software Foundation; either version 3, or (at your option)
9 * any later version.
10 *
11 * GNU lightning is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
14 * License for more details.
15 *
16 * Authors:
17 * Paulo Cesar Pereira de Andrade
18 */
19
20#if PROTO
21# if __WORDSIZE == 32
22# define ldr(r0,r1) ldr_i(r0,r1)
ba86ff93 23# define ldi(r0,i0) ldi_i(r0,i0)
4a71579b
PC		 24# define ldxr(r0,r1,r2) ldxr_i(r0,r1,r2)
25# define ldxi(r0,r1,i0) ldxi_i(r0,r1,i0)
ba86ff93
PC		 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)
4a71579b
PC		 29# define stxi(i0,r0,r1) stxi_i(i0,r0,r1)
30# else
31# define ldr(r0,r1) ldr_l(r0,r1)
ba86ff93 32# define ldi(r0,i0) ldi_l(r0,i0)
4a71579b
PC		 33# define ldxr(r0,r1,r2) ldxr_l(r0,r1,r2)
34# define ldxi(r0,r1,i0) ldxi_l(r0,r1,i0)
ba86ff93
PC		 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)
4a71579b
PC		 38# define stxi(i0,r0,r1) stxi_l(i0,r0,r1)
39# endif
40# define is(i) *_jit->pc.us++ = i
41# if __WORDSIZE == 32
42# define stack_framesize 96
43# else
44# define stack_framesize 160
45# endif
46# define _R0_REGNO 0
47# define _R1_REGNO 1
48# define _R7_REGNO 7
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)
58# if __WORDSIZE == 32
59# define s32_p(i0) 1
60# else
61# define s32_p(i0) \
62 ((i0) >= -2147483648L && (i0) < 2147483647L)
63# endif
64
65/*
66 Condition Code Instruction (Mask) Bit Mask Value
67 0 8 8
68 1 9 4
69 2 10 2
70 3 11 1
71
72AGR:
73 0 Zero
74 1 < zero
75 2 > zero
76 3 Overflow
77--
781 -> overflow CC_O
7914 -> no overflow CC_NO
80
81ALGR:
82 0 Zero, no carry
83 1 Not zero, no carry
84 2 Zero, carry
85 3 Not zero, carry
86--
872|1 -> carry CC_NLE
888|4 -> no carry CC_LE
89
90SGR:
91 0 Zero
92 1 < zero
93 2 > zero
94 3 Overflow
95--
961 -> overflow CC_O
9714 -> no overflow CC_NO
98
99SLGR:
100 0 --
101 1 Not zero, borrow
102 2 Zero, no borrow
103 3 Not zero, no borrow
104--
1054 -> borrow CC_L
10611 -> no borrow CC_NL
107 */
108
109# define CC_NV 0x0
110# define CC_O 0x1
111# define CC_H 0x2
112# define CC_NLE 0x3
113# define CC_L 0x4
114# define CC_NHE 0x5
115# define CC_LH 0x6
116# define CC_NE 0x7
117# define CC_E 0x8
118# define CC_NLH 0x9
119# define CC_HE 0xA
120# define CC_NL 0xB
121# define CC_LE 0xC
122# define CC_NH 0xD
123# define CC_NO 0xE
124# define CC_AL 0xF
125# define _us jit_uint16_t
126# define _ui jit_uint32_t
127# define E_(Op) _E(_jit,Op)
128static void _E(jit_state_t*,_ui);
129# define I_(Op,I) _I(_jit,Op,I)
130static void _I(jit_state_t*,_ui,_ui);
131# define RR_(Op,R1,R2) _RR(_jit,Op,R1,R2)
132static void _RR(jit_state_t*,_ui,_ui,_ui);
133# define RRE_(Op,R1,R2) _RRE(_jit,Op,R1,R2)
134static void _RRE(jit_state_t*,_ui,_ui,_ui);
135# define RRF_(Op,R3,M4,R1,R2) _RRF(_jit,Op,R3,M4,R1,R2)
136static 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)
138static 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)
140static 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)
142static 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)
144static 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)
146static 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)
149static void _RSL(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
150# define RSI_(Op,R1,R3,I2) _RSI(_jit,Op,R1,R3,I2)
151static 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)
154static void _RIE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
155# define RIL_(Op,R1,Op2,I2) _RIL(_jit,Op,R1,Op2,I2)
156static void _RIL(jit_state_t*,_ui,_ui,_ui,_ui);
157# define SI_(Op,I2,B1,D1) _SI(_jit,Op,I2,B1,D1)
158static void _SI(jit_state_t*,_ui,_ui,_ui,_ui);
159# define SIY_(Op,I2,B1,D1,Op2) _SIY(_jit,Op,I2,B1,D1,Op2)
160static void _SIY(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
161# define S_(Op,B2,D2) _S(_jit,Op,B2,D2)
162static 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)
165static 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)
167static void _SSE(jit_state_t*,_ui,_ui,_ui,_ui,_ui);
168# undef _us
169# undef _ui
170# define nop(c) _nop(_jit,c)
171static 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)
191# else
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)
210# endif
211/****************************************************************
212 * General Instructions *
213 ****************************************************************/
214/* ADD */
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)
222/* ADD HALFWORD */
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)
228/* ADD LOGICAL */
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)
241/* AND */
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)
250/* AND IMMEDIATE */
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)
300/* CHECKSUM */
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)
306/* COMPARE */
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)
375/* COPY ACCESS */
376# define CPYA(R1,R2) RRE_(0xB24D,R1,R2)
377/* DIVIDE */
378# define DR(R1,R2) RR_(0x1D,R1,R2)
379# define D(R1,D2,X2,B2) RX_(0x5D,R1,X2,B2,D2)
380/* DIVIDE LOGICAL */
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)
385/* DIVIDE SINGLE */
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)
390/* EXCLUSIVE OR */
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)
399/* EXECUTE */
400# define EX(R1,D2,X2,B2) RX_(0x44,R1,X2,B2,D2)
401/* EXTRACT ACCESS */
402# define EAR(R1,R2) RRE_(0xB24F,R1,R2)
403/* EXTRACT PSW */
404# define EPSW(R1,R2) RRE_(0xB98D,R1,R2)
79bfeef6
PC		 405/* FIND LEFTMOST ONE */
406# define FLOGR(R1,R2) RRE_(0xB983,R1,R2)
4a71579b
PC		 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)
421/* LOAD */
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)
432/* LOAD ADDRESS */
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)
439/* LOAD AND TEST */
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)
443/* LOAD BYTE */
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)
451/* LOAD HALFWORD */
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)
459/* LOAD LOGICAL */
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)
476/* LOAD MULTIPLE */
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)
484/* LOAD NEGATIVE */
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)
490/* LOAD POSITIVE */
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)
494/* LOAD REVERSED */
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)
500/* MONITOR CALL */
501# define MC(D1,B1,I2) SI_(0xAF,I2,B1,D1)
502/* MOVE */
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)
506/* MOVE INVERSE */
507# define MVCIN(D1,L,B1,D2,B2) SSL_(0xE8,L,B1,D1,B2,D2)
508/* MOVE LONG */
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)
514/* MOVE NUMERICS */
515# define MVN(D1,L,B1,D2,B2) SSL_(0xD1,L,B1,D1,B2,D2)
516/* MOVE STRING */
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)
520/* MOVE ZONES */
521# define MVZ(D1,L,B1,D2,B2) SSL_(0xD3,L,B1,D1,B2,D2)
522/* MULTIPLY */
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)
543/* OR */
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)
552/* OR IMMEDIATE */
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)
557/* PACK */
558# define PACK(D1,L1,B1,D2,L2,B2) SS_(0xF2,L1,L2,B1,D1,B2,D2)
559/* PACK ASCII */
560# define PKA(D1,B1,D2,L2,B2) SSL_(0xE9,L2,B1,D1,B2,D2)
561/* PACK UNICODE */
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)
568/* SEARCH STRING */
569# define SRST(R1,R2) RRE_(0xB25E,R1,R2)
570/* SET ACCESS */
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)
598/* STORE */
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)
612/* STORE CLOCK */
613# define STCK(D2,B2) S_(0xB205,B2,D2)
614/* STORE CLOCK EXTENDED */
615# define STCKE(D2,B2) S_(0xB278,B2,D2)
616/* STORE HALFWORD */
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)
619/* STORE MULTIPLE */
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)
627/* STORE REVERSED */
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)
631/* SUBTRACT */
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)
659/* TEST AND SET */
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)
670/* TRANSLATE */
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)
684/* UNPACK */
685# define UNPK(D1,L1,B1,D2,L2,B2) SS_(0xF3,L1,L2,B1,D1,B2,D2)
686/* UNPACK ASCII */
687# define UNPKA(D1,L1,B1,D2,L2,B2) SS_(0xEA,L1,L2,B1,D1,B2,D2)
688/* UNPACK UNICODE */
689# define UNPKU(D1,L1,B1,D2,L2,B2) SS_(0xE2,L1,L2,B1,D1,B2,D2)
690/* UPDATE TREE */
691# define UPT() E_(0x0102)
692/****************************************************************
693 * Decimal Instructions *
694 ****************************************************************/
695/* ADD DECIMAL */
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)
699/* DIVIDE DECIMAL */
700# define DP(D1,L1,B1,D2,L2,B2) SS_(0xFD,L1,L2,B1,D1,B2,D2)
701/* EDIT */
702# define ED(D1,L,B1,D2,B2) SSL_(0xDE,L,B1,D1,B2,D2)
703/* EDIT AND MARK */
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)
711/* TEST DECIMAL */
712# define TP(D1,L1,B1) RSL_(0xEB,L1,B1,D1,0xC0)
713/* ZERO AND ADD */
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)
727/* DIAGNOSE */
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)
742/* INSERT PSW KEY */
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)
754/* LOAD CONTROL */
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)
757/* LOAD PSW */
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)
770/* MOVE PAGE */
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)
778/* MOVE WITH KEY */
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)
782/* PAGE IN */
783# define PGIN(R1,R2) RRE_(0xB22E,R1,R2)
784/* PAGE OUT */
785# define PGOUT(R1,R2) RRE_(0xB22F,R1,R2)
786/* PROGRAM CALL */
787# define PC(D2,B2) S_(0xB218,B2,D2)
788/* PROGRAM RETURN */
789# define PR() E_(0x0101)
790/* PROGRAM TRANSFER */
791# define PT(R1,R2) RRE_(0xB228,R1,R2)
792/* PURGE ALB */
793# define PALB() RRE_(0xB248,0,0)
794/* PURGE TLB */
795# define PTLB() S_(0xB20D,0,0)
796/* RESET REFERENCE BIT EXTENDED */
797# define RRBE(R1,R2) RRE_(0xB22A,R1,R2)
798/* RESUME PROGRAM */
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)
804/* SET CLOCK */
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)
810/* SET CPU TIMER */
811# define SPT(D2,B2) S_(0xB208,B2,D2)
812/* SET PREFIX */
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)
826/* STORE CONTROL */
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)
831/* STORE CPU ID */
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)
837/* STORE PREFIX */
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)
850/* TEST ACCESS */
851# define TAR(R1,R2) RRE_(0xB24C,R1,R2)
852/* TEST BLOCK */
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)
856/* TRACE */
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)
859/* TRAP */
860# define TRAP2() E_(0x01FF)
861# define TRAP4(D2,B2) S_(0xB2FF,B2,D2)
862/****************************************************************
863 * I/O Instructions *
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)
894static jit_int32_t _xdivr(jit_state_t*,jit_int32_t,jit_int32_t);
895# define xdivr_u(r0,r1) _xdivr_u(_jit,r0,r1)
896static jit_int32_t _xdivr_u(jit_state_t*,jit_int32_t,jit_int32_t);
897# define xdivi(r0,i0) _xdivi(_jit,r0,i0)
898static jit_int32_t _xdivi(jit_state_t*,jit_int32_t,jit_word_t);
899# define xdivi_u(r0,i0) _xdivi_u(_jit,r0,i0)
900static 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)
902static 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)
905static 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)
908static 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)
911static 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)
914static 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)
917static 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)
920static 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)
923static 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)
926static 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)
929static 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)
932static 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)
935static 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)
938static 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)
941static 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)
944static 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)
947static 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)
950static 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)
953static 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)
956static 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)
959static 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)
962static 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)
965static 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)
968static 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)
971static 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)
974static void _movr(jit_state_t*,jit_int32_t,jit_int32_t);
975# define movi(r0,i0) _movi(_jit,r0,i0)
976static void _movi(jit_state_t*,jit_int32_t,jit_word_t);
977# define movi_p(r0,i0) _movi_p(_jit,r0,i0)
978static jit_word_t _movi_p(jit_state_t*,jit_int32_t,jit_word_t);
79bfeef6
PC		 979# define bswapr_us(r0, r1) _bswapr_us(_jit, r0, r1)
980static void _bswapr_us(jit_state_t*,jit_int32_t,jit_int32_t);
981# define bswapr_ui(r0, r1) _bswapr_ui(_jit, r0, r1)
982static 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)
985static void _bswapr_ul(jit_state_t*,jit_int32_t,jit_int32_t);
986#endif
40a44dcb
PC		 987# define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
988static 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)
990static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
ba3814c1
PC		 991# define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
992static 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)
4a71579b
PC		 996# define addr(r0,r1,r2) _addr(_jit,r0,r1,r2)
997static 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)
999static 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)
1001static 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)
1003static 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)
1005static 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)
1007static 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)
1009static 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)
1011static 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)
1013static 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)
1015static 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)
1017static 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)
1019static 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)
1021static 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)
1023static 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)
1025static void _muli(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
ba86ff93
PC		 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)
4a71579b
PC		 1030# define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
1031static 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)
1034static 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)
1037static 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)
1040static 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)
1043static 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)
1045static 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)
1047static 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)
1049static 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)
1051static 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)
1053static 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)
1055static 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)
1057static 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)
1059static 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)
1062static 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)
1065static 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)
1068static 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)
1072static void _lshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
79bfeef6 1073# define lshi(r0,r1,i0) _lshi(_jit,r0,r1,i0)
4a71579b 1074static void _lshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
4a71579b
PC		 1075# define rshr(r0,r1,r2) _rshr(_jit,r0,r1,r2)
1076static void _rshr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
79bfeef6 1077# define rshi(r0,r1,i0) _rshi(_jit,r0,r1,i0);
4a71579b 1078static void _rshi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
4a71579b
PC		 1079# define rshr_u(r0,r1,r2) _rshr_u(_jit,r0,r1,r2)
1080static void _rshr_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
79bfeef6
PC		 1081# define rshi_u(r0,r1,i0) _rshi_u(_jit,r0,r1,i0)
1082static void _rshi_u(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
4a71579b 1083# else
79bfeef6
PC		 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)
4a71579b 1088# define rshr_u(r0,r1,r2) SRLG(r0,r1,0,r2)
79bfeef6 1089# define rshi_u(r0,r1,i0) SRLG(r0,r1,i0,0)
4a71579b 1090# endif
4a71579b
PC		 1091# if __WORDSIZE == 32
1092# define negr(r0,r1) LCR(r0,r1)
ba86ff93
PC		 1093# define lrotr(r0,r1,r2) RLL(r0,r1,0,r2)
1094# define lroti(r0,r1,i0) RLL(r0,r1,i0,0)
4a71579b
PC		 1095# else
1096# define negr(r0,r1) LCGR(r0,r1)
ba86ff93
PC		 1097# define lrotr(r0,r1,r2) RLLG(r0,r1,0,r2)
1098# define lroti(r0,r1,i0) RLLG(r0,r1,i0,0)
4a71579b 1099# endif
ba86ff93
PC		 1100# define rrotr(r0,r1,r2) _rrotr(_jit,r0,r1,r2)
1101static 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)
79bfeef6
PC		 1103# define clor(r0, r1) _clor(_jit, r0, r1)
1104static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
1105# define clzr(r0, r1) _clzr(_jit, r0, r1)
1106static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
1107# define ctor(r0, r1) _ctor(_jit, r0, r1)
1108static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
1109# define ctzr(r0, r1) _ctzr(_jit, r0, r1)
1110static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
4a71579b
PC		 1111# define comr(r0,r1) _comr(_jit,r0,r1)
1112static void _comr(jit_state_t*,jit_int32_t,jit_int32_t);
1113# define andr(r0,r1,r2) _andr(_jit,r0,r1,r2)
1114static 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)
1116static 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)
1118static 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)
1120static 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)
1122static 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)
1124static void _xori(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
ba86ff93
PC		 1125#define extr(r0,r1,i0,i1) _extr(_jit,r0,r1,i0,i1)
1126static 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)
1128static 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)
1130static void _depr(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t,jit_word_t);
4a71579b
PC		 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)
1138# endif
1139# define ldr_c(r0,r1) LGB(r0,0,0,r1)
1140# define ldi_c(r0,i0) _ldi_c(_jit,r0,i0)
1141static 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)
1143static 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)
1145static 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)
1148static 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)
1150static 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)
1152static 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)
1155# else
1156# define ldr_s(r0,r1) LGH(r0,0,0,r1)
1157# endif
1158# define ldi_s(r0,i0) _ldi_s(_jit,r0,i0)
1159static 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)
1161static 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)
1163static 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)
1166static 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)
1168static 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)
1170static 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)
1173# else
1174# define ldr_i(r0,r1) LGF(r0,0,0,r1)
1175# endif
1176# define ldi_i(r0,i0) _ldi_i(_jit,r0,i0)
1177static 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)
1179static 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)
1181static 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)
1185static 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)
1187static 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)
1189static 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)
1192static 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)
1194static 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)
1196static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
1197# endif
1198# define str_c(r0,r1) STC(r1,0,0,r0)
1199# define sti_c(i0,r0) _sti_c(_jit,i0,r0)
1200static 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)
1202static 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)
1204static 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)
1207static 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)
1209static 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)
1211static 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)
1214static 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)
1216static 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)
1218static 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)
1222static 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)
1224static 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)
1226static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
1227# endif
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)
79bfeef6
PC		 1329# define jmpi(i0,i1) _jmpi(_jit,i0,i1)
1330static jit_word_t _jmpi(jit_state_t*,jit_word_t, jit_bool_t);
4a71579b
PC		 1331# define jmpi_p(i0) _jmpi_p(_jit,i0)
1332static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
1333# define callr(r0) BALR(_R14_REGNO,r0)
79bfeef6
PC		 1334# define calli(i0,i1) _calli(_jit,i0,i1)
1335static jit_word_t _calli(jit_state_t*,jit_word_t, jit_bool_t);
4a71579b
PC		 1336# define calli_p(i0) _calli_p(_jit,i0)
1337static jit_word_t _calli_p(jit_state_t*,jit_word_t);
1338# define prolog(i0) _prolog(_jit,i0)
1339static void _prolog(jit_state_t*,jit_node_t*);
1340# define epilog(i0) _epilog(_jit,i0)
1341static void _epilog(jit_state_t*,jit_node_t*);
1342# define vastart(r0) _vastart(_jit, r0)
1343static void _vastart(jit_state_t*, jit_int32_t);
1344# define vaarg(r0, r1) _vaarg(_jit, r0, r1)
1345static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
1346# define patch_at(instr,label) _patch_at(_jit,instr,label)
1347static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
1348#endif
1349
1350#if CODE
1351# define _us jit_uint16_t
1352# define _ui jit_uint32_t
1353static void
1354_E(jit_state_t *_jit, _ui Op)
1355{
1356 union {
1357 struct {
1358 _us op;
1359 } b;
1360 _us s;
1361 } i0;
1362 i0.b.op = Op;
1363 assert(i0.b.op == Op);
1364 is(i0.s);
1365}
1366
1367static void
1368_I(jit_state_t *_jit, _ui Op, _ui I)
1369{
1370 union {
1371 struct {
1372 _us op : 8;
1373 _us i : 8;
1374 } b;
1375 _us s;
1376 } i0;
1377 i0.b.op = Op;
1378 i0.b.i = I;
1379 assert(i0.b.op == Op);
1380 assert(i0.b.i == I);
1381 is(i0.s);
1382}
1383
1384static void
1385_RR(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1386{
1387 union {
1388 struct {
1389 _us op : 8;
1390 _us r1 : 4;
1391 _us r2 : 4;
1392 } b;
1393 _us s;
1394 } i0;
1395 i0.b.op = Op;
1396 i0.b.r1 = R1;
1397 i0.b.r2 = R2;
1398 assert(i0.b.op == Op);
1399 assert(i0.b.r1 == R1);
1400 assert(i0.b.r2 == R2);
1401 is(i0.s);
1402}
1403
1404static void
1405_RRE(jit_state_t *_jit, _ui Op, _ui R1, _ui R2)
1406{
1407 union {
1408 struct {
1409 _us op;
1410 } b;
1411 _us s;
1412 } i0;
1413 union {
1414 struct {
1415 _us _ : 8;
1416 _us r1 : 4;
1417 _us r2 : 4;
1418 } b;
1419 _us s;
1420 } i1;
1421 i0.b.op = Op;
1422 i1.b._ = 0;
1423 i1.b.r1 = R1;
1424 i1.b.r2 = R2;
1425 assert(i0.b.op == Op);
1426 assert(i1.b.r1 == R1);
1427 assert(i1.b.r2 == R2);
1428 is(i0.s);
1429 is(i1.s);
1430}
1431
1432static void
1433_RRF(jit_state_t *_jit, _ui Op, _ui R3, _ui M4, _ui R1, _ui R2)
1434{
1435 union {
1436 struct {
1437 _us op;
1438 } b;
1439 _us s;
1440 } i0;
1441 union {
1442 struct {
1443 _us r3 : 4;
1444 _us m4 : 4;
1445 _us r1 : 4;
1446 _us r2 : 4;
1447 } b;
1448 _us s;
1449 } i1;
1450 i0.b.op = Op;
1451 i1.b.r3 = R3;
1452 i1.b.m4 = M4;
1453 i1.b.r1 = R1;
1454 i1.b.r2 = 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);
1460 is(i0.s);
1461 is(i1.s);
1462}
1463
1464static void
1465_RX(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2)
1466{
1467 union {
1468 struct {
1469 _us op : 8;
1470 _us r1 : 4;
1471 _us x2 : 4;
1472 } b;
1473 _us s;
1474 } i0;
1475 union {
1476 struct {
1477 _us b2 : 4;
1478 _us d2 : 12;
1479 } b;
1480 _us s;
1481 } i1;
1482 i0.b.op = Op;
1483 i0.b.r1 = R1;
1484 i0.b.x2 = X2;
1485 i1.b.b2 = B2;
1486 i1.b.d2 = 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);
1492 is(i0.s);
1493 is(i1.s);
1494}
1495
1496static void
1497_RXE(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1498{
1499 union {
1500 struct {
1501 _us op : 8;
1502 _us r1 : 4;
1503 _us x2 : 4;
1504 } b;
1505 _us s;
1506 } i0;
1507 union {
1508 struct {
1509 _us b2 : 4;
1510 _us d2 : 12;
1511 } b;
1512 _ui s;
1513 } i1;
1514 union {
1515 struct {
1516 _us _ : 8;
1517 _us op : 8;
1518 } b;
1519 _us s;
1520 } i2;
1521 i2.b._ = 0;
1522 i0.b.op = Op;
1523 i0.b.r1 = R1;
1524 i0.b.x2 = X2;
1525 i1.b.b2 = B2;
1526 i1.b.d2 = D2;
1527 i2.b.op = 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);
1534 is(i0.s);
1535 is(i1.s);
1536 is(i2.s);
1537}
1538
1539static void
1540_RXF(jit_state_t *_jit, _ui Op, _ui R3, _ui X2, _ui B2, _ui D2, _ui R1, _ui Op2)
1541{
1542 union {
1543 struct {
1544 _us op : 8;
1545 _us r3 : 4;
1546 _us x2 : 4;
1547 } b;
1548 _us s;
1549 } i0;
1550 union {
1551 struct {
1552 _us b2 : 4;
1553 _us d2 : 12;
1554 } b;
1555 _us s;
1556 } i1;
1557 union {
1558 struct {
1559 _us r1 : 4;
1560 _us _ : 4;
1561 _us op : 8;
1562 } b;
1563 _us s;
1564 } i2;
1565 i2.b._ = 0;
1566 i0.b.op = Op;
1567 i0.b.r3 = R3;
1568 i0.b.x2 = X2;
1569 i1.b.b2 = B2;
1570 i1.b.d2 = D2;
1571 i2.b.r1 = R1;
1572 i2.b.op = 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);
1580 is(i0.s);
1581 is(i1.s);
1582 is(i2.s);
1583}
1584
1585static void
1586_RXY(jit_state_t *_jit, _ui Op, _ui R1, _ui X2, _ui B2, _ui D2, _ui Op2)
1587{
1588 union {
1589 struct {
1590 _us op : 8;
1591 _us r1 : 4;
1592 _us x2 : 4;
1593 } b;
1594 _us s;
1595 } i0;
1596 union {
1597 struct {
1598 _us b2 : 4;
1599 _us dl : 12;
1600 } b;
1601 _us s;
1602 } i1;
1603 union {
1604 struct {
1605 _us dh : 8;
1606 _us op : 8;
1607 } b;
1608 _us s;
1609 } i2;
1610 i0.s = i1.s = i2.s = 0;
1611 i0.b.op = Op;
1612 i0.b.r1 = R1;
1613 i0.b.x2 = X2;
1614 i1.b.b2 = B2;
1615 i1.b.dl = D2 & 0xfff;
1616 i2.b.dh = D2 >> 12;
1617 i2.b.op = Op2;
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);
1624 is(i0.s);
1625 is(i1.s);
1626 is(i2.s);
1627}
1628
1629static void
1630_RS(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui B2, _ui D2)
1631{
1632 union {
1633 struct {
1634 _us op : 8;
1635 _us r1 : 4;
1636 _us r3 : 4;
1637 } b;
1638 _us s;
1639 } i0;
1640 union {
1641 struct {
1642 _us b2 : 4;
1643 _us d2 : 12;
1644 } b;
1645 _us s;
1646 } i1;
1647 i0.s = i1.s = 0;
1648 i0.b.op = Op;
1649 i0.b.r1 = R1;
1650 i0.b.r3 = R3;
1651 i1.b.b2 = B2;
1652 i1.b.d2 = 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);
1658 is(i0.s);
1659 is(i1.s);
1660}
1661
1662static void
1663_RSL(jit_state_t *_jit, _ui Op, _ui L1, _ui B1, _ui D1, _ui Op2)
1664{
1665 union {
1666 struct {
1667 _us op : 8;
1668 _us l1 : 4;
1669 _us _ : 4;
1670 } b;
1671 _us s;
1672 } i0;
1673 union {
1674 struct {
1675 _us b1 : 4;
1676 _us d1 : 12;
1677 } b;
1678 _us s;
1679 } i1;
1680 union {
1681 struct {
1682 _us _ : 8;
1683 _us op : 8;
1684 } b;
1685 _us s;
1686 } i2;
1687 i0.b._ = 0;
1688 i2.b._ = 0;
1689 i0.b.op = Op;
1690 i0.b.l1 = L1;
1691 i1.b.b1 = B1;
1692 i1.b.d1 = D1;
1693 i2.b.op = 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);
1699 is(i0.s);
1700 is(i1.s);
1701 is(i2.s);
1702}
1703
1704static void
1705_RSI(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2)
1706{
1707 union {
1708 struct {
1709 _us op : 8;
1710 _us r1 : 4;
1711 _us r3 : 4;
1712 } b;
1713 _us s;
1714 } i0;
1715 union {
1716 struct {
1717 _us i2;
1718 } b;
1719 _us s;
1720 } i1;
1721 i0.b.op = Op;
1722 i0.b.r1 = R1;
1723 i0.b.r3 = R3;
1724 i1.b.i2 = 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);
1729 is(i0.s);
1730 is(i1.s);
1731}
1732
1733static void
1734_RIE(jit_state_t *_jit, _ui Op, _ui R1, _ui R3, _ui I2, _ui Op2)
1735{
1736 union {
1737 struct {
1738 _us op : 8;
1739 _us r1 : 4;
1740 _us r3 : 4;
1741 } b;
1742 _us s;
1743 } i0;
1744 union {
1745 struct {
1746 _us i2;
1747 } b;
1748 _us s;
1749 } i1;
1750 union {
1751 struct {
1752 _us _ : 8;
1753 _us op : 8;
1754 } b;
1755 _us s;
1756 } i2;
1757 i2.b._ = 0;
1758 i0.b.op = Op;
1759 i0.b.r1 = R1;
1760 i0.b.r3 = R3;
1761 i1.b.i2 = I2;
1762 i2.b.op = 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);
1768 is(i0.s);
1769 is(i1.s);
1770 is(i2.s);
1771}
1772
1773static void
1774_RIL(jit_state_t *_jit, _ui Op, _ui R1, _ui Op2, _ui I2)
1775{
1776 union {
1777 struct {
1778 _us o1 : 8;
1779 _us r1 : 4;
1780 _us o2 : 4;
1781 } b;
1782 _us s;
1783 } i0;
1784 union {
1785 struct {
1786 _ui ih : 16;
1787 _ui il : 16;
1788 } b;
1789 _ui i;
1790 } i12;
1791 i0.b.o1 = Op;
1792 i0.b.r1 = R1;
1793 i0.b.o2 = Op2;
1794 i12.i = I2;
1795 assert(i0.b.o1 == Op);
1796 assert(i0.b.r1 == R1);
1797 assert(i0.b.o2 == Op2);
1798 is(i0.s);
1799 is(i12.b.ih);
1800 is(i12.b.il);
1801}
1802
1803static void
1804_SI(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1)
1805{
1806 union {
1807 struct {
1808 _us op : 8;
1809 _us i2 : 8;
1810 } b;
1811 _us s;
1812 } i0;
1813 union {
1814 struct {
1815 _us b1 : 4;
1816 _us d1 : 12;
1817 } b;
1818 _us s;
1819 } i1;
1820 i0.b.op = Op;
1821 i0.b.i2 = I2;
1822 i1.b.b1 = B1;
1823 i1.b.d1 = 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);
1828 is(i0.s);
1829 is(i1.s);
1830}
1831
1832static void
1833_SIY(jit_state_t *_jit, _ui Op, _ui I2, _ui B1, _ui D1, _ui Op2)
1834{
1835 union {
1836 struct {
1837 _us op : 8;
1838 _us i2 : 8;
1839 } b;
1840 _us s;
1841 } i0;
1842 union {
1843 struct {
1844 _us b1 : 4;
1845 _us dl : 12;
1846 } b;
1847 _us s;
1848 } i1;
1849 union {
1850 struct {
1851 _us dh : 8;
1852 _us op : 8;
1853 } b;
1854 _us s;
1855 } i2;
1856 i0.b.op = Op;
1857 i0.b.i2 = I2;
1858 i1.b.b1 = B1;
1859 i1.b.dl = D1 & 0xfff;
1860 i2.b.dh = D1 >> 8;
1861 i2.b.op = Op2;
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);
1867 is(i0.s);
1868 is(i1.s);
1869 is(i2.s);
1870}
1871
1872static void
1873_S(jit_state_t *_jit, _ui Op, _ui B2, _ui D2)
1874{
1875 union {
1876 struct {
1877 _us op;
1878 } b;
1879 _us s;
1880 } i0;
1881 union {
1882 struct {
1883 _us b2 : 4;
1884 _us d2 : 12;
1885 } b;
1886 _us s;
1887 } i1;
1888 i0.b.op = Op;
1889 i1.b.b2 = B2;
1890 i1.b.d2 = D2;
1891 assert(i0.b.op == Op);
1892 assert(i1.b.b2 == B2);
1893 assert(i1.b.d2 == D2);
1894 is(i0.s);
1895 is(i1.s);
1896}
1897
1898static void
1899_SS(jit_state_t *_jit, _ui Op, _ui LL, _ui LH, _ui B1, _ui D1, _ui B2, _ui D2)
1900{
1901 union {
1902 struct {
1903 _us op : 8;
1904 _us ll : 4;
1905 _us lh : 4;
1906 } b;
1907 _us s;
1908 } i0;
1909 union {
1910 struct {
1911 _us b1 : 4;
1912 _us d1 : 12;
1913 } b;
1914 _us s;
1915 } i1;
1916 union {
1917 struct {
1918 _us b2 : 4;
1919 _us d2 : 12;
1920 } b;
1921 _us s;
1922 } i2;
1923 i0.b.op = Op;
1924 i0.b.ll = LL;
1925 i0.b.lh = LH;
1926 i1.b.b1 = B1;
1927 i1.b.d1 = D1;
1928 i2.b.b2 = B2;
1929 i2.b.d2 = 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);
1937 is(i0.s);
1938 is(i1.s);
1939 is(i2.s);
1940}
1941
1942static void
1943_SSE(jit_state_t *_jit, _ui Op, _ui B1, _ui D1, _ui B2, _ui D2)
1944{
1945 union {
1946 struct {
1947 _us op;
1948 } b;
1949 _us s;
1950 } i0;
1951 union {
1952 struct {
1953 _us b1 : 4;
1954 _us d1 : 12;
1955 } b;
1956 _us s;
1957 } i1;
1958 union {
1959 struct {
1960 _us b2 : 4;
1961 _us d2 : 12;
1962 } b;
1963 _us s;
1964 } i2;
1965 i0.b.op = Op;
1966 i1.b.b1 = B1;
1967 i1.b.d1 = D1;
1968 i2.b.b2 = B2;
1969 i2.b.d2 = 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);
1975 is(i0.s);
1976 is(i1.s);
1977 is(i2.s);
1978}
1979# undef _us
1980# undef _ui
1981
1982static void
1983_nop(jit_state_t *_jit, jit_int32_t c)
1984{
1985 assert(c >= 0 && !(c & 1));
1986 while (c) {
1987 NOPR(_R7_REGNO);
1988 c -= 2;
1989 }
1990}
1991
1992static jit_int32_t
1993_xdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1994{
1995 jit_int32_t regno;
1996 regno = jit_get_reg_pair();
1997#if __WORDSIZE == 32
1998 movr(rn(regno), r0);
1999 SRDA(rn(regno), 32, 0);
2000#else
2001 movr(rn(regno) + 1, r0);
2002#endif
2003 DIVREM_(rn(regno), r1);
2004 jit_unget_reg_pair(regno);
2005 return (regno);
2006}
2007
2008static jit_int32_t
2009_xdivr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2010{
2011 jit_int32_t regno;
2012 regno = jit_get_reg_pair();
2013#if __WORDSIZE == 32
2014 movr(rn(regno), r0);
2015 SRDL(rn(regno), 32, 0);
2016#else
2017 movr(rn(regno) + 1, r0);
2018#endif
2019 movi(rn(regno), 0);
2020 DIVREMU_(rn(regno), r1);
2021 jit_unget_reg_pair(regno);
2022 return (regno);
2023}
2024
2025static jit_int32_t
2026_xdivi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2027{
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);
2034#else
2035 movr(rn(regno) + 1, r0);
2036#endif
2037 movi(rn(imm), i0);
2038 DIVREM_(rn(regno), rn(imm));
2039 jit_unget_reg(imm);
2040 jit_unget_reg_pair(regno);
2041 return (regno);
2042}
2043
2044static jit_int32_t
2045_xdivi_u(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2046{
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);
2054#else
2055 movr(rn(regno) + 1, r0);
2056#endif
2057 movi(rn(regno), 0);
2058 movi(rn(imm), i0);
2059 DIVREMU_(rn(regno), rn(imm));
2060 jit_unget_reg(imm);
2061 jit_unget_reg_pair(regno);
2062 return (regno);
2063}
2064
2065static void
2066_crr(jit_state_t *_jit, jit_int32_t cc,
2067 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2068{
2069 jit_word_t w;
2070 jit_int32_t reg, rg;
2071 if (r0 == r1 || r0 == r2) {
2072 reg = jit_get_reg(jit_class_gpr);
2073 rg = rn(reg);
2074 }
2075 else
2076 rg = r0;
2077 movi(rg, 1);
2078 CMP_(r1, r2);
2079 w = _jit->pc.w;
2080 BRC(cc, 0);
2081 movi(rg, 0);
2082 patch_at(w, _jit->pc.w);
2083 if (r0 == r1 || r0 == r2) {
2084 movr(r0, rg);
2085 jit_unget_reg(reg);
2086 }
2087}
2088
2089static void
2090_cri(jit_state_t *_jit, jit_int32_t cc,
2091 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2092{
2093 jit_int32_t reg;
2094 reg = jit_get_reg(jit_class_gpr);
2095 movi(rn(reg), i0);
2096 crr(cc, r0, r1, rn(reg));
2097 jit_unget_reg(reg);
2098}
2099
2100static void
2101_crr_u(jit_state_t *_jit, jit_int32_t cc,
2102 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2103{
2104 jit_word_t w;
2105 jit_int32_t reg, rg;
2106 if (r0 == r1 || r0 == r2) {
2107 reg = jit_get_reg(jit_class_gpr);
2108 rg = rn(reg);
2109 }
2110 else
2111 rg = r0;
2112 movi(rg, 1);
2113 CMPU_(r1, r2);
2114 w = _jit->pc.w;
2115 BRC(cc, 0);
2116 movi(rg, 0);
2117 patch_at(w, _jit->pc.w);
2118 if (r0 == r1 || r0 == r2) {
2119 movr(r0, rg);
2120 jit_unget_reg(reg);
2121 }
2122}
2123
2124static void
2125_cri_u(jit_state_t *_jit, jit_int32_t cc,
2126 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2127{
2128 jit_int32_t reg;
2129 reg = jit_get_reg(jit_class_gpr);
2130 movi(rn(reg), i0);
2131 crr_u(cc, r0, r1, rn(reg));
2132 jit_unget_reg(reg);
2133}
2134
2135static void
2136_brr(jit_state_t *_jit, jit_int32_t cc,
2137 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2138{
2139 jit_word_t d;
2140 CMP_(r0, r1);
2141 d = (i0 - _jit->pc.w) >> 1;
2142 if (s16_p(d))
2143 BRC(cc, x16(d));
2144 else {
2145 assert(s32_p(d));
2146 BRCL(cc, d);
2147 }
2148}
2149
2150static jit_word_t
2151_brr_p(jit_state_t *_jit, jit_int32_t cc,
2152 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2153{
2154 jit_word_t w;
2155 CMP_(r0, r1);
2156 w = _jit->pc.w;
2157 BRCL(cc, 0);
2158 return (w);
2159}
2160
2161static void
2162_bri(jit_state_t *_jit, jit_int32_t cc,
2163 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2164{
2165 jit_int32_t reg;
2166 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2167 movi(rn(reg), i1);
2168 brr(cc, i0, r0, rn(reg));
2169 jit_unget_reg(reg);
2170}
2171
2172static jit_word_t
2173_bri_p(jit_state_t *_jit, jit_int32_t cc,
2174 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2175{
2176 jit_word_t w;
2177 jit_int32_t reg;
2178 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2179 movi(rn(reg), i1);
2180 w = brr_p(cc, i0, r0, rn(reg));
2181 jit_unget_reg(reg);
2182 return (w);
2183}
2184
2185static void
2186_brr_u(jit_state_t *_jit, jit_int32_t cc,
2187 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2188{
2189 jit_word_t d;
2190 CMPU_(r0, r1);
2191 d = (i0 - _jit->pc.w) >> 1;
2192 if (s16_p(d))
2193 BRC(cc, x16(d));
2194 else {
2195 assert(s32_p(d));
2196 BRCL(cc, d);
2197 }
2198}
2199
2200static jit_word_t
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)
2203{
2204 jit_word_t w;
2205 CMPU_(r0, r1);
2206 w = _jit->pc.w;
2207 BRCL(cc, 0);
2208 return (w);
2209}
2210
2211static void
2212_bri_u(jit_state_t *_jit, jit_int32_t cc,
2213 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2214{
2215 jit_int32_t reg;
2216 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2217 movi(rn(reg), i1);
2218 brr_u(cc, i0, r0, rn(reg));
2219 jit_unget_reg(reg);
2220}
2221
2222static jit_word_t
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)
2225{
2226 jit_word_t w;
2227 jit_int32_t reg;
2228 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2229 movi(rn(reg), i1);
2230 w = brr_u_p(cc, i0, r0, rn(reg));
2231 jit_unget_reg(reg);
2232 return (w);
2233}
2234
2235static void
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)
2238{
2239 jit_word_t d;
2240 if (s) addr(r0, r0, r1);
2241 else addcr(r0, r0, r1);
2242 d = (i0 - _jit->pc.w) >> 1;
2243 if (s16_p(d))
2244 BRC(c, x16(d));
2245 else {
2246 assert(s32_p(d));
2247 BRCL(c, d);
2248 }
2249}
2250
2251static void
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)
2254{
2255 jit_int32_t reg;
2256 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2257 movi(rn(reg), i1);
2258 baddr(c, s, i0, r0, rn(reg));
2259 jit_unget_reg(reg);
2260}
2261
2262static jit_word_t
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)
2265{
2266 jit_word_t d, w;
2267 if (s) addr(r0, r0, r1);
2268 else addcr(r0, r0, r1);
2269 d = (i0 - _jit->pc.w) >> 1;
2270 w = _jit->pc.w;
2271 BRCL(c, d);
2272 return (w);
2273}
2274
2275static jit_word_t
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)
2278{
2279 jit_word_t w;
2280 jit_int32_t reg;
2281 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2282 movi(rn(reg), i1);
2283 w = baddr_p(c, s, i0, r0, rn(reg));
2284 jit_unget_reg(reg);
2285 return (w);
2286}
2287
2288static void
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)
2291{
2292 jit_word_t d;
2293 if (s) subr(r0, r0, r1);
2294 else subcr(r0, r0, r1);
2295 d = (i0 - _jit->pc.w) >> 1;
2296 if (s16_p(d))
2297 BRC(c, x16(d));
2298 else {
2299 assert(s32_p(d));
2300 BRCL(c, d);
2301 }
2302}
2303
2304static void
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)
2307{
2308 jit_int32_t reg;
2309 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2310 movi(rn(reg), i1);
2311 bsubr(c, s, i0, r0, rn(reg));
2312 jit_unget_reg(reg);
2313}
2314
2315static jit_word_t
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)
2318{
2319 jit_word_t d, w;
2320 if (s) subr(r0, r0, r1);
2321 else subcr(r0, r0, r1);
2322 d = (i0 - _jit->pc.w) >> 1;
2323 w = _jit->pc.w;
2324 BRCL(c, d);
2325 return (w);
2326}
2327
2328static jit_word_t
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)
2331{
2332 jit_word_t w;
2333 jit_int32_t reg;
2334 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2335 movi(rn(reg), i1);
2336 w = bsubr_p(c, s, i0, r0, rn(reg));
2337 jit_unget_reg(reg);
2338 return (w);
2339}
2340
2341static void
2342_bmxr(jit_state_t *_jit, jit_int32_t cc,
2343 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2344{
2345 jit_word_t d;
2346 jit_int32_t reg;
2347 reg = jit_get_reg(jit_class_gpr);
2348 movr(rn(reg), r0);
2349 andr(rn(reg), rn(reg), r1);
2350 TEST_(rn(reg), rn(reg));
2351 jit_unget_reg(reg);
2352 d = (i0 - _jit->pc.w) >> 1;
2353 if (s16_p(d))
2354 BRC(cc, x16(d));
2355 else {
2356 assert(s32_p(d));
2357 BRCL(cc, d);
2358 }
2359}
2360
2361static jit_word_t
2362_bmxr_p(jit_state_t *_jit, jit_int32_t cc,
2363 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2364{
2365 jit_word_t w;
2366 jit_int32_t reg;
2367 reg = jit_get_reg(jit_class_gpr);
2368 movr(rn(reg), r0);
2369 andr(rn(reg), rn(reg), r1);
2370 TEST_(rn(reg), rn(reg));
2371 jit_unget_reg(reg);
2372 w = _jit->pc.w;
2373 BRCL(cc, 0);
2374 return (w);
2375}
2376
2377static void
2378_bmxi(jit_state_t *_jit, jit_int32_t cc,
2379 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2380{
2381 jit_word_t d;
2382 jit_int32_t reg;
2383 reg = jit_get_reg(jit_class_gpr);
2384 movi(rn(reg), i1);
2385 andr(rn(reg), rn(reg), r0);
2386 TEST_(rn(reg), rn(reg));
2387 jit_unget_reg(reg);
2388 d = (i0 - _jit->pc.w) >> 1;
2389 if (s16_p(d))
2390 BRC(cc, x16(d));
2391 else {
2392 assert(s32_p(d));
2393 BRCL(cc, d);
2394 }
2395}
2396
2397static jit_word_t
2398_bmxi_p(jit_state_t *_jit, jit_int32_t cc,
2399 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2400{
2401 jit_word_t w;
2402 jit_int32_t reg;
2403 reg = jit_get_reg(jit_class_gpr);
2404 movi(rn(reg), i1);
2405 andr(rn(reg), rn(reg), r0);
2406 TEST_(rn(reg), rn(reg));
2407 jit_unget_reg(reg);
2408 w = _jit->pc.w;
2409 BRCL(cc, 0);
2410 return (w);
2411}
2412
2413static void
2414_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2415{
2416#if __WORDSIZE == 32
2417 if (r0 != r1)
2418 LR(r0, r1);
2419#else
2420 if (r0 != r1)
2421 LGR(r0, r1);
2422#endif
2423}
2424
2425static void
2426_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2427{
2428 jit_word_t d;
2429#if __WORDSIZE == 64
2430 jit_int32_t bits;
2431#endif
2432 d = (i0 - _jit->pc.w) >> 1;
2433 if (s16_p(i0)) {
2434#if __WORDSIZE == 32
2435 LHI(r0, x16(i0));
2436#else
2437 LGHI(r0, x16(i0));
2438#endif
2439 }
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
2444 i0 > 0
2445#else
2446 s32_p(d)
2447#endif
2448 )
2449 LARL(r0, d);
2450 else {
2451#if __WORDSIZE == 32
2452 LHI(r0, x16(i0));
2453 IILH(r0, x16((jit_uword_t)i0 >> 16));
2454#else
2455 bits = 0;
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));
2465#endif
2466 }
2467}
2468
2469static jit_word_t
2470_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2471{
2472 jit_word_t w;
2473 w = _jit->pc.w;
2474#if __WORDSIZE == 32
2475 LHI(r0, x16(i0));
2476#else
2477 IILL(r0, x16(i0));
2478#endif
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));
2483#endif
2484 return (w);
2485}
2486
40a44dcb
PC		 2487static void
2488_movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2489{
2490 jit_word_t w;
2491 w = beqi_p(_jit->pc.w, r2, 0);
2492#if __WORDSIZE == 32
2493 LR(r0, r1);
2494#else
2495 LGR(r0, r1);
2496#endif
2497 patch_at(w, _jit->pc.w);
2498}
2499
2500static void
2501_movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2502{
2503 jit_word_t w;
2504 w = bnei_p(_jit->pc.w, r2, 0);
2505#if __WORDSIZE == 32
2506 LR(r0, r1);
2507#else
2508 LGR(r0, r1);
2509#endif
2510 patch_at(w, _jit->pc.w);
2511}
2512
79bfeef6
PC		 2513static void
2514_bswapr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2515{
2516 LRVR(r0, r1);
2517 SRL(r0, 16, 0);
2518 LLGHR(r0, r0);
2519}
2520
2521static void
2522_bswapr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2523{
2524 LRVR(r0, r1);
2525# if __WORDSIZE == 64
2526 LLGFR(r0, r0);
2527# endif
2528}
2529
2530#if __WORDSIZE == 64
2531static void
2532_bswapr_ul(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2533{
2534 LRVGR(r0, r1);
2535}
2536#endif
2537
ba3814c1
PC		 2538static void
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)
2541{
c0c16242
PC		 2542 jit_int32_t iscasi, r1_reg;
2543 if ((iscasi = (r1 == _NOREG))) {
2544 r1_reg = jit_get_reg_but_zero(0);
2545 r1 = rn(r1_reg);
2546 movi(r1, i0);
2547 }
2548 /* Do not clobber r2 */
2549 movr(r0, r2);
2550 /* The CS and CSG instructions below effectively do atomically:
2551 * if (*r1 == r0)
2552 * *r1 = r3;
2553 * else
2554 * r0 = *r1
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.
2560 */
2561# if __WORDSIZE == 32
2562 CS(r0, r3, 0, r1);
2563# else
2564 CSG(r0, r3, 0, r1);
2565# endif
2566 eqr(r0, r0, r2);
2567 if (iscasi)
2568 jit_unget_reg(r1_reg);
ba3814c1
PC		 2569}
2570
4a71579b
PC		 2571static void
2572_addr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2573{
2574 if (r0 == r2)
2575 ADD_(r0, r1);
2576 else {
2577 movr(r0, r1);
2578 ADD_(r0, r2);
2579 }
2580}
2581
2582static void
2583_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2584{
2585 jit_int32_t reg;
2586 if (r0 == r1 && s16_p(i0))
2587 ADDI_(r0, x16(i0));
2588#if __WORDSIZE == 64
2589 else if (s20_p(i0))
2590 LAY(r0, x20(i0), 0, r1);
2591#endif
2592 else {
2593 reg = jit_get_reg(jit_class_gpr);
2594 movi(rn(reg), i0);
2595 addr(r0, r1, rn(reg));
2596 jit_unget_reg(reg);
2597 }
2598}
2599
2600static void
2601_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2602{
2603 if (r0 == r2)
2604 ADDC_(r0, r1);
2605 else {
2606 movr(r0, r1);
2607 ADDC_(r0, r2);
2608 }
2609}
2610
2611static void
2612_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2613{
2614 jit_int32_t reg;
2615 reg = jit_get_reg(jit_class_gpr);
2616 movi(rn(reg), i0);
2617 addcr(r0, r1, rn(reg));
2618 jit_unget_reg(reg);
2619}
2620
2621static void
2622_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2623{
2624 if (r0 == r2)
2625 ADDX_(r0, r1);
2626 else {
2627 movr(r0, r1);
2628 ADDX_(r0, r2);
2629 }
2630}
2631
2632static void
2633_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2634{
2635 jit_int32_t reg;
2636 reg = jit_get_reg(jit_class_gpr);
2637 movi(rn(reg), i0);
2638 addxr(r0, r1, rn(reg));
2639 jit_unget_reg(reg);
2640}
2641
2642static void
2643_subr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2644{
2645 jit_int32_t reg;
2646 if (r0 == r2) {
2647 reg = jit_get_reg(jit_class_gpr);
2648 movr(rn(reg), r2);
2649 movr(r0, r1);
2650 SUB_(r0, rn(reg));
2651 jit_unget_reg(reg);
2652 }
2653 else {
2654 movr(r0, r1);
2655 SUB_(r0, r2);
2656 }
2657}
2658
2659static void
2660_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2661{
2662 jit_int32_t reg;
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);
2668#endif
2669 else {
2670 reg = jit_get_reg(jit_class_gpr);
2671 movi(rn(reg), i0);
2672 subr(r0, r1, rn(reg));
2673 jit_unget_reg(reg);
2674 }
2675}
2676
2677static void
2678_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2679{
2680 jit_int32_t reg;
2681 if (r0 == r2) {
2682 reg = jit_get_reg(jit_class_gpr);
2683 movr(rn(reg), r2);
2684 movr(r0, r1);
2685 SUBC_(r0, rn(reg));
2686 jit_unget_reg(reg);
2687 }
2688 else {
2689 movr(r0, r1);
2690 SUBC_(r0, r2);
2691 }
2692}
2693
2694static void
2695_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2696{
2697 jit_int32_t reg;
2698 reg = jit_get_reg(jit_class_gpr);
2699 movi(rn(reg), i0);
2700 subcr(r0, r1, rn(reg));
2701 jit_unget_reg(reg);
2702}
2703
2704static void
2705_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2706{
2707 jit_int32_t reg;
2708 if (r0 == r2) {
2709 reg = jit_get_reg(jit_class_gpr);
2710 movr(rn(reg), r2);
2711 movr(r0, r1);
2712 SUBX_(r0, rn(reg));
2713 jit_unget_reg(reg);
2714 }
2715 else {
2716 movr(r0, r1);
2717 SUBX_(r0, r2);
2718 }
2719}
2720
2721static void
2722_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2723{
2724 jit_int32_t reg;
2725 reg = jit_get_reg(jit_class_gpr);
2726 movi(rn(reg), i0);
2727 subxr(r0, r1, rn(reg));
2728 jit_unget_reg(reg);
2729}
2730
2731static void
2732_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2733{
2734 subi(r0, r1, i0);
2735 negr(r0, r0);
2736}
2737
2738static void
2739_mulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2740{
2741 if (r0 == r2)
2742 MUL_(r0, r1);
2743 else {
2744 movr(r0, r1);
2745 MUL_(r0, r2);
2746 }
2747}
2748
2749static void
2750_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2751{
2752 jit_int32_t reg;
2753 if (s16_p(i0)) {
2754 movr(r0, r1);
2755 MULI_(r0, x16(i0));
2756 }
2757 else {
2758 reg = jit_get_reg(jit_class_gpr);
2759 movi(rn(reg), i0);
2760 mulr(r0, r1, rn(reg));
2761 jit_unget_reg(reg);
2762 }
2763}
2764
2765static void
2766_qmulr(jit_state_t *_jit,
2767 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2768{
2769 jit_int32_t reg;
2770 /* The only invalid condition is r0 == r1 */
2771 jit_int32_t t2, t3, s2, s3;
ba86ff93 2772 if ((r0 != JIT_NOREG && r2 == r0) || r2 == r1) {
4a71579b
PC		 2773 s2 = jit_get_reg(jit_class_gpr);
2774 t2 = rn(s2);
2775 movr(t2, r2);
2776 }
2777 else
2778 t2 = r2;
ba86ff93 2779 if ((r0 != JIT_NOREG && r3 == r0) || r3 == r1) {
4a71579b
PC		 2780 s3 = jit_get_reg(jit_class_gpr);
2781 t3 = rn(s3);
2782 movr(t3, r3);
2783 }
2784 else
2785 t3 = r3;
2786 qmulr_u(r0, r1, r2, r3);
2787 reg = jit_get_reg(jit_class_gpr);
2788 /**/
2789 rshi(rn(reg), t2, 63);
2790 mulr(rn(reg), rn(reg), t3);
2791 addr(r1, r1, rn(reg));
2792 /**/
2793 rshi(rn(reg), t3, 63);
2794 mulr(rn(reg), rn(reg), t2);
2795 addr(r1, r1, rn(reg));
2796 jit_unget_reg(reg);
2797 if (t2 != r2)
2798 jit_unget_reg(s2);
2799 if (t3 != r3)
2800 jit_unget_reg(s3);
2801}
2802
2803static void
2804_qmuli(jit_state_t *_jit,
2805 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2806{
2807 jit_int32_t reg;
2808 reg = jit_get_reg(jit_class_gpr);
2809 movi(rn(reg), i0);
2810 qmulr(r0, r1, r2, rn(reg));
2811 jit_unget_reg(reg);
2812}
2813
2814static void
2815_qmulr_u(jit_state_t *_jit,
2816 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2817{
2818 jit_int32_t regno;
2819 regno = jit_get_reg_pair();
2820 movr(rn(regno) + 1, r2);
2821 MULU_(rn(regno), r3);
ba86ff93
PC		 2822 if (r0 != JIT_NOREG)
2823 movr(r0, rn(regno) + 1);
4a71579b
PC		 2824 movr(r1, rn(regno));
2825 jit_unget_reg_pair(regno);
2826}
2827
2828static void
2829_qmuli_u(jit_state_t *_jit,
2830 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2831{
2832 jit_int32_t regno;
2833 regno = jit_get_reg_pair();
2834 movr(rn(regno) + 1, r2);
2835 movi(rn(regno), i0);
2836 MULU_(rn(regno), rn(regno));
ba86ff93
PC		 2837 if (r0 != JIT_NOREG)
2838 movr(r0, rn(regno) + 1);
4a71579b
PC		 2839 movr(r1, rn(regno));
2840 jit_unget_reg_pair(regno);
2841}
2842
2843static void
2844_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2845{
2846 jit_int32_t regno;
2847 regno = xdivr(r1, r2);
2848 movr(r0, rn(regno) + 1);
2849}
2850
2851static void
2852_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2853{
2854 jit_int32_t regno;
2855 regno = xdivi(r1, i0);
2856 movr(r0, rn(regno) + 1);
2857}
2858
2859static void
2860_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2861{
2862 jit_int32_t regno;
2863 regno = xdivr_u(r1, r2);
2864 movr(r0, rn(regno) + 1);
2865}
2866
2867static void
2868_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2869{
2870 jit_int32_t regno;
2871 regno = xdivi_u(r1, i0);
2872 movr(r0, rn(regno) + 1);
2873}
2874
2875static void
2876_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2877{
2878 jit_int32_t regno;
2879 regno = xdivr(r1, r2);
2880 movr(r0, rn(regno));
2881}
2882
2883static void
2884_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2885{
2886 jit_int32_t regno;
2887 regno = xdivi(r1, i0);
2888 movr(r0, rn(regno));
2889}
2890
2891static void
2892_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2893{
2894 jit_int32_t regno;
2895 regno = xdivr_u(r1, r2);
2896 movr(r0, rn(regno));
2897}
2898
2899static void
2900_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2901{
2902 jit_int32_t regno;
2903 regno = xdivi_u(r1, i0);
2904 movr(r0, rn(regno));
2905}
2906
2907static void
2908_qdivr(jit_state_t *_jit,
2909 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2910{
2911 jit_int32_t regno;
2912 regno = xdivr(r2, r3);
2913 movr(r0, rn(regno) + 1);
2914 movr(r1, rn(regno));
2915}
2916
2917static void
2918_qdivi(jit_state_t *_jit,
2919 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2920{
2921 jit_int32_t regno;
2922 regno = xdivi(r2, i0);
2923 movr(r0, rn(regno) + 1);
2924 movr(r1, rn(regno));
2925}
2926
2927static void
2928_qdivr_u(jit_state_t *_jit,
2929 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
2930{
2931 jit_int32_t regno;
2932 regno = xdivr_u(r2, r3);
2933 movr(r0, rn(regno) + 1);
2934 movr(r1, rn(regno));
2935}
2936
2937static void
2938_qdivi_u(jit_state_t *_jit,
2939 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_word_t i0)
2940{
2941 jit_int32_t regno;
2942 regno = xdivi_u(r2, i0);
2943 movr(r0, rn(regno) + 1);
2944 movr(r1, rn(regno));
2945}
2946
2947# if __WORDSIZE == 32
2948static void
2949_lshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2950{
2951 jit_int32_t reg;
2952 if (r0 == r2) {
2953 reg = jit_get_reg_but_zero(0);
2954 movr(rn(reg), r2);
2955 movr(r0, r1);
2956 SLL(r0, 0, rn(reg));
2957 jit_unget_reg_but_zero(reg);
2958 }
2959 else {
2960 movr(r0, r1);
2961 SLL(r0, 0, r2);
2962 }
2963}
4a71579b
PC		 2964
2965static void
2966_lshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2967{
79bfeef6
PC		 2968 movr(r0, r1);
2969 SLL(r0, i0, 0);
4a71579b
PC		 2970}
2971
4a71579b
PC		 2972static void
2973_rshr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2974{
2975 jit_int32_t reg;
2976 if (r0 == r2) {
2977 reg = jit_get_reg_but_zero(0);
2978 movr(rn(reg), r2);
2979 movr(r0, r1);
2980 SRA(r0, 0, rn(reg));
2981 jit_unget_reg_but_zero(reg);
2982 }
2983 else {
2984 movr(r0, r1);
2985 SRA(r0, 0, r2);
2986 }
2987}
4a71579b
PC		 2988
2989static void
2990_rshi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2991{
79bfeef6
PC		 2992 movr(r0, r1);
2993 SRA(r0, i0, 0);
4a71579b
PC		 2994}
2995
4a71579b
PC		 2996static void
2997_rshr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2998{
2999 jit_int32_t reg;
3000 if (r0 == r2) {
3001 reg = jit_get_reg_but_zero(0);
3002 movr(rn(reg), r2);
3003 movr(r0, r1);
3004 SRL(r0, 0, rn(reg));
3005 jit_unget_reg_but_zero(reg);
3006 }
3007 else {
3008 movr(r0, r1);
3009 SRL(r0, 0, r2);
3010 }
3011}
4a71579b
PC		 3012
3013static void
3014_rshi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3015{
79bfeef6
PC		 3016 movr(r0, r1);
3017 SRL(r0, i0, 0);
3018}
3019#endif
3020
3021static void
ba86ff93 3022_rrotr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
79bfeef6 3023{
ba86ff93
PC		 3024 jit_int32_t reg;
3025 if (r0 != r1 && r0 != r2) {
3026 rsbi(r0, r2, __WORDSIZE);
3027 lrotr(r0, r1, r0);
3028 }
3029 else {
3030 reg = jit_get_reg_but_zero(0);
3031 rsbi(rn(reg), r2, __WORDSIZE);
3032 lrotr(r0, r1, rn(reg));
3033 jit_unget_reg(reg);
3034 }
79bfeef6
PC		 3035}
3036
3037static void
3038_clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3039{
3040#if CHECK_FLOGR
3041 if (jit_cpu.flogr) {
3042#endif
3043 comr(r0, r1);
3044 clzr(r0, r0);
3045#if CHECK_FLOGR
3046 }
3047 else
3048 fallback_clo(r0, r1);
3049#endif
3050}
3051
3052static void
3053_clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3054{
3055#if CHECK_FLOGR
3056 if (jit_cpu.flogr) {
3057#endif
3058#if __WORDSIZE == 32
3059 jit_word_t w;
3060#endif
3061 jit_int32_t regno;
3062 regno = jit_get_reg_pair();
3063#if __WORDSIZE == 32
3064 SLLG(rn(regno), r1, 32, 0);
3065#else
3066 movr(rn(regno), r1);
3067#endif
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);
3074#endif
3075 jit_unget_reg_pair(regno);
3076#if CHECK_FLOGR
3077 }
3078 else
3079 fallback_clz(r0, r1);
3080#endif
3081}
3082
3083static void
3084_ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3085{
3086#if CHECK_FLOGR
3087 if (jit_cpu.flogr) {
3088#endif
ba86ff93
PC		 3089 comr(r0, r1);
3090 ctzr(r0, r0);
79bfeef6
PC		 3091#if CHECK_FLOGR
3092 }
3093 else
3094 fallback_cto(r0, r1);
3095#endif
3096}
3097
3098static void
3099_ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3100{
ba86ff93 3101 jit_int32_t t0, t1;
79bfeef6
PC		 3102#if CHECK_FLOGR
3103 if (jit_cpu.flogr) {
3104#endif
ba86ff93
PC		 3105 t0 = jit_get_reg_but_zero(0);
3106 t1 = jit_get_reg_but_zero(0);
3107 negr(rn(t0), r1);
3108 andr(rn(t0), rn(t0), r1);
3109 clzr(r0, rn(t0));
3110 xori(rn(t1), r0, __WORDSIZE - 1);
3111 movnr(r0, rn(t1), rn(t0));
3112 jit_unget_reg(t0);
3113 jit_unget_reg(t1);
79bfeef6
PC		 3114#if CHECK_FLOGR
3115 }
3116 else
3117 fallback_ctz(r0, r1);
3118#endif
4a71579b
PC		 3119}
3120
ba86ff93
PC		 3121static void
3122_extr(jit_state_t *_jit,
3123 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3124{
3125 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3126 /* Big Endian always */
3127 i0 = __WORDSIZE - (i0 + i1);
3128 if (i1 == __WORDSIZE)
3129 movr(r0, r1);
3130 else {
3131 if (__WORDSIZE - (i0 + i1)) {
3132 lshi(r0, r1, __WORDSIZE - (i0 + i1));
3133 rshi(r0, r0, __WORDSIZE - i1);
3134 }
3135 else
3136 rshi(r0, r1, __WORDSIZE - i1);
3137 }
3138}
3139
3140static void
3141_extr_u(jit_state_t *_jit,
3142 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3143{
3144 assert(i0 >= 0 && i1 >= 1 && i0 + i1 <= __WORDSIZE);
3145 /* Big Endian always */
3146 i0 = __WORDSIZE - (i0 + i1);
3147 if (i1 == __WORDSIZE)
3148 movr(r0, r1);
3149 else {
3150 if (i0)
3151 rshi_u(r0, r1, i0);
3152 andi(r0, r0, (1L << i1) - 1);
3153 }
3154}
3155
3156static void
3157_depr(jit_state_t *_jit,
3158 jit_int32_t r0, jit_int32_t r1, jit_word_t i0, jit_word_t i1)
3159{
3160 jit_int32_t t0;
3161 jit_word_t mask;
3162 /* Big Endian always */
3163 i0 = __WORDSIZE - (i0 + i1);
3164 if (i1 == __WORDSIZE)
3165 movr(r0, r1);
3166 else {
3167 mask = (1L << i1) - 1;
3168 t0 = jit_get_reg(jit_class_gpr);
3169 andi(rn(t0), r1, mask);
3170 if (i0) {
3171 lshi(rn(t0), rn(t0), i0);
3172 mask <<= i0;
3173 }
3174 andi(r0, r0, ~mask);
3175 orr(r0, r0, rn(t0));
3176 jit_unget_reg(t0);
3177 }
3178}
3179
4a71579b
PC		 3180static void
3181_comr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3182{
3183 jit_int32_t reg;
3184 reg = jit_get_reg(jit_class_gpr);
3185 movi(rn(reg), -1);
3186 movr(r0, r1);
3187 XOR_(r0, rn(reg));
3188 jit_unget_reg(reg);
3189}
3190
3191static void
3192_andr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3193{
3194 if (r0 == r2)
3195 AND_(r0, r1);
3196 else {
3197 movr(r0, r1);
3198 AND_(r0, r2);
3199 }
3200}
3201
3202static void
3203_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3204{
3205 movr(r0, r1);
3206 NILL(r0, x16(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));
3211#endif
3212}
3213
3214static void
3215_orr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3216{
3217 if (r0 == r2)
3218 OR_(r0, r1);
3219 else {
3220 movr(r0, r1);
3221 OR_(r0, r2);
3222 }
3223}
3224
3225static void
3226_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3227{
3228 movr(r0, r1);
3229 OILL(r0, x16(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));
3234#endif
3235}
3236
3237static void
3238_xorr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3239{
3240 if (r0 == r2)
3241 XOR_(r0, r1);
3242 else {
3243 movr(r0, r1);
3244 XOR_(r0, r2);
3245 }
3246}
3247
3248static void
3249_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3250{
3251 jit_int32_t reg;
3252 reg = jit_get_reg(jit_class_gpr);
3253 movi(rn(reg), i0);
3254 xorr(r0, r1, rn(reg));
3255 jit_unget_reg(reg);
3256}
3257
3258static void
3259_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3260{
3261 movi(r0, i0);
3262 ldr_c(r0, r0);
3263}
3264
3265static void
3266_ldxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3267{
3268 if (r0 == r2) {
3269 addr(r0, r0, r1);
3270 ldr_c(r0, r0);
3271 }
3272 else {
3273 movr(r0, r1);
3274 addr(r0, r0, r2);
3275 ldr_c(r0, r0);
3276 }
3277}
3278
3279static void
3280_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3281{
3282 jit_int32_t reg;
3283 if (s20_p(i0)) {
3284#if __WORDSIZE == 32
3285 LB(r0, x20(i0), 0, r1);
3286#else
3287 LGB(r0, x20(i0), 0, r1);
3288#endif
3289 }
3290 else if (r0 != r1) {
3291 movi(r0, i0);
3292 addr(r0, r0, r1);
3293 ldr_c(r0, r0);
3294 }
3295 else {
3296 reg = jit_get_reg_but_zero(0);
3297 movi(rn(reg), i0);
3298 addr(rn(reg), rn(reg), r1);
3299 ldr_c(r0, rn(reg));
3300 jit_unget_reg_but_zero(reg);
3301 }
3302}
3303
3304static void
3305_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3306{
3307 movi(r0, i0);
3308 ldr_uc(r0, r0);
3309}
3310
3311static void
3312_ldxr_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3313{
3314 if (r0 == r2) {
3315 addr(r0, r0, r1);
3316 ldr_uc(r0, r0);
3317 }
3318 else {
3319 movr(r0, r1);
3320 addr(r0, r0, r2);
3321 ldr_uc(r0, r0);
3322 }
3323}
3324
3325static void
3326_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3327{
3328 jit_int32_t reg;
3329 if (s20_p(i0))
3330 LLGC(r0, x20(i0), 0, r1);
3331 else if (r0 != r1) {
3332 movi(r0, i0);
3333 addr(r0, r0, r1);
3334 ldr_uc(r0, r0);
3335 }
3336 else {
3337 reg = jit_get_reg_but_zero(0);
3338 movi(rn(reg), i0);
3339 addr(rn(reg), rn(reg), r1);
3340 ldr_uc(r0, rn(reg));
3341 jit_unget_reg_but_zero(reg);
3342 }
3343}
3344
3345static void
3346_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3347{
3348 movi(r0, i0);
3349 ldr_s(r0, r0);
3350}
3351
3352static void
3353_ldxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3354{
3355 if (r0 == r2) {
3356 addr(r0, r0, r1);
3357 ldr_s(r0, r0);
3358 }
3359 else {
3360 movr(r0, r1);
3361 addr(r0, r0, r2);
3362 ldr_s(r0, r0);
3363 }
3364}
3365
3366static void
3367_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3368{
3369 jit_int32_t reg;
3370#if __WORDSIZE == 32
3371 if (u12_p(i0))
3372 LH(r0, i0, 0, r1);
3373 else
3374#endif
3375 if (s20_p(i0)) {
3376#if __WORDSIZE == 32
3377 LHY(r0, x20(i0), 0, r1);
3378#else
3379 LGH(r0, x20(i0), 0, r1);
3380#endif
3381 }
3382 else if (r0 != r1) {
3383 movi(r0, i0);
3384 addr(r0, r0, r1);
3385 ldr_s(r0, r0);
3386 }
3387 else {
3388 reg = jit_get_reg_but_zero(0);
3389 movi(rn(reg), i0);
3390 addr(rn(reg), rn(reg), r1);
3391 ldr_s(r0, rn(reg));
3392 jit_unget_reg_but_zero(reg);
3393 }
3394}
3395
3396static void
3397_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3398{
3399 movi(r0, i0);
3400 ldr_us(r0, r0);
3401}
3402
3403static void
3404_ldxr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3405{
3406 if (r0 == r2) {
3407 addr(r0, r0, r1);
3408 ldr_us(r0, r0);
3409 }
3410 else {
3411 movr(r0, r1);
3412 addr(r0, r0, r2);
3413 ldr_us(r0, r0);
3414 }
3415}
3416
3417static void
3418_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3419{
3420 jit_int32_t reg;
3421 if (s20_p(i0))
3422 LLGH(r0, x20(i0), 0, r1);
3423 else if (r0 != r1) {
3424 movi(r0, i0);
3425 addr(r0, r0, r1);
3426 ldr_us(r0, r0);
3427 }
3428 else {
3429 reg = jit_get_reg_but_zero(0);
3430 movi(rn(reg), i0);
3431 addr(rn(reg), rn(reg), r1);
3432 ldr_us(r0, rn(reg));
3433 jit_unget_reg_but_zero(reg);
3434 }
3435}
3436
3437static void
3438_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3439{
3440 movi(r0, i0);
3441 ldr_i(r0, r0);
3442}
3443
3444static void
3445_ldxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3446{
3447 if (r0 == r2) {
3448 addr(r0, r0, r1);
3449 ldr_i(r0, r0);
3450 }
3451 else {
3452 movr(r0, r1);
3453 addr(r0, r0, r2);
3454 ldr_i(r0, r0);
3455 }
3456}
3457
3458static void
3459_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3460{
3461 jit_int32_t reg;
3462 if (s20_p(i0))
3463 LGF(r0, x20(i0), 0, r1);
3464 else if (r0 != r1) {
3465 movi(r0, i0);
3466 addr(r0, r0, r1);
3467 ldr_i(r0, r0);
3468 }
3469 else {
3470 reg = jit_get_reg_but_zero(0);
3471 movi(rn(reg), i0);
3472 addr(rn(reg), rn(reg), r1);
3473 ldr_i(r0, rn(reg));
3474 jit_unget_reg_but_zero(reg);
3475 }
3476}
3477
3478#if __WORDSIZE == 64
3479static void
3480_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3481{
3482 movi(r0, i0);
3483 ldr_ui(r0, r0);
3484}
3485
3486static void
3487_ldxr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3488{
3489 if (r0 == r2) {
3490 addr(r0, r0, r1);
3491 ldr_ui(r0, r0);
3492 }
3493 else {
3494 movr(r0, r1);
3495 addr(r0, r0, r2);
3496 ldr_ui(r0, r0);
3497 }
3498}
3499
3500static void
3501_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3502{
3503 jit_int32_t reg;
3504 if (s20_p(i0))
3505 LLGF(r0, x20(i0), 0, r1);
3506 else if (r0 != r1) {
3507 movi(r0, i0);
3508 addr(r0, r0, r1);
3509 ldr_ui(r0, r0);
3510 }
3511 else {
3512 reg = jit_get_reg_but_zero(0);
3513 movi(rn(reg), i0);
3514 addr(rn(reg), rn(reg), r1);
3515 ldr_ui(r0, rn(reg));
3516 jit_unget_reg_but_zero(reg);
3517 }
3518}
3519
3520static void
3521_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
3522{
3523 movi(r0, i0);
3524 ldr_l(r0, r0);
3525}
3526
3527static void
3528_ldxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3529{
3530 if (r0 == r2) {
3531 addr(r0, r0, r1);
3532 ldr_l(r0, r0);
3533 }
3534 else {
3535 movr(r0, r1);
3536 addr(r0, r0, r2);
3537 ldr_l(r0, r0);
3538 }
3539}
3540
3541static void
3542_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
3543{
3544 jit_int32_t reg;
3545 if (s20_p(i0))
3546 LG(r0, x20(i0), 0, r1);
3547 else if (r0 != r1) {
3548 movi(r0, i0);
3549 addr(r0, r0, r1);
3550 ldr_l(r0, r0);
3551 }
3552 else {
3553 reg = jit_get_reg_but_zero(0);
3554 movi(rn(reg), i0);
3555 addr(rn(reg), rn(reg), r1);
3556 ldr_l(r0, rn(reg));
3557 jit_unget_reg_but_zero(reg);
3558 }
3559}
3560#endif
3561
3562static void
3563_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3564{
3565 jit_int32_t reg;
3566 reg = jit_get_reg_but_zero(0);
3567 movi(rn(reg), i0);
3568 str_c(rn(reg), r0);
3569 jit_unget_reg_but_zero(reg);
3570}
3571
3572static void
3573_stxr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3574{
3575 jit_int32_t reg;
3576 reg = jit_get_reg_but_zero(0);
3577 movr(rn(reg), r0);
3578 addr(rn(reg), rn(reg), r1);
3579 str_c(rn(reg), r2);
3580 jit_unget_reg_but_zero(reg);
3581}
3582
3583static void
3584_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3585{
3586 jit_int32_t reg;
3587 if (u12_p(i0))
3588 STC(r1, i0, 0, r0);
3589 else if (s20_p(i0))
3590 STCY(r1, x20(i0), 0, r0);
3591 else {
3592 reg = jit_get_reg_but_zero(0);
3593 addi(rn(reg), r0, i0);
3594 str_c(rn(reg), r1);
3595 jit_unget_reg_but_zero(reg);
3596 }
3597}
3598
3599static void
3600_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3601{
3602 jit_int32_t reg;
3603 reg = jit_get_reg_but_zero(0);
3604 movi(rn(reg), i0);
3605 str_s(rn(reg), r0);
3606 jit_unget_reg_but_zero(reg);
3607}
3608
3609static void
3610_stxr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3611{
3612 jit_int32_t reg;
3613 reg = jit_get_reg_but_zero(0);
3614 movr(rn(reg), r0);
3615 addr(rn(reg), rn(reg), r1);
3616 str_s(rn(reg), r2);
3617 jit_unget_reg_but_zero(reg);
3618}
3619
3620static void
3621_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3622{
3623 jit_int32_t reg;
3624 if (u12_p(i0))
3625 STH(r1, i0, 0, r0);
3626 else if (s20_p(i0))
3627 STHY(r1, x20(i0), 0, r0);
3628 else {
3629 reg = jit_get_reg_but_zero(0);
3630 addi(rn(reg), r0, i0);
3631 str_s(rn(reg), r1);
3632 jit_unget_reg_but_zero(reg);
3633 }
3634}
3635
3636static void
3637_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3638{
3639 jit_int32_t reg;
3640 reg = jit_get_reg_but_zero(0);
3641 movi(rn(reg), i0);
3642 str_i(rn(reg), r0);
3643 jit_unget_reg_but_zero(reg);
3644}
3645
3646static void
3647_stxr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3648{
3649 jit_int32_t reg;
3650 reg = jit_get_reg_but_zero(0);
3651 movr(rn(reg), r0);
3652 addr(rn(reg), rn(reg), r1);
3653 str_i(rn(reg), r2);
3654 jit_unget_reg_but_zero(reg);
3655}
3656
3657static void
3658_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3659{
3660 jit_int32_t reg;
3661 if (u12_p(i0))
3662 ST(r1, i0, 0, r0);
3663 else if (s20_p(i0))
3664 STY(r1, x20(i0), 0, r0);
3665 else {
3666 reg = jit_get_reg_but_zero(0);
3667 addi(rn(reg), r0, i0);
3668 str_i(rn(reg), r1);
3669 jit_unget_reg_but_zero(reg);
3670 }
3671}
3672
3673#if __WORDSIZE == 64
3674static void
3675_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
3676{
3677 jit_int32_t reg;
3678 reg = jit_get_reg_but_zero(0);
3679 movi(rn(reg), i0);
3680 str_l(rn(reg), r0);
3681 jit_unget_reg_but_zero(reg);
3682}
3683
3684static void
3685_stxr_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
3686{
3687 jit_int32_t reg;
3688 reg = jit_get_reg_but_zero(0);
3689 movr(rn(reg), r0);
3690 addr(rn(reg), rn(reg), r1);
3691 str_l(rn(reg), r2);
3692 jit_unget_reg_but_zero(reg);
3693}
3694
3695static void
3696_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
3697{
3698 jit_int32_t reg;
3699 if (s20_p(i0))
3700 STG(r1, x20(i0), 0, r0);
3701 else {
3702 reg = jit_get_reg_but_zero(0);
3703 addi(rn(reg), r0, i0);
3704 str_l(rn(reg), r1);
3705 jit_unget_reg_but_zero(reg);
3706 }
3707}
3708#endif
3709
79bfeef6
PC		 3710static jit_word_t
3711_jmpi(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
4a71579b 3712{
4a71579b 3713 jit_int32_t reg;
79bfeef6
PC		 3714 jit_word_t d, w;
3715 w = _jit->pc.w;
3716 d = (i0 - w) >> 1;
3717 if (i1 && s16_p(d))
4a71579b
PC		 3718 J(x16(d));
3719 else if (s32_p(d))
3720 BRL(d);
3721 else {
3722 reg = jit_get_reg_but_zero(jit_class_nospill);
3723 movi(rn(reg), i0);
3724 jmpr(rn(reg));
3725 jit_unget_reg_but_zero(reg);
3726 }
79bfeef6 3727 return (w);
4a71579b
PC		 3728}
3729
3730static jit_word_t
3731_jmpi_p(jit_state_t *_jit, jit_word_t i0)
3732{
3733 jit_word_t w;
3734 jit_int32_t reg;
3735 reg = jit_get_reg_but_zero(jit_class_nospill);
3736 w = movi_p(rn(reg), i0);
3737 jmpr(rn(reg));
3738 jit_unget_reg_but_zero(reg);
3739 return (w);
3740}
3741
79bfeef6
PC		 3742static jit_word_t
3743_calli(jit_state_t *_jit, jit_word_t i0, jit_bool_t i1)
4a71579b 3744{
4a71579b 3745 jit_int32_t reg;
79bfeef6
PC		 3746 jit_word_t d, w;
3747 w = _jit->pc.w;
3748 d = (i0 - w) >> 1;
3749 if (i1 && s16_p(d))
3750 BRAS(_R14_REGNO, x16(d));
3751 else if (s32_p(d))
4a71579b
PC		 3752 BRASL(_R14_REGNO, d);
3753 else {
3754 reg = jit_get_reg_but_zero(0);
3755 movi(rn(reg), i0);
3756 callr(rn(reg));
3757 jit_unget_reg_but_zero(reg);
3758 }
79bfeef6 3759 return (w);
4a71579b
PC		 3760}
3761
3762static jit_word_t
3763_calli_p(jit_state_t *_jit, jit_word_t i0)
3764{
3765 jit_word_t w;
3766 jit_int32_t reg;
3767 reg = jit_get_reg_but_zero(0);
3768 w = movi_p(rn(reg), i0);
3769 callr(rn(reg));
3770 jit_unget_reg_but_zero(reg);
3771 return (w);
3772}
3773
3774static jit_int32_t gprs[] = {
3775 _R2, _R3, _R4, _R5,
3776 _R6, _R7, _R8, _R9, _R10, _R11, _R12, _R13
3777};
3778
3779static void
3780_prolog(jit_state_t *_jit, jit_node_t *i0)
3781{
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)
3787 return;
3788 _jitc->function->self.aoff = frame;
3789 }
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
3797 * in registers.
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.
3807 */
3808 if ((_jitc->function->self.call & jit_call_varargs) &&
3809 jit_arg_reg_p(_jitc->function->vagp))
3810 regno = _jitc->function->vagp;
3811 else {
3812 for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3813 if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3814 break;
3815 }
3816 }
3817#if __WORDSIZE == 32
3818# define FP_OFFSET 64
3819 if (_jitc->function->self.call & jit_call_varargs)
3820 offset = regno * 4 + 8;
3821 else
3822 offset = (regno - 4) * 4 + 32;
3823 STM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3824#else
3825# define FP_OFFSET 128
3826 if (_jitc->function->self.call & jit_call_varargs)
3827 offset = regno * 8 + 16;
3828 else
3829 offset = (regno - 4) * 8 + 48;
3830 STMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3831#endif
3832
3833#define SPILL(R, O) \
3834 do { \
3835 if (jit_regset_tstbit(&_jitc->function->regset, R)) \
3836 stxi_d(O, _R15_REGNO, rn(R)); \
3837 } while (0)
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));
3848 }
3849 else {
3850 /* First 4 in low address */
3851#if __WORDSIZE == 32
3852 SPILL(_F10, 0);
3853 SPILL(_F11, 8);
3854 SPILL(_F12, 16);
3855 SPILL(_F13, 24);
3856 /* gpr registers here */
3857 SPILL(_F14, 72);
3858 SPILL(_F8, 80);
3859 SPILL(_F9, 88);
3860#else
3861 SPILL(_F10, 16);
3862 SPILL(_F11, 24);
3863 SPILL(_F12, 32);
3864 SPILL(_F13, 48);
3865 /* Last 3 in high address */
3866 SPILL(_F14, 136);
3867 SPILL(_F8, 144);
3868 SPILL(_F9, 152);
3869#endif
3870 }
3871#undef SPILL
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);
3879 }
3880}
3881
3882static void
3883_epilog(jit_state_t *_jit, jit_node_t *i0)
3884{
3885 jit_int32_t regno, offset;
3886 if (_jitc->function->assume_frame)
3887 return;
3888 if ((_jitc->function->self.call & jit_call_varargs) &&
3889 jit_arg_reg_p(_jitc->function->vagp))
3890 regno = _jitc->function->vagp;
3891 else {
3892 for (regno = 4; regno < jit_size(gprs) - 1; regno++) {
3893 if (jit_regset_tstbit(&_jitc->function->regset, gprs[regno]))
3894 break;
3895 }
3896 }
3897#if __WORDSIZE == 32
3898 if (_jitc->function->self.call & jit_call_varargs)
3899 offset = regno * 4 + 8;
3900 else
3901 offset = (regno - 4) * 4 + 32;
3902#else
3903 if (_jitc->function->self.call & jit_call_varargs)
3904 offset = regno * 8 + 16;
3905 else
3906 offset = (regno - 4) * 8 + 48;
3907#endif
3908 movr(_R15_REGNO, _R13_REGNO);
3909
3910#define LOAD(R, O) \
3911 do { \
3912 if (jit_regset_tstbit(&_jitc->function->regset, R)) \
3913 ldxi_d(rn(R), _R15_REGNO, O); \
3914 } while (0)
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));
3923 }
3924 else {
3925#if __WORDSIZE == 32
3926 LOAD(_F10, 0);
3927 LOAD(_F11, 8);
3928 LOAD(_F12, 16);
3929 LOAD(_F13, 24);
3930 LOAD(_F14, 72);
3931 LOAD(_F8, 80);
3932 LOAD(_F9, 88);
3933#else
3934 LOAD(_F10, 16);
3935 LOAD(_F11, 24);
3936 LOAD(_F12, 32);
3937 LOAD(_F13, 48);
3938 LOAD(_F14, 136);
3939 LOAD(_F8, 144);
3940 LOAD(_F9, 152);
3941#endif
3942 }
3943#undef LOAD
3944#if __WORDSIZE == 32
3945 LM(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3946#else
3947 LMG(rn(gprs[regno]), _R15_REGNO, x20(offset), _R15_REGNO);
3948#endif
3949 BR(_R14_REGNO);
3950}
3951
3952static void
3953_vastart(jit_state_t *_jit, jit_int32_t r0)
3954{
3955 jit_int32_t reg;
3956
3957 assert(_jitc->function->self.call & jit_call_varargs);
3958
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);
3962
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));
3966
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));
3970
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));
3974
3975 /* Initialize register save area pointer. */
3976 stxi(offsetof(jit_va_list_t, save), r0, _R13_REGNO);
3977
3978 jit_unget_reg(reg);
3979}
3980
3981static void
3982_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
3983{
3984 jit_int32_t rg0;
3985 jit_int32_t rg1;
3986 jit_int32_t rg2;
3987 jit_word_t ge_code;
3988 jit_word_t lt_code;
3989
3990 assert(_jitc->function->self.call & jit_call_varargs);
3991
3992 rg0 = jit_get_reg_but_zero(0);
3993 rg1 = jit_get_reg_but_zero(0);
3994
3995 /* Load the gp offset in save area in the first temporary. */
3996 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, gpoff));
3997
3998 /* Jump over if there are no remaining arguments in the save area. */
3999 ge_code = bgei_p(_jit->pc.w, rn(rg0), 5);
4000
4001 /* Load the save area pointer in the second temporary. */
4002 ldxi(rn(rg1), r1, offsetof(jit_va_list_t, save));
4003
4004 /* Scale offset */
4005 rg2 = jit_get_reg_but_zero(0);
4006 lshi(rn(rg2), rn(rg0),
4007#if __WORDSIZE == 32
4008 2
4009#else
4010 3
4011#endif
4012 );
4013 /* Add offset to saved area. */
4014 addi(rn(rg2), rn(rg2), 2 * sizeof(jit_word_t));
4015
4016 /* Load the vararg argument in the first argument. */
4017 ldxr(r0, rn(rg1), rn(rg2));
4018 jit_unget_reg_but_zero(rg2);
4019
4020 /* Update the gp offset. */
4021 addi(rn(rg0), rn(rg0), 1);
4022 stxi(offsetof(jit_va_list_t, gpoff), r1, rn(rg0));
4023
4024 /* Will only need one temporary register below. */
4025 jit_unget_reg_but_zero(rg1);
4026
4027 /* Jump over overflow code. */
4028 lt_code = jmpi_p(_jit->pc.w);
4029
4030 /* Where to land if argument is in overflow area. */
4031 patch_at(ge_code, _jit->pc.w);
4032
4033 /* Load overflow pointer. */
4034 ldxi(rn(rg0), r1, offsetof(jit_va_list_t, over));
4035
4036 /* Load argument. */
4037 ldr(r0, rn(rg0));
4038
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));
4042
4043 /* Where to land if argument is in save area. */
4044 patch_at(lt_code, _jit->pc.w);
4045
4046 jit_unget_reg_but_zero(rg0);
4047}
4048
4049static void
4050_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
4051{
4052 jit_word_t d;
4053 union {
4054 jit_uint16_t *s;
4055 jit_word_t w;
4056 } u;
4057 u.w = instr;
4058 union {
4059 struct {
4060 jit_uint16_t op : 8;
4061 jit_uint16_t r1 : 4;
4062 jit_uint16_t r3 : 4;
4063 } b;
4064 jit_uint16_t s;
4065 } i0;
4066 union {
4067 struct {
4068 jit_uint16_t i2;
4069 } b;
4070 jit_uint16_t s;
4071 } i1;
4072 union {
4073 struct {
4074 jit_uint32_t ih : 16;
4075 jit_uint32_t il : 16;
4076 } b;
4077 jit_uint32_t i;
4078 } i12;
4079 i0.s = u.s[0];
4080 /* movi_p */
4081 if (i0.b.op ==
4082#if __WORDSIZE == 32
4083 0xA7 && i0.b.r3 == 8
4084#else
4085 0xA5
4086#endif
4087 ) {
4088#if __WORDSIZE == 64
4089 assert(i0.b.r3 == 3);
4090#endif
4091 i1.b.i2 = (jit_uword_t)label;
4092 u.s[1] = i1.s;
4093 i0.s = u.s[2];
4094 assert(i0.b.op == 0xA5 && i0.b.r3 == 2);
4095 i1.b.i2 = (jit_uword_t)label >> 16;
4096 u.s[3] = i1.s;
4097#if __WORDSIZE == 64
4098 i0.s = u.s[4];
4099 assert(i0.b.op == 0xA5 && i0.b.r3 == 1);
4100 i1.b.i2 = (jit_uword_t)label >> 32;
4101 u.s[5] = i1.s;
4102 i0.s = u.s[6];
4103 assert(i0.b.op == 0xA5 && i0.b.r3 == 0);
4104 i1.b.i2 = (jit_uword_t)label >> 48;
4105 u.s[7] = i1.s;
4106#endif
4107 }
79bfeef6 4108 /* BRC or BRL */
4a71579b 4109 else if (i0.b.op == 0xA7) {
79bfeef6 4110 assert(i0.b.r3 == 0x4 || i0.b.r3 == 0x5);
4a71579b
PC		 4111 d = (label - instr) >> 1;
4112 assert(s16_p(d));
4113 i1.b.i2 = d;
4114 u.s[1] = i1.s;
4115 }
79bfeef6 4116 /* BRCL or BRASL */
4a71579b 4117 else if (i0.b.op == 0xC0) {
79bfeef6 4118 assert(i0.b.r3 == 0x4 || i0.b.r3 == 0x5);
4a71579b
PC		 4119 d = (label - instr) >> 1;
4120 assert(s32_p(d));
4121 i12.i = d;
4122 u.s[1] = i12.b.ih;
4123 u.s[2] = i12.b.il;
4124 }
4125 else
4126 abort();
4127}
4128#endif
ARM optimized PCSX fork