notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update libchdr
[pcsx_rearmed.git] / deps / lightning / lib / jit_sparc-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# define _G2_REGNO 0x02
22# define _G3_REGNO 0x03
23# define _G4_REGNO 0x04
24# define _O0_REGNO 0x08
25# define _O1_REGNO 0x09
26# define _SP_REGNO 0x0e
27# define _FP_REGNO 0x1e
28# define _O7_REGNO 0x0f
29# define _L0_REGNO 0x10
30# define _L1_REGNO 0x11
31# define _L2_REGNO 0x12
32# define _L3_REGNO 0x13
33# define _L4_REGNO 0x14
34# define _L5_REGNO 0x15
35# define _L6_REGNO 0x16
36# define _L7_REGNO 0x17
37# define _I7_REGNO 0x1f
38/*
39 * - previous stack frame
40 * fp ----
41 * fp- local variables (in lightning, 8 bytes space for float conversion)
42 * fp- alloca
43 * sp+ stack arguments
44 * sp+ 6 words to save register arguments
45 * sp+ 1 word for hidden address of aggregate return value (32 bits only)
46 * sp+ 16 words for in and local registers
47 * sp ----
48 * decreasing memory address - next stack frame (not yet allocated)
49 */
50# define stack_framesize ((16 + (__WORDSIZE == 32) + 6) * sizeof(jit_word_t))
51typedef union {
52 struct { jit_uint32_t b: 2; } op;
53 struct { jit_uint32_t _: 2; jit_uint32_t b: 1; } a;
54 struct { jit_uint32_t _: 2; jit_uint32_t b: 5; } rd;
55 struct { jit_uint32_t _: 2; jit_uint32_t b: 30; } disp30;
56 struct { jit_uint32_t _: 3; jit_uint32_t b: 4; } cond;
57 struct { jit_uint32_t _: 7; jit_uint32_t b: 3; } op2;
58 struct { jit_uint32_t _: 7; jit_uint32_t b: 6; } op3;
59 struct { jit_uint32_t _: 10; jit_uint32_t b: 1; } cc1;
60 struct { jit_uint32_t _: 10; jit_uint32_t b: 22; } imm22;
61 struct { jit_uint32_t _: 10; jit_uint32_t b: 22; } disp22;
62 struct { jit_uint32_t _: 11; jit_uint32_t b: 1; } cc0;
63 struct { jit_uint32_t _: 12; jit_uint32_t b: 1; } p;
64 struct { jit_uint32_t _: 13; jit_uint32_t b: 19; } disp19;
65 struct { jit_uint32_t _: 13; jit_uint32_t b: 5; } rs1;
66 struct { jit_uint32_t _: 18; jit_uint32_t b: 1; } i;
67 struct { jit_uint32_t _: 18; jit_uint32_t b: 9; } opf;
68 struct { jit_uint32_t _: 19; jit_uint32_t b: 1; } x;
69 struct { jit_uint32_t _: 19; jit_uint32_t b: 8; } asi;
70 struct { jit_uint32_t _: 19; jit_uint32_t b: 6; } res;
71 struct { jit_uint32_t _: 19; jit_uint32_t b: 13; } simm13;
72 struct { jit_uint32_t _: 20; jit_uint32_t b: 7; } asix;
73 struct { jit_uint32_t _: 20; jit_uint32_t b: 6; } asis;
74 struct { jit_uint32_t _: 26; jit_uint32_t b: 6; } shim;
75 struct { jit_uint32_t _: 25; jit_uint32_t b: 7; } imm7;
76 struct { jit_uint32_t _: 27; jit_uint32_t b: 5; } rs2;
77 jit_int32_t v;
78} jit_instr_t;
79# define ii(i) *_jit->pc.ui++ = i
80# define s7_p(imm) ((imm) <= 63 && (imm) >= -64)
81# define s13_p(imm) ((imm) <= 4095 && (imm) >= -4096)
82# define s19_p(imm) ((imm) <= 262143 && (imm) >= -262144)
83# define s22_p(imm) ((imm) <= 2097151 && (imm) >= -20971512)
84# define s30_p(imm) ((imm) <= 536870911 && (imm) >= -536870912)
85# define f1(op, disp30) _f1(_jit, op, disp30)
86static void _f1(jit_state_t*,jit_int32_t,jit_int32_t);
87# define f2r(op, rd, op2, imm22) _f2r(_jit, op, rd, op2, imm22)
88static void _f2r(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
89# define f2b(op, a, cond, op2, disp22) _f2b(_jit, op, a, cond, op2, disp22)
90static void
91_f2b(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
92# if __WORDSIZE == 64
93# define f2bp(op,a,cond,op2,cc1,cc0,p,disp19) \
94 _f2bp(_jit,op,a,cond,op2,cc1,cc0,p,disp19)
95static void
96_f2bp(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,
97 jit_int32_t,jit_int32_t,jit_int32_t);
98# endif
99# define f3r(op, rd, op3, rs1, rs2) _f3r(_jit, op, rd, op3, rs1, rs2)
100static void _f3r(jit_state_t*,
101 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
102# if __WORDSIZE == 64
c0c16242
PC		 103# define f3ri(op, rd, op3, rs1, rs2) _f3ri(_jit, op, rd, op3, rs1, rs2)
104static void _f3ri(jit_state_t*,
105 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
4a71579b
PC		 106# define f3rx(op, rd, op3, rs1, rs2) _f3rx(_jit, op, rd, op3, rs1, rs2)
107static void _f3rx(jit_state_t*,
108 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
109# endif
110# define f3i(op, rd, op3, rs1, simm13) _f3i(_jit, op, rd, op3, rs1, simm13)
111static void _f3i(jit_state_t*,
112 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
113# define f3s(op, rd, op3, rs1, simm13) _f3s(_jit, op, rd, op3, rs1, simm13)
114static void _f3s(jit_state_t*,
115 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
116# define f3t(cond, rs1, i, ri) _f3t(_jit, cond, rs1, i, ri)
117static void _f3t(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
118 maybe_unused;
c0c16242 119# define f3a(op,rd,op3,rs1,asi,rs2) _f3a(_jit, op, rd, op3, rs1, asi, rs2)
4a71579b
PC		 120static void _f3a(jit_state_t*,jit_int32_t,
121 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
122 maybe_unused;
79bfeef6
PC		 123# define f2c1(op,rd,op3,rs1,opf,rs2) _f2c1(_jit,op,rd,op3,rs1,opf,rs2)
124static void
125_f2c1(jit_state_t*,jit_int32_t, jit_int32_t,
126 jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t)
127 maybe_unused;
4a71579b
PC		 128# define LDSB(rs1, rs2, rd) f3r(3, rd, 9, rs1, rs2)
129# define LDSBI(rs1, imm, rd) f3i(3, rd, 9, rs1, imm)
130# define LDSH(rs1, rs2, rd) f3r(3, rd, 10, rs1, rs2)
131# define LDSHI(rs1, imm, rd) f3i(3, rd, 10, rs1, imm)
132# define LDUB(rs1, rs2, rd) f3r(3, rd, 1, rs1, rs2)
133# define LDUBI(rs1, imm, rd) f3i(3, rd, 1, rs1, imm)
134# define LDUH(rs1, rs2, rd) f3r(3, rd, 2, rs1, rs2)
135# define LDUHI(rs1, imm, rd) f3i(3, rd, 2, rs1, imm)
136# if __WORDSIZE == 32
137# define LD(rs1, rs2, rd) f3r(3, rd, 0, rs1, rs2)
138# define LDI(rs1, imm, rd) f3i(3, rd, 0, rs1, imm)
139# define LDD(rs1, rs2, rd) f3r(3, rd, 3, rs1, rs2)
140# define LDDI(rs1, imm, rd) f3i(3, rd, 3, rs1, imm)
141# else
142# define LDSW(rs1, rs2, rd) f3r(3, rd, 8, rs1, rs2)
143# define LDSWI(rs1, imm, rd) f3i(3, rd, 8, rs1, imm)
144# define LDUW(rs1, rs2, rd) f3r(3, rd, 0, rs1, rs2)
145# define LDUWI(rs1, imm, rd) f3i(3, rd, 0, rs1, imm)
146# define LDX(rs1, rs2, rd) f3r(3, rd, 11, rs1, rs2)
147# define LDXI(rs1, imm, rd) f3i(3, rd, 11, rs1, imm)
148# endif
149# define LDSBA(rs1, rs2, asi, rd) f3a(3, rd, 25, rs1, asi, rs2)
150# define LDSHA(rs1, rs2, asi, rd) f3a(3, rd, 26, rs1, asi, rs2)
151# define LDUBA(rs1, rs2, asi, rd) f3a(3, rd, 17, rs1, asi, rs2)
152# define LDUHA(rs1, rs2, asi, rd) f3a(3, rd, 18, rs1, asi, rs2)
153# if __WORDSIZE == 32
154# define LDA(rs1, rs2, asi, rd) f3a(3, rd, 16, rs1, asi, rs2)
155# define LDDA(rs1, rs2, asi, rd) f3a(3, rd, 19, rs1, asi, rs2)
156# else
157# define LDSWA(rs1, rs2, asi, rd) f3a(3, rd, 24, rs1, asi, rs2)
158# define LDUWA(rs1, rs2, asi, rd) f3a(3, rd, 16, rs1, asi, rs2)
159# define LDXA(rs1, rs2, asi, rd) f3a(3, rd, 27, rs1, asi, rs2)
160# endif
161# define LDC(rs1, rs2, rd) f3r(3, rd, 48, rs1, rs2)
162# define LDCI(rs1, imm, rd) f3i(3, rd, 48, rs1, imm)
163# define LDDC(rs1, rs2, rd) f3r(3, rd, 51, rs1, rs2)
164# define LDDCI(rs1, imm, rd) f3i(3, rd, 51, rs1, imm)
165# define LDCSR(rs1, rs2, rd) f3r(3, rd, 49, rs1, rs2)
166# define LDCSRI(rs1, imm, rd) f3i(3, rd, 49, rs1, imm)
167# define STB(rd, rs1, rs2) f3r(3, rd, 5, rs1, rs2)
168# define STBI(rd, rs1, imm) f3i(3, rd, 5, rs1, imm)
169# define STH(rd, rs1, rs2) f3r(3, rd, 6, rs1, rs2)
170# define STHI(rd, rs1, imm) f3i(3, rd, 6, rs1, imm)
171# if __WORDSIZE == 32
172# define ST(rd, rs1, rs2) f3r(3, rd, 4, rs1, rs2)
173# define STI(rd, rs1, imm) f3i(3, rd, 4, rs1, imm)
174# define STD(rrd, s1, rs2) f3r(3, rd, 7, rs1, rs2)
175# define STDI(rd, rs1, imm) f3i(3, rd, 7, rs1, imm)
176# else
177# define STW(rd, rs1, rs2) f3r(3, rd, 4, rs1, rs2)
178# define STWI(rd, rs1, imm) f3i(3, rd, 4, rs1, imm)
179# define STX(rd, rs1, rs2) f3r(3, rd, 14, rs1, rs2)
180# define STXI(rd, rs1, imm) f3i(3, rd, 14, rs1, imm)
181# endif
182# define STBA(rd, rs1, rs2) f3a(3, rd, 21, rs1, asi, rs2)
183# define STHA(rd, rs1, rs2) f3a(3, rd, 22, rs1, asi, rs2)
184# if __WORDSIZE == 32
185# define STA(rd, rs1, rs2) f3a(3, rd, 20, rs1, asi, rs2)
186# define STDA(rd, rs1, rs2) f3a(3, rd, 23, rs1, asi, rs2)
187# else
188# define STWA(rd, rs1, rs2) f3a(3, rd, 20, rs1, asi, rs2)
189# define STXA(rd, rs1, rs2) f3a(3, rd, 30, rs1, asi, rs2)
190# endif
191# define STC(rd, rs1, rs2) f3r(3, rd, 52, rs1, rs2)
192# define STCI(rd, rs1, imm) f3i(3, rd, 52, rs1, imm)
193# define STDC(rd, rs1, rs2) f3r(3, rd, 55, rs1, rs2)
194# define STDCI(rd, rs1, imm) f3i(3, rd, 55, rs1, imm)
195# define STCSR(rd, rs1, rs2) f3r(3, rd, 53, rs1, rs2)
196# define STCSRI(rd, rs1, imm) f3i(3, rd, 53, rs1, imm)
197# define STDCQ(rd, rs1, rs2) f3r(3, rd, 54, rs1, rs2)
198# define STDCQI(rd, rs1, imm) f3i(3, rd, 54, rs1, imm)
199# define LDSTUB(rs1, rs2, rd) f3r(3, rd, 13, rs1, rs2)
200# define LDSTUBI(rs1, imm, rd) f3r(3, rd, 13, rs1, imm)
201# define LDSTUBA(rs1, rs2, asi, rd) f3a(3, rd, 21, rs1, asi, rs2)
202# define SWAP(rs1, rs2, rd) f3r(3, rd, 15, rs1, rs2)
203# define SWAPI(rs1, imm, rd) f3r(3, rd, 15, rs1, imm)
204# define SWAPA(rs1, rs2, asi, rd) f3a(3, rd, 23, rs1, asi, rs2)
c0c16242
PC		 205/* Sparc v9 deprecates SWAP* in favor of CAS*A */
206# define CASA(rs1, rs2, rd) f3a(3, rd, 60, rs1, 128, rs2)
207# if __WORDSIZE == 64
208# define CASXA(rs1, rs2, rd) f3a(3, rd, 62, rs1, 128, rs2)
209# endif
4a71579b
PC		 210# define NOP() SETHI(0, 0)
211# define HI(im) ((im) >> 10)
212# define LO(im) ((im) & 0x3ff)
213# define SETHI(im, rd) f2r(0, rd, 4, im)
214# define AND(rs1, rs2, rd) f3r(2, rd, 1, rs1, rs2)
215# define ANDI(rs1, imm, rd) f3i(2, rd, 1, rs1, imm)
216# define ANDcc(rs1, rs2, rd) f3r(2, rd, 17, rs1, rs2)
217# define ANDIcc(rs1, imm, rd) f3i(2, rd, 17, rs1, imm)
218# define BTST(rs1, rs2) ANDcc(rs1, rs2, 0)
219# define BTSTI(rs1, imm) ANDIcc(rs1, imm, 0)
220# define ANDN(rs1, rs2, rd) f3r(2, rd, 5, rs1, rs2)
221# define ANDNI(rs1, imm, rd) f3i(2, rd, 5, rs1, imm)
222# define ANDNcc(rs1, rs2, rd) f3r(2, rd, 21, rs1, rs2)
223# define ANDNIcc(rs1, imm, rd) f3i(2, rd, 21, rs1, imm)
224# define OR(rs1, rs2, rd) f3r(2, rd, 2, rs1, rs2)
225# define ORI(rs1, imm, rd) f3i(2, rd, 2, rs1, imm)
226# define ORcc(rs1, rs2, rd) f3r(2, rd, 18, rs1, rs2)
227# define ORIcc(rs1, imm, rd) f3i(2, rd, 18, rs1, imm)
228# define ORN(rs1, rs2, rd) f3r(2, rd, 6, rs1, rs2)
229# define ORNI(rs1, imm, rd) f3i(2, rd, 6, rs1, imm)
230# define ORNcc(rs1, rs2, rd) f3r(2, rd, 22, rs1, rs2)
231# define ORNIcc(rs1, imm, rd) f3i(2, rd, 22, rs1, imm)
232# define XOR(rs1, rs2, rd) f3r(2, rd, 3, rs1, rs2)
233# define XORI(rs1, imm, rd) f3i(2, rd, 3, rs1, imm)
234# define XORcc(rs1, rs2, rd) f3r(2, rd, 19, rs1, rs2)
235# define XORIcc(rs1, imm, rd) f3i(2, rd, 19, rs1, imm)
236# define XNOR(rs1, rs2, rd) f3r(2, rd, 7, rs1, rs2)
237# define XNORI(rs1, imm, rd) f3i(2, rd, 7, rs1, imm)
238# define XNORcc(rs1, rs2, rd) f3r(2, rd, 23, rs1, rs2)
239# define XNORIcc(rs1, imm, rd) f3i(2, rd, 23, rs1, imm)
240# define SLL(rs1, rs2, rd) f3r(2, rd, 37, rs1, rs2)
241# define SLLI(rs1, imm, rd) f3i(2, rd, 37, rs1, imm)
242# define SRL(rs1, rs2, rd) f3r(2, rd, 38, rs1, rs2)
243# define SRLI(rs1, imm, rd) f3i(2, rd, 38, rs1, imm)
244# define SRA(rs1, rs2, rd) f3r(2, rd, 39, rs1, rs2)
245# define SRAI(rs1, imm, rd) f3i(2, rd, 39, rs1, imm)
246# if __WORDSIZE == 64
247# define SLLX(rs1, rs2, rd) f3rx(2, rd, 37, rs1, rs2)
248# define SLLXI(rs1, imm, rd) f3s(2, rd, 37, rs1, imm)
249# define SRLX(rs1, rs2, rd) f3rx(2, rd, 38, rs1, rs2)
250# define SRLXI(rs1, imm, rd) f3s(2, rd, 38, rs1, imm)
251# define SRAX(rs1, rs2, rd) f3rx(2, rd, 39, rs1, rs2)
252# define SRAXI(rs1, imm, rd) f3s(2, rd, 39, rs1, imm)
253# endif
254# define ADD(rs1, rs2, rd) f3r(2, rd, 0, rs1, rs2)
255# define ADDI(rs1, imm, rd) f3i(2, rd, 0, rs1, imm)
256# define ADDcc(rs1, rs2, rd) f3r(2, rd, 16, rs1, rs2)
257# define ADDIcc(rs1, imm, rd) f3i(2, rd, 16, rs1, imm)
258# define ADDX(rs1, rs2, rd) f3r(2, rd, 8, rs1, rs2)
259# define ADDXI(rs1, imm, rd) f3i(2, rd, 8, rs1, imm)
260# define ADDXcc(rs1, rs2, rd) f3r(2, rd, 24, rs1, rs2)
261# define ADDXIcc(rs1, imm, rd) f3i(2, rd, 24, rs1, imm)
262# define TADDcc(rs1, rs2, rd) f3r(2, rd, 32, rs1, rs2)
263# define TADDIcc(rs1, imm, rd) f3i(2, rd, 32, rs1, imm)
264# define TADDccTV(rs1, rs2, rd) f3r(2, rd, 34, rs1, rs2)
265# define TADDIccTV(rs1, imm, rd) f3i(2, rd, 34, rs1, imm)
266# define SUB(rs1, rs2, rd) f3r(2, rd, 4, rs1, rs2)
267# define NEG(rs1, rd) SUB(0, rs1, rd)
268# define SUBI(rs1, imm, rd) f3i(2, rd, 4, rs1, imm)
269# define SUBcc(rs1, rs2, rd) f3r(2, rd, 20, rs1, rs2)
270# define SUBIcc(rs1, imm, rd) f3i(2, rd, 20, rs1, imm)
271# define CMP(rs1, rs2) SUBcc(rs1, rs2, 0)
272# define CMPI(rs1, imm) SUBIcc(rs1, imm, 0)
273# define SUBX(rs1, rs2, rd) f3r(2, rd, 12, rs1, rs2)
274# define SUBXI(rs1, imm, rd) f3i(2, rd, 12, rs1, imm)
275# define SUBXcc(rs1, rs2, rd) f3r(2, rd, 28, rs1, rs2)
276# define SUBXIcc(rs1, imm, rd) f3i(2, rd, 28, rs1, imm)
277# define TSUBcc(rs1, rs2, rd) f3r(2, rd, 33, rs1, rs2)
278# define TDADDIcc(rs1, imm, rd) f3i(2, rd, 33, rs1, imm)
279# define TSUBccTV(rs1, rs2, rd) f3r(2, rd, 35, rs1, rs2)
280# define TSUBIccTV(rs1, imm, rd) f3i(2, rd, 35, rs1, imm)
281# define MULScc(rs1, rs2, rd) f3r(2, rd, 36, rs1, rs2)
282# define MULSIcc(rs1, imm, rd) f3i(2, rd, 36, rs1, imm)
283# define UMUL(rs1, rs2, rd) f3r(2, rd, 10, rs1, rs2)
284# define UMULI(rs1, imm, rd) f3i(2, rd, 10, rs1, imm)
285# define SMUL(rs1, rs2, rd) f3r(2, rd, 11, rs1, rs2)
286# define SMULI(rs1, imm, rd) f3i(2, rd, 11, rs1, imm)
287# define UMULcc(rs1, rs2, rd) f3r(2, rd, 26, rs1, rs2)
288# define UMULIcc(rs1, imm, rd) f3i(2, rd, 26, rs1, imm)
289# define SMULcc(rs1, rs2, rd) f3r(2, rd, 27, rs1, rs2)
290# define SMULIcc(rs1, imm, rd) f3i(2, rd, 27, rs1, imm)
291# define UDIV(rs1, rs2, rd) f3r(2, rd, 14, rs1, rs2)
292# define UDIVI(rs1, imm, rd) f3i(2, rd, 14, rs1, imm)
293# define SDIV(rs1, rs2, rd) f3r(2, rd, 15, rs1, rs2)
294# define SDIVI(rs1, imm, rd) f3i(2, rd, 15, rs1, imm)
295# define UDIVcc(rs1, rs2, rd) f3r(2, rd, 30, rs1, rs2)
296# define UDIVIcc(rs1, imm, rd) f3i(2, rd, 30, rs1, imm)
297# define SDIVcc(rs1, rs2, rd) f3r(2, rd, 31, rs1, rs2)
298# define SDIVIcc(rs1, imm, rd) f3i(2, rd, 31, rs1, imm)
299# if __WORDSIZE == 64
300# define MULX(rs1, rs2, rd) f3r(2, rd, 9, rs1, rs2)
301# define MULXI(rs1, imm, rd) f3i(2, rd, 9, rs1, imm)
302# define SDIVX(rs1, rs2, rd) f3r(2, rd, 45, rs1, rs2)
303# define SDIVXI(rs1, imm, rd) f3i(2, rd, 45, rs1, imm)
304# define UDIVX(rs1, rs2, rd) f3r(2, rd, 13, rs1, rs2)
305# define UDIVXI(rs1, imm, rd) f3i(2, rd, 13, rs1, imm)
306# endif
307# define SAVE(rs1, rs2, rd) f3r(2, rd, 60, rs1, rs2)
308# define SAVEI(rs1, imm, rd) f3i(2, rd, 60, rs1, imm)
309# define RESTORE(rs1, rs2, rd) f3r(2, rd, 61, rs1, rs2)
310# define RESTOREI(rs1, imm, rd) f3i(2, rd, 61, rs1, imm)
311# define SPARC_BA 8 /* always */
312# define SPARC_BN 0 /* never */
313# define SPARC_BNE 9 /* not equal - not Z */
314# define SPARC_BNZ SPARC_BNE
315# define SPARC_BE 1 /* equal - Z */
316# define SPARC_BZ SPARC_BE
317# define SPARC_BG 10 /* greater - not (Z or (N xor V)) */
318# define SPARC_BLE 2 /* less or equal - Z or (N xor V) */
319# define SPARC_BGE 11 /* greater or equal - not (N xor V) */
320# define SPARC_BL 3 /* less - N xor V */
321# define SPARC_BGU 12 /* greater unsigned - not (C or Z) */
322# define SPARC_BLEU 4 /* less or equal unsigned - C or Z */
323# define SPARC_BCC 13 /* carry clear - not C */
324# define SPARC_BGEU SPARC_BCC
325# define SPARC_BCS 5 /* carry set - C */
326# define SPARC_BLU SPARC_BCS
327# define SPARC_BPOS 14 /* positive - not N */
328# define SPARC_BNEG 6 /* negative - N */
329# define SPARC_BVC 15 /* overflow clear - not V */
330# define SPARC_BVS 7 /* overflow set - V */
331/* Preferred BPcc integer branch opcodes */
332# if __WORDSIZE == 64
333# define SPARC_BPA 8 /* always - 1 */
334# define SPARC_BPN 0 /* never - 0 */
335# define SPARC_BPNE 9 /* not equal - not Z */
336# define SPARC_BPE 1 /* equal - Z */
337# define SPARC_BPG 10 /* greater - not (Z or (N xor V)) */
338# define SPARC_BPLE 2 /* less or equal - Z or (N xor V) */
339# define SPARC_BPGE 11 /* greater or equal - not (N xor V) */
340# define SPARC_BPL 3 /* less - N xor V */
341# define SPARC_BPGU 12 /* greater unsigned - not (C or V) */
342# define SPARC_BPLEU 4 /* less or equal unsigned - C or Z */
343# define SPARC_BPCC 13 /* carry clear (greater than or equal, unsigned) - not C */
344# define SPARC_BPCS 5 /* carry set (less than, unsigned) - C */
345# define SPARC_BPPOS 14 /* positive - not N */
346# define SPARC_BPNEG 6 /* negative - N */
347# define SPARC_BPVC 15 /* overflow clear - not V */
348# define SPARC_BPVS 7 /* overflow set - V */
349# endif
350# define B(cc, imm) f2b(0, 0, cc, 2, imm)
351# define Ba(cc, imm) f2b(0, 1, cc, 2, imm)
352# define BA(imm) B(SPARC_BA, imm)
353# define BAa(imm) Ba(SPARC_BA, imm)
354# define BN(imm) B(SPARC_BN, imm)
355# define BNa(imm) Ba(SPARC_BN, imm)
356# define BNE(imm) B(SPARC_BNE, imm)
357# define BNEa(imm) Ba(SPARC_BNE, imm)
358# define BNZ(imm) BNE(imm)
359# define BNZa(imm) BNEa(imm)
360# define BE(imm) B(SPARC_BE, imm)
361# define BEa(imm) Ba(SPARC_BE, imm)
362# define BZ(imm) BE(imm)
363# define BZa(imm) BEa(imm)
364# define BG(imm) B(SPARC_BG, imm)
365# define BGa(imm) Ba(SPARC_BG, imm)
366# define BLE(imm) B(SPARC_BLE, imm)
367# define BLEa(imm) Ba(SPARC_BLE, imm)
368# define BGE(imm) B(SPARC_BGE, imm)
369# define BGEa(imm) Ba(SPARC_BGE, imm)
370# define BL(imm) B(SPARC_BL, imm)
371# define BLa(imm) Ba(SPARC_BL, imm)
372# define BGU(imm) B(SPARC_BGU, imm)
373# define BGUa(imm) Ba(SPARC_BGU, imm)
374# define BLEU(imm) B(SPARC_BLEU, imm)
375# define BLEUa(imm) Ba(SPARC_BLEU, imm)
376# define BCC(imm) B(SPARC_BCC, imm)
377# define BCCa(imm) Ba(SPARC_BCC, imm)
378# define BGEU(imm) BCC(imm)
379# define BGEUa(imm) BCCa(imm)
380# define BCS(imm) B(SPARC_BCS, imm)
381# define BCSa(imm) Ba(SPARC_BCS, imm)
382# define BLU(imm) BCS(imm)
383# define BLUa(imm) BCSa(imm)
384# define BPOS(imm) B(SPARC_BPOS, imm)
385# define BPOSa(imm) Ba(SPARC_BPOS, imm)
386# define BNEG(imm) B(SPARC_BNEG, imm)
387# define BNEGa(imm) Ba(SPARC_BNEG, imm)
388# define BVC(imm) B(SPARC_BVC, imm)
389# define BVCa(imm) Ba(SPARC_BVC, imm)
390# define BVS(imm) B(SPARC_BVS, imm)
391# define BVSa(imm) Ba(SPARC_BVS, imm)
392# if __WORDSIZE == 64
393# define BPccap(cc,a,cc1, cc2,p,imm) f2bp(0, a, cc, 1, cc1, cc0, p, imm)
394# define BPap(cc, imm) f2bp(0, 1, cc, 1, 1, 0, p, imm)
395# define BPa(cc, imm) f2bp(0, 1, cc, 1, 1, 0, 1, imm)
396# define BP(cc, imm) f2bp(0, 0, cc, 1, 1, 0, 1, imm)
397# define BPA(imm) BP(SPARC_BPA, imm)
398# define BPN(imm) BP(SPARC_BPN, imm)
399# define BNPE(imm) BP(SPARC_BPNE, imm)
400# define BPE(imm) BP(SPARC_BPE, imm)
401# define BPG(imm) BP(SPARC_BPG, imm)
402# define BPLE(imm) BP(SPARC_BPLE, imm)
403# define BPGE(imm) BP(SPARC_BPGE, imm)
404# define BPL(imm) BP(SPARC_BPL, imm)
405# define BPGU(imm) BP(SPARC_BPGU, imm)
406# define BPLEU(imm) BP(SPARC_BPLEU, imm)
407# define BPCC(imm) BP(SPARC_BPCC, imm)
408# define BPCS(imm) BP(SPARC_BPCS, imm)
409# define BPPOS(imm) BP(SPARC_BPPOS, imm)
410# define BPNEG(imm) BP(SPARC_BPNEG, imm)
411# define BPVC(imm) BP(SPARC_BPVC, imm)
412# define BPVS(imm) BP(SPARC_BPVS, imm)
413# endif
414# define SPARC_CBA 8 /* always */
415# define SPARC_CBN 0 /* never */
416# define SPARC_CB3 7 /* 3 */
417# define SPARC_CB2 6 /* 2 */
418# define SPARC_CB23 5 /* 2 or 3 */
419# define SPARC_CB1 4 /* 1 */
420# define SPARC_CB13 3 /* 1 or 3 */
421# define SPARC_CB12 2 /* 1 or 2 */
422# define SPARC_CB123 1 /* 1 or 2 or 3 */
423# define SPARC_CB0 9 /* 0 */
424# define SPARC_CB03 10 /* 0 or 3 */
425# define SPARC_CB02 11 /* 0 or 2 */
426# define SPARC_CB023 12 /* 0 or 2 or 3 */
427# define SPARC_CB01 13 /* 0 or 1 */
428# define SPARC_CB013 14 /* 0 or 1 or 3 */
429# define SPARC_CB012 15 /* 0 or 1 or 2 */
430# define CB(cc, imm) f2b(0, 0, cc, 7, imm)
431# define CBa(cc, imm) f2b(0, 1, cc, 7, imm)
432# define CBA(imm) CB(SPARC_CBA, imm)
433# define CBAa(imm) CBa(SPARC_CBA, imm)
434# define CBN(imm) CB(SPARC_CBN, imm)
435# define CBNa(imm) CBa(SPARC_CBN, imm)
436# define CB3(imm) CB(SPARC_CB3, imm)
437# define CB3a(imm) CBa(SPARC_CB3, imm)
438# define CB2(imm) CB(SPARC_CB2, imm)
439# define CB2a(imm) CBa(SPARC_CB2, imm)
440# define CB23(imm) CB(SPARC_CB23, imm)
441# define CB23a(imm) CBa(SPARC_CB23, imm)
442# define CB1(imm) CB(SPARC_CB1, imm)
443# define CB1a(imm) CBa(SPARC_CB1, imm)
444# define CB13(imm) CB(SPARC_CB13, imm)
445# define CB13a(imm) CBa(SPARC_CB13, imm)
446# define CB12(imm) CB(SPARC_CB12, imm)
447# define CB12a(imm) CBa(SPARC_CB12, imm)
448# define CB123(imm) CB(SPARC_CB123, imm)
449# define CB123a(imm) CBa(SPARC_CB123, imm)
450# define CB0(imm) CB(SPARC_CB0, imm)
451# define CB0a(imm) CBa(SPARC_CB0, imm)
452# define CB03(imm) CB(SPARC_CB03, imm)
453# define CB03a(imm) CBa(SPARC_CB03, imm)
454# define CB02(imm) CB(SPARC_CB02, imm)
455# define CB02a(imm) CBa(SPARC_CB02, imm)
456# define CB023(imm) CB(SPARC_CB103, imm)
457# define CB023a(imm) CBa(SPARC_CB023, imm)
458# define CB01(imm) CB(SPARC_CB01, imm)
459# define CB01a(imm) CBa(SPARC_CB01, imm)
460# define CB013(imm) CB(SPARC_CB013, imm)
461# define CB013a(imm) CBa(SPARC_CB013, imm)
462# define CB012(imm) CB(SPARC_CB012, imm)
463# define CB012a(imm) CBa(SPARC_CB012, imm)
464# define CALLI(imm) f1(1, imm)
465# define CALL(r0) JMPL(_O7_REGNO, r0, 0)
466# define RETL() JMPLI(0, _O7_REGNO, 8)
467# define RET() JMPLI(0, _I7_REGNO, 8)
468# define JMPL(rd, rs1, rs2) f3r(2, rd, 56, rs1, rs2)
469# define JMPLI(rd, rs1, imm) f3i(2, rd, 56, rs1, imm)
470# define RETT(rs1, rs2) f3r(2, 0, 57, rs1, rs2)
471# define RETTI(rs1, imm) f3i(2, 0, 57, rs1, imm)
472# define SPARC_TA 8 /* always */
473# define SPARC_TN 0 /* never */
474# define SPARC_TNE 9 /* not equal - not Z */
475# define SPARC_TNZ SPARC_BNE
476# define SPARC_TE 1 /* equal - Z */
477# define SPARC_TZ SPARC_BE
478# define SPARC_TG 10 /* greater - not (Z or (N xor V)) */
479# define SPARC_TLE 2 /* less or equal - Z or (N xor V) */
480# define SPARC_TGE 11 /* greater or equal - not (N xor V) */
481# define SPARC_TL 3 /* less - N xor V */
482# define SPARC_TGU 12 /* greater unsigned - not (C or Z) */
483# define SPARC_TLEU 4 /* less or equal unsigned - C or Z */
484# define SPARC_TCC 13 /* carry clear - not C */
485# define SPARC_TGEU SPARC_BCC
486# define SPARC_TCS 5 /* carry set - C */
487# define SPARC_TLU SPARC_BCS
488# define SPARC_TPOS 14 /* positive - not N */
489# define SPARC_TNEG 6 /* negative - N */
490# define SPARC_TVC 15 /* overflow clear - not V */
491# define SPARC_TVS 7 /* overflow set - V */
492# define T(cc, rs1, rs2) f3t(cc, rs1, 0, rs2)
493# define TI(cc, rs1, imm) f3t(cc, rs1, 1, imm)
494# define TA(rs1, rs2) T(SPARC_TA, rs1, rs2)
495# define TAI(rs1, imm) TI(SPARC_TA, rs1, imm)
496# define TN(rs1, rs2) T(SPARC_TN, rs1, rs2)
497# define TNI(rs1, imm) TI(SPARC_TN, rs1, imm)
498# define TNE(rs1, rs2) T(SPARC_TNE, rs1, rs2)
499# define TNEI(rs1, imm) TI(SPARC_TNE, rs1, imm)
500# define TNZ(rs1, rs2) TNE(rs1, rs2)
501# define TNZI(rs1, imm) TNEI(rs1, imm)
502# define TE(rs1, rs2) T(SPARC_TE, rs1, rs2)
503# define TEI(rs1, imm) TI(SPARC_TE, rs1, imm)
504# define TZ(rs1, rs2) TE(rs1, rs2)
505# define TZI(rs1, imm) TEI(rs1, imm)
506# define TG(rs1, rs2) T(SPARC_TG, rs1, rs2)
507# define TGI(rs1, imm) TI(SPARC_TG, rs1, imm)
508# define TLE(rs1, rs2) T(SPARC_TLE, rs1, rs2)
509# define TLEI(rs1, imm) TI(SPARC_TLE, rs1, imm)
510# define TGE(rs1, rs2) T(SPARC_TGE, rs1, rs2)
511# define TGEI(rs1, imm) TI(SPARC_TGE, rs1, imm)
512# define TL(rs1, rs2) T(SPARC_TL, rs1, rs2)
513# define TLI(rs1, imm) TI(SPARC_TL, rs1, imm)
514# define TGU(rs1, rs2) T(SPARC_TGU, rs1, rs2)
515# define TGUI(rs1, imm) TI(SPARC_TGU, rs1, imm)
516# define TLEU(rs1, rs2) T(SPARC_TLEU, rs1, rs2)
517# define TLEUI(rs1, imm) TI(SPARC_TLEU, rs1, imm)
518# define TCC(rs1, rs2) T(SPARC_TCC, rs1, rs2)
519# define TCCI(rs1, imm) TI(SPARC_TCC, rs1, imm)
520# define TGEU(rs1, rs2) TCC(rs1, rs2)
521# define TGEUI(rs1, imm) TCCI(rs1, imm)
522# define TCS(rs1, rs2) T(SPARC_TCC, rs1, rs2)
523# define TCSI(rs1, imm) TI(SPARC_TCC, rs1, imm)
524# define TLU(rs1, rs2) TCS(rs1, rs2)
525# define TLUI(rs1, imm) TCSI(rs1, imm)
526# define TPOS(rs1, rs2) T(SPARC_TPOS, rs1, rs2)
527# define TPOSI(rs1, imm) TI(SPARC_TPOS, rs1, imm)
528# define TNEG(rs1, rs2) T(SPARC_TNEG, rs1, rs2)
529# define TNEGI(rs1, imm) TI(SPARC_TNEG, rs1, imm)
530# define TVC(rs1, rs2) T(SPARC_TVC, rs1, rs2)
531# define TVCI(rs1, imm) TI(SPARC_TVC, rs1, imm)
532# define TVS(rs1, rs2) T(SPARC_TVS, rs1, rs2)
533# define TVSI(rs1, imm) TI(SPARC_TVS, rs1, imm)
534# define RDY(rd) f3r(2, rd, 40, 0, 0)
535# define RDASR(rs1, rd) f3r(2, rd, 40, rs1, 0)
536# define RDPSR(rd) f3r(2, rd, 41, 0, 0)
537# define RDWIM(rd) f3r(2, rd, 42, 0, 0)
538# define RDTBR(rd) f3r(2, rd, 43, 0, 0)
539# define WRY(rs1, rs2) f3r(2, 0, 48, rs1, rs2)
540# define WRYI(rs1, imm) f3i(2, 0, 48, rs1, imm)
541# define WRASR(rs1, rs2, rd) f3r(2, rd, 48, rs1, rs2)
542# define WRASRI(rs1, imm, rd) f3i(2, rd, 48, rs1, imm)
543# define WRPSR(rs1, rs2, rd) f3r(2, rd, 49, rs1, rs2)
544# define WRPSRI(rs1, imm, rd) f3i(2, rd, 49, rs1, imm)
545# define WRWIM(rs1, rs2, rd) f3r(2, rd, 50, rs1, rs2)
546# define WRWIMI(rs1, imm, rd) f3i(2, rd, 50, rs1, imm)
547# define WRTBR(rs1, rs2, rd) f3r(2, rd, 51, rs1, rs2)
548# define WRTBRI(rs1, imm, rd) f3i(2, rd, 51, rs1, imm)
549# define STBAR() f3i(2, 0, 40, 15, 0)
550# define UNIMP(imm) f2r(0, 0, 0, imm)
551# define FLUSH(rs1, rs2) f3r(2, 0, 59, rs1, rs2)
552# define FLUSHI(rs1, im) f3i(2, 0, 59, rs1, imm)
79bfeef6 553# define LZCNT(rs2, rd) f2c1(2, rd, 54, 0, 23, rs2)
4a71579b
PC		 554# define nop(i0) _nop(_jit, i0)
555static void _nop(jit_state_t*, jit_int32_t);
556# define movr(r0, r1) _movr(_jit, r0, r1)
557static void _movr(jit_state_t*, jit_int32_t, jit_int32_t);
558# define movi(r0, i0) _movi(_jit, r0, i0)
559static void _movi(jit_state_t*, jit_int32_t, jit_word_t);
560# define movi_p(r0, i0) _movi_p(_jit, r0, i0)
561static jit_word_t _movi_p(jit_state_t*, jit_int32_t, jit_word_t);
40a44dcb
PC		 562# define bswapr_us(r0, r1) generic_bswapr_us(_jit, r0, r1)
563# define bswapr_ui(r0, r1) generic_bswapr_ui(_jit, r0, r1)
564# define bswapr_ul(r0, r1) generic_bswapr_ul(_jit, r0, r1)
565# define movnr(r0,r1,r2) _movnr(_jit,r0,r1,r2)
566static void _movnr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
567# define movzr(r0,r1,r2) _movzr(_jit,r0,r1,r2)
568static void _movzr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
ba3814c1
PC		 569# define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
570static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
571 jit_int32_t,jit_int32_t,jit_word_t);
572#define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
573#define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
4a71579b
PC		 574# define comr(r0, r1) XNOR(r1, 0, r0)
575# define negr(r0, r1) NEG(r1, r0)
79bfeef6
PC		 576# define bitswap(r0, r1) _bitswap(_jit, r0, r1)
577static void _bitswap(jit_state_t*, jit_int32_t, jit_int32_t);
578# define clor(r0, r1) _clor(_jit, r0, r1)
579static void _clor(jit_state_t*, jit_int32_t, jit_int32_t);
580# define clzr(r0, r1) _clzr(_jit, r0, r1)
581static void _clzr(jit_state_t*, jit_int32_t, jit_int32_t);
582# define ctor(r0, r1) _ctor(_jit, r0, r1)
583static void _ctor(jit_state_t*, jit_int32_t, jit_int32_t);
584# define ctzr(r0, r1) _ctzr(_jit, r0, r1)
585static void _ctzr(jit_state_t*, jit_int32_t, jit_int32_t);
4a71579b
PC		 586# define addr(r0, r1, r2) ADD(r1, r2, r0)
587# define addi(r0, r1, i0) _addi(_jit, r0, r1, i0)
588static void _addi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
589# if __WORDSIZE == 32
590# define addcr(r0, r1, r2) ADDcc(r1, r2, r0)
591# else
592# define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2)
593static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
594# endif
595# define addci(r0, r1, i0) _addci(_jit, r0, r1, i0)
596static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
597# if __WORDSIZE == 32
598# define addxr(r0, r1, r2) ADDXcc(r1, r2, r0)
599# else
600# define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2)
601static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
602# endif
603# define addxi(r0, r1, i0) _addxi(_jit, r0, r1, i0)
604static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
605# define subr(r0, r1, r2) SUB(r1, r2, r0)
606# define subi(r0, r1, i0) _subi(_jit, r0, r1, i0)
607static void _subi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
608# if __WORDSIZE == 32
609# define subcr(r0, r1, r2) SUBcc(r1, r2, r0)
610# else
611# define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2)
612static void _subcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
613# endif
614# define subci(r0, r1, i0) _subci(_jit, r0, r1, i0)
615static void _subci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
616# if __WORDSIZE == 32
617# define subxr(r0, r1, r2) SUBXcc(r1, r2, r0)
618# else
619# define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2)
620static void _subxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
621# endif
622# define subxi(r0, r1, i0) _subxi(_jit, r0, r1, i0)
623static void _subxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
624# define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
625static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
626# if __WORDSIZE == 32
627# define mulr(r0, r1, r2) UMUL(r1, r2, r0)
628# else
629# define mulr(r0, r1, r2) MULX(r1, r2, r0)
630# endif
631# define muli(r0, r1, i0) _muli(_jit, r0, r1, i0)
632static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
633# if __WORDSIZE == 32
634# define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
635# define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
636# define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
637static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
638 jit_int32_t,jit_int32_t,jit_bool_t);
639# define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
640# define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
641# define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
642static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
643 jit_int32_t,jit_word_t,jit_bool_t);
644# else
645# define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
646static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,
647 jit_int32_t,jit_int32_t);
648# define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
649static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,
650 jit_int32_t,jit_word_t);
651# define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
652static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,
653 jit_int32_t,jit_int32_t);
654# define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
655static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,
656 jit_int32_t,jit_word_t);
657# endif
658# define divr(r0, r1, r2) _divr(_jit, r0, r1, r2)
659static void _divr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
660# define divi(r0, r1, i0) _divi(_jit, r0, r1, i0)
661static void _divi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
662# define divr_u(r0, r1, r2) _divr_u(_jit, r0, r1, r2)
663static void _divr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
664# define divi_u(r0, r1, i0) _divi_u(_jit, r0, r1, i0)
665static void _divi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
666# define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
667# define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
668# define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
669static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
670 jit_int32_t,jit_int32_t,jit_bool_t);
671# define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
672# define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
673# define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
674static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
675 jit_int32_t,jit_word_t,jit_bool_t);
676# define remr(r0, r1, r2) _remr(_jit, r0, r1, r2)
677static void _remr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
678# define remi(r0, r1, i0) _remi(_jit, r0, r1, i0)
679static void _remi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
680# define remr_u(r0, r1, r2) _remr_u(_jit, r0, r1, r2)
681static void _remr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
682# define remi_u(r0, r1, i0) _remi_u(_jit, r0, r1, i0)
683static void _remi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
684# define andr(r0, r1, r2) AND(r1, r2, r0)
685# define andi(r0, r1, i0) _andi(_jit, r0, r1, i0)
686static void _andi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
687# define orr(r0, r1, r2) OR(r1, r2, r0)
688# define ori(r0, r1, i0) _ori(_jit, r0, r1, i0)
689static void _ori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
690# define xorr(r0, r1, r2) XOR(r1, r2, r0)
691# define xori(r0, r1, i0) _xori(_jit, r0, r1, i0)
692static void _xori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
693# if __WORDSIZE == 32
694# define lshr(r0, r1, r2) SLL(r1, r2, r0)
695# define lshi(r0, r1, i0) SLLI(r1, i0, r0)
696# define rshr(r0, r1, r2) SRA(r1, r2, r0)
697# define rshi(r0, r1, i0) SRAI(r1, i0, r0)
698# define rshr_u(r0, r1, r2) SRL(r1, r2, r0)
699# define rshi_u(r0, r1, i0) SRLI(r1, i0, r0)
700# else
701# define lshr(r0, r1, r2) SLLX(r1, r2, r0)
702# define lshi(r0, r1, i0) SLLXI(r1, i0, r0)
703# define rshr(r0, r1, r2) SRAX(r1, r2, r0)
704# define rshi(r0, r1, i0) SRAXI(r1, i0, r0)
705# define rshr_u(r0, r1, r2) SRLX(r1, r2, r0)
706# define rshi_u(r0, r1, i0) SRLXI(r1, i0, r0)
707# endif
4a71579b
PC		 708# define extr_c(r0,r1) _extr_c(_jit,r0,r1)
709static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
710# define extr_uc(r0,r1) andi(r0, r1, 0xff)
711# define extr_s(r0,r1) _extr_s(_jit,r0,r1)
712static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
713# define extr_us(r0,r1) _extr_us(_jit,r0,r1)
714static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
40a44dcb 715# if __WORDSIZE == 64
4a71579b
PC		 716# define extr_i(r0,r1) _extr_i(_jit,r0,r1)
717static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t);
718# define extr_ui(r0,r1) _extr_ui(_jit,r0,r1)
719static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
720# endif
721# define cr(cc, r0, r1, r2) _cr(_jit, cc, r0, r1, r2)
722static void _cr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
723# define cw(cc, r0, r1, i0) _cw(_jit, cc, r0, r1, i0)
724static void _cw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
725# if __WORDSIZE == 32
726# define ltr(r0, r1, r2) cr(SPARC_BL, r0, r1, r2)
727# define lti(r0, r1, i0) cw(SPARC_BL, r0, r1, i0)
728# define ltr_u(r0, r1, r2) cr(SPARC_BLU, r0, r1, r2)
729# define lti_u(r0, r1, i0) cw(SPARC_BLU, r0, r1, i0)
730# define ler(r0, r1, r2) cr(SPARC_BLE, r0, r1, r2)
731# define lei(r0, r1, i0) cw(SPARC_BLE, r0, r1, i0)
732# define ler_u(r0, r1, r2) cr(SPARC_BLEU, r0, r1, r2)
733# define lei_u(r0, r1, i0) cw(SPARC_BLEU, r0, r1, i0)
734# define eqr(r0, r1, r2) cr(SPARC_BE, r0, r1, r2)
735# define eqi(r0, r1, i0) cw(SPARC_BE, r0, r1, i0)
736# define ger(r0, r1, r2) cr(SPARC_BGE, r0, r1, r2)
737# define gei(r0, r1, i0) cw(SPARC_BGE, r0, r1, i0)
738# define ger_u(r0, r1, r2) cr(SPARC_BGEU, r0, r1, r2)
739# define gei_u(r0, r1, i0) cw(SPARC_BGEU, r0, r1, i0)
740# define gtr(r0, r1, r2) cr(SPARC_BG, r0, r1, r2)
741# define gti(r0, r1, i0) cw(SPARC_BG, r0, r1, i0)
742# define gtr_u(r0, r1, r2) cr(SPARC_BGU, r0, r1, r2)
743# define gti_u(r0, r1, i0) cw(SPARC_BGU, r0, r1, i0)
744# define ner(r0, r1, r2) cr(SPARC_BNE, r0, r1, r2)
745# define nei(r0, r1, i0) cw(SPARC_BNE, r0, r1, i0)
746# else
747# define ltr(r0, r1, r2) cr(SPARC_BPL, r0, r1, r2)
748# define lti(r0, r1, i0) cw(SPARC_BPL, r0, r1, i0)
749# define ltr_u(r0, r1, r2) cr(SPARC_BPCS, r0, r1, r2)
750# define lti_u(r0, r1, i0) cw(SPARC_BPCS, r0, r1, i0)
751# define ler(r0, r1, r2) cr(SPARC_BPLE, r0, r1, r2)
752# define lei(r0, r1, i0) cw(SPARC_BPLE, r0, r1, i0)
753# define ler_u(r0, r1, r2) cr(SPARC_BPLEU, r0, r1, r2)
754# define lei_u(r0, r1, i0) cw(SPARC_BPLEU, r0, r1, i0)
755# define eqr(r0, r1, r2) cr(SPARC_BPE, r0, r1, r2)
756# define eqi(r0, r1, i0) cw(SPARC_BPE, r0, r1, i0)
757# define ger(r0, r1, r2) cr(SPARC_BPGE, r0, r1, r2)
758# define gei(r0, r1, i0) cw(SPARC_BPGE, r0, r1, i0)
759# define ger_u(r0, r1, r2) cr(SPARC_BPCC, r0, r1, r2)
760# define gei_u(r0, r1, i0) cw(SPARC_BPCC, r0, r1, i0)
761# define gtr(r0, r1, r2) cr(SPARC_BPG, r0, r1, r2)
762# define gti(r0, r1, i0) cw(SPARC_BPG, r0, r1, i0)
763# define gtr_u(r0, r1, r2) cr(SPARC_BPGU, r0, r1, r2)
764# define gti_u(r0, r1, i0) cw(SPARC_BPGU, r0, r1, i0)
765# define ner(r0, r1, r2) cr(SPARC_BPNE, r0, r1, r2)
766# define nei(r0, r1, i0) cw(SPARC_BPNE, r0, r1, i0)
767# endif
768# define ldr_c(r0, r1) LDSB(r1, 0, r0)
769# define ldi_c(r0, i0) _ldi_c(_jit, r0, i0)
770static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
771# define ldr_uc(r0, r1) LDUB(r1, 0, r0)
772# define ldi_uc(r0, i0) _ldi_uc(_jit, r0, i0)
773static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
774# define ldr_s(r0, r1) LDSH(r1, 0, r0)
775# define ldi_s(r0, i0) _ldi_s(_jit, r0, i0)
776static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
777# define ldr_us(r0, r1) LDUH(r1, 0, r0)
778# define ldi_us(r0, i0) _ldi_us(_jit, r0, i0)
779static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
780# if __WORDSIZE == 32
781# define ldr_i(r0, r1) LD(r1, 0, r0)
782# define ldr(u, v) ldr_i(u, v)
783# define ldi(u, v) ldi_i(u, v)
784# else
785# define ldr_i(r0, r1) LDSW(r1, 0, r0)
786# define ldr_ui(r0, r1) LDUW(r1, 0, r0)
787# define ldr_l(r0, r1) LDX(r1, 0, r0)
788# define ldr(u, v) ldr_l(u, v)
789# define ldi(u, v) ldi_l(u, v)
790# endif
791# define ldi_i(r0, i0) _ldi_i(_jit, r0, i0)
792static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
793# if __WORDSIZE == 64
794# define ldi_ui(r0, i0) _ldi_ui(_jit, r0, i0)
795static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
796# define ldi_l(r0, i0) _ldi_l(_jit, r0, i0)
797static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
798# endif
799# define ldxr_c(r0, r1, r2) LDSB(r1, r2, r0)
800# define ldxi_c(r0, r1, i0) _ldxi_c(_jit, r0, r1, i0)
801static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
802# define ldxr_uc(r0, r1, r2) LDUB(r1, r2, r0)
803# define ldxi_uc(r0, r1, i0) _ldxi_uc(_jit, r0, r1, i0)
804static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
805# define ldxr_s(r0, r1, r2) LDSH(r1, r2, r0)
806# define ldxi_s(r0, r1, i0) _ldxi_s(_jit, r0, r1, i0)
807static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
808# define ldxr_us(r0, r1, r2) LDUH(r1, r2, r0)
809# define ldxi_us(r0, r1, i0) _ldxi_us(_jit, r0, r1, i0)
810static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
811# if __WORDSIZE == 32
812# define ldxr(u, v, w) ldxr_i(u, v, w)
813# define ldxr_i(r0, r1, r2) LD(r1, r2, r0)
814# define ldxi(u, v, w) ldxi_i(u, v, w)
815# else
816# define ldxr(u, v, w) ldxr_l(u, v, w)
817# define ldxr_i(r0, r1, r2) LDSW(r1, r2, r0)
818# define ldxr_ui(r0, r1, r2) LDUW(r1, r2, r0)
819# define ldxr_l(r0, r1, r2) LDX(r1, r2, r0)
820# define ldxi(u, v, w) ldxi_l(u, v, w)
821# endif
822# define ldxi_i(r0, r1, i0) _ldxi_i(_jit, r0, r1, i0)
823static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
824# if __WORDSIZE == 64
825# define ldxi_ui(r0, r1, i0) _ldxi_ui(_jit, r0, r1, i0)
826static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
827# define ldxi_l(r0, r1, i0) _ldxi_l(_jit, r0, r1, i0)
828static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
829# endif
830# define str_c(r0, r1) STB(r1, r0, 0)
831# define sti_c(i0, r0) _sti_c(_jit, i0, r0)
832static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
833# define str_s(r0, r1) STH(r1, r0, 0)
834# define sti_s(i0, r0) _sti_s(_jit, i0, r0)
835static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
836# if __WORDSIZE == 32
837# define str(u, v) str_i(u, v)
838# define str_i(r0, r1) STI(r1, r0, 0)
839# define sti(u, v) sti_i(u, v)
840# else
841# define str(u, v) str_l(u, v)
842# define str_i(r0, r1) STW(r1, r0, 0)
843# define str_l(r0, r1) STX(r1, r0, 0)
844# define sti(u, v) sti_l(u, v)
845# endif
846# define sti_i(i0, r0) _sti_i(_jit, i0, r0)
847static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
848# if __WORDSIZE == 64
849# define sti_l(i0, r0) _sti_l(_jit, i0, r0)
850static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
851# endif
852# define stxr_c(r0, r1, r2) STB(r2, r1, r0)
853# define stxi_c(i0, r0, r1) _stxi_c(_jit, i0, r0, r1)
854static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
855# define stxr_s(r0, r1, r2) STH(r2, r1, r0)
856# define stxi_s(i0, r0, r1) _stxi_s(_jit, i0, r0, r1)
857static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
858# if __WORDSIZE == 32
859# define stxr(u, v, w) stxr_i(u, v, w)
860# define stxr_i(r0, r1, r2) ST(r2, r1, r0)
861# define stxi(u, v, w) stxi_i(u, v, w)
862# else
863# define stxr(u, v, w) stxr_l(u, v, w)
864# define stxr_i(r0, r1, r2) STW(r2, r1, r0)
865# define stxi(u, v, w) stxi_l(u, v, w)
866# define stxr_l(r0, r1, r2) STX(r2, r1, r0)
867# endif
868# define stxi_i(i0, r0, r1) _stxi_i(_jit, i0, r0, r1)
869static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
870# if __WORDSIZE == 64
871# define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1)
872static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
873# endif
874# define br(cc, i0, r0, r1) _br(_jit, cc, i0, r0, r1)
875static jit_word_t
876_br(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
877# define bw(cc, i0, r0, i1) _bw(_jit, cc, i0, r0, i1)
878static jit_word_t
879_bw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
880# if __WORDSIZE == 32
881# define bltr(i0, r0, r1) br(SPARC_BL, i0, r0, r1)
882# define blti(i0, r0, i1) bw(SPARC_BL, i0, r0, i1)
883# define bltr_u(i0, r0, r1) br(SPARC_BLU, i0, r0, r1)
884# define blti_u(i0, r0, i1) bw(SPARC_BLU, i0, r0, i1)
885# define bler(i0, r0, r1) br(SPARC_BLE, i0, r0, r1)
886# define blei(i0, r0, i1) bw(SPARC_BLE, i0, r0, i1)
887# define bler_u(i0, r0, r1) br(SPARC_BLEU, i0, r0, r1)
888# define blei_u(i0, r0, i1) bw(SPARC_BLEU, i0, r0, i1)
889# define beqr(i0, r0, r1) br(SPARC_BE, i0, r0, r1)
890# define beqi(i0, r0, i1) bw(SPARC_BE, i0, r0, i1)
891# define bger(i0, r0, r1) br(SPARC_BGE, i0, r0, r1)
892# define bgei(i0, r0, i1) bw(SPARC_BGE, i0, r0, i1)
893# define bger_u(i0, r0, r1) br(SPARC_BGEU, i0, r0, r1)
894# define bgei_u(i0, r0, i1) bw(SPARC_BGEU, i0, r0, i1)
895# define bgtr(i0, r0, r1) br(SPARC_BG, i0, r0, r1)
896# define bgti(i0, r0, i1) bw(SPARC_BG, i0, r0, i1)
897# define bgtr_u(i0, r0, r1) br(SPARC_BGU, i0, r0, r1)
898# define bgti_u(i0, r0, i1) bw(SPARC_BGU, i0, r0, i1)
899# define bner(i0, r0, r1) br(SPARC_BNE, i0, r0, r1)
900# define bnei(i0, r0, i1) bw(SPARC_BNE, i0, r0, i1)
901# else
902# define bltr(i0, r0, r1) br(SPARC_BPL, i0, r0, r1)
903# define blti(i0, r0, i1) bw(SPARC_BPL, i0, r0, i1)
904# define bltr_u(i0, r0, r1) br(SPARC_BPCS, i0, r0, r1)
905# define blti_u(i0, r0, i1) bw(SPARC_BPCS, i0, r0, i1)
906# define bler(i0, r0, r1) br(SPARC_BPLE, i0, r0, r1)
907# define blei(i0, r0, i1) bw(SPARC_BPLE, i0, r0, i1)
908# define bler_u(i0, r0, r1) br(SPARC_BPLEU, i0, r0, r1)
909# define blei_u(i0, r0, i1) bw(SPARC_BPLEU, i0, r0, i1)
910# define beqr(i0, r0, r1) br(SPARC_BPE, i0, r0, r1)
911# define beqi(i0, r0, i1) bw(SPARC_BPE, i0, r0, i1)
912# define bger(i0, r0, r1) br(SPARC_BPGE, i0, r0, r1)
913# define bgei(i0, r0, i1) bw(SPARC_BPGE, i0, r0, i1)
914# define bger_u(i0, r0, r1) br(SPARC_BPCC, i0, r0, r1)
915# define bgei_u(i0, r0, i1) bw(SPARC_BPCC, i0, r0, i1)
916# define bgtr(i0, r0, r1) br(SPARC_BPG, i0, r0, r1)
917# define bgti(i0, r0, i1) bw(SPARC_BPG, i0, r0, i1)
918# define bgtr_u(i0, r0, r1) br(SPARC_BPGU, i0, r0, r1)
919# define bgti_u(i0, r0, i1) bw(SPARC_BPGU, i0, r0, i1)
920# define bner(i0, r0, r1) br(SPARC_BPNE, i0, r0, r1)
921# define bnei(i0, r0, i1) bw(SPARC_BPNE, i0, r0, i1)
922# endif
923# define b_asr(jif,add,sgn,i0,r0,r1) _b_asr(_jit,jif,add,sgn,i0,r0,r1)
924static jit_word_t
925_b_asr(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
926 jit_word_t,jit_int32_t,jit_int32_t);
927# define b_asw(jif,add,sgn,i0,r0,i1) _b_asw(_jit,jif,add,sgn,i0,r0,i1)
928static jit_word_t
929_b_asw(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
930 jit_word_t,jit_int32_t,jit_word_t);
931# define boaddr(i0, r0, r1) b_asr(1, 1, 1, i0, r0, r1)
932# define boaddi(i0, r0, i1) b_asw(1, 1, 1, i0, r0, i1)
933# define boaddr_u(i0, r0, r1) b_asr(1, 1, 0, i0, r0, r1)
934# define boaddi_u(i0, r0, i1) b_asw(1, 1, 0, i0, r0, i1)
935# define bxaddr(i0, r0, r1) b_asr(0, 1, 1, i0, r0, r1)
936# define bxaddi(i0, r0, i1) b_asw(0, 1, 1, i0, r0, i1)
937# define bxaddr_u(i0, r0, r1) b_asr(0, 1, 0, i0, r0, r1)
938# define bxaddi_u(i0, r0, i1) b_asw(0, 1, 0, i0, r0, i1)
939# define bosubr(i0, r0, r1) b_asr(1, 0, 1, i0, r0, r1)
940# define bosubi(i0, r0, i1) b_asw(1, 0, 1, i0, r0, i1)
941# define bosubr_u(i0, r0, r1) b_asr(1, 0, 0, i0, r0, r1)
942# define bosubi_u(i0, r0, i1) b_asw(1, 0, 0, i0, r0, i1)
943# define bxsubr(i0, r0, r1) b_asr(0, 0, 1, i0, r0, r1)
944# define bxsubi(i0, r0, i1) b_asw(0, 0, 1, i0, r0, i1)
945# define bxsubr_u(i0, r0, r1) b_asr(0, 0, 0, i0, r0, r1)
946# define bxsubi_u(i0, r0, i1) b_asw(0, 0, 0, i0, r0, i1)
947# define bm_r(set, i0, r0, r1) _bm_r(_jit,set,i0,r0,r1)
948static jit_word_t
949_bm_r(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_int32_t);
950# define bm_w(set,i0,r0,i1) _bm_w(_jit,set,i0,r0,i1)
951static jit_word_t
952_bm_w(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_word_t);
953# define bmsr(i0, r0, r1) bm_r(1, i0, r0, r1)
954# define bmsi(i0, r0, i1) bm_w(1, i0, r0, i1)
955# define bmcr(i0, r0, r1) bm_r(0, i0, r0, r1)
956# define bmci(i0, r0, i1) bm_w(0, i0, r0, i1)
957# define jmpr(r0) _jmpr(_jit, r0)
958static void _jmpr(jit_state_t*,jit_int32_t);
959# define jmpi(i0) _jmpi(_jit, i0)
79bfeef6 960static jit_word_t _jmpi(jit_state_t*,jit_word_t);
4a71579b
PC		 961# define jmpi_p(i0) _jmpi_p(_jit, i0)
962static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
963# define callr(r0) _callr(_jit, r0)
964static void _callr(jit_state_t*,jit_int32_t);
965# define calli(i0) _calli(_jit, i0)
79bfeef6 966static jit_word_t _calli(jit_state_t*,jit_word_t);
4a71579b
PC		 967# define calli_p(i0) _calli_p(_jit, i0)
968static jit_word_t _calli_p(jit_state_t*,jit_word_t);
969# define prolog(node) _prolog(_jit, node)
970static void _prolog(jit_state_t*,jit_node_t*);
971# define epilog(node) _epilog(_jit, node)
972static void _epilog(jit_state_t*,jit_node_t*);
973#define vastart(r0) _vastart(_jit, r0)
974static void _vastart(jit_state_t*, jit_int32_t);
975#define vaarg(r0, r1) _vaarg(_jit, r0, r1)
976static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
977#define patch_at(jump, label) _patch_at(_jit, jump, label)
978static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
979#endif
980
981#if CODE
982static void
983_f2r(jit_state_t *_jit,
984 jit_int32_t op, jit_int32_t rd, jit_int32_t op2, jit_int32_t imm22)
985{
986 jit_instr_t v;
987 assert(!(op & 0xfffffffc));
988 assert(!(rd & 0xffffffe0));
989 assert(!(op2 & 0xfffffff8));
990 assert(s22_p(imm22));
991 v.op.b = op;
992 v.rd.b = rd;
993 v.op2.b = op2;
994 v.imm22.b = imm22;
995 ii(v.v);
996}
997
998static void
999_f2b(jit_state_t *_jit,
1000 jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
1001 jit_int32_t disp22)
1002{
1003 jit_instr_t v;
1004 assert(!(op & 0xfffffffc));
1005 assert(!(a & 0xfffffffe));
1006 assert(!(cond & 0xfffffff0));
1007 assert(!(op2 & 0xfffffff8));
1008 assert(s22_p(disp22));
1009 v.op.b = op;
1010 v.a.b = a;
1011 v.cond.b = cond;
1012 v.op2.b = op2;
1013 v.disp22.b = disp22;
1014 ii(v.v);
1015}
1016
1017# if __WORDSIZE == 64
1018static void
1019_f2bp(jit_state_t *_jit,
1020 jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
1021 jit_int32_t cc1, jit_int32_t cc0, jit_int32_t p, jit_int32_t disp19)
1022{
1023 jit_instr_t v;
1024 assert(!(op & 0xfffffffc));
1025 assert(!(a & 0xfffffffe));
1026 assert(!(cond & 0xfffffff0));
1027 assert(!(op2 & 0xfffffff8));
1028 assert(s19_p(disp19));
1029 v.op.b = op;
1030 v.a.b = a;
1031 v.cond.b = cond;
1032 v.op2.b = op2;
1033 v.cc1.b = cc1;
1034 v.cc0.b = cc0;
1035 v.p.b = p;
1036 v.disp19.b = disp19;
1037 ii(v.v);
1038}
1039# endif
1040
1041static void
1042_f3r(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1043 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1044{
1045 jit_instr_t v;
1046 assert(!(op & 0xfffffffc));
1047 assert(!(rd & 0xffffffe0));
1048 assert(!(op3 & 0xffffffc0));
1049 assert(!(rs1 & 0xffffffe0));
1050 assert(!(rs2 & 0xffffffe0));
1051 v.op.b = op;
1052 v.rd.b = rd;
1053 v.op3.b = op3;
1054 v.rs1.b = rs1;
1055 v.i.b = 0;
1056 v.asi.b = 0;
1057 v.rs2.b = rs2;
1058 ii(v.v);
1059}
1060
1061# if __WORDSIZE == 64
c0c16242
PC		 1062static void
1063_f3ri(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1064 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1065{
1066 jit_instr_t v;
1067 assert(!(op & 0xfffffffc));
1068 assert(!(rd & 0xffffffe0));
1069 assert(!(op3 & 0xffffffc0));
1070 assert(!(rs1 & 0xffffffe0));
1071 assert(!(rs2 & 0xffffffe0));
1072 v.op.b = op;
1073 v.rd.b = rd;
1074 v.op3.b = op3;
1075 v.rs1.b = rs1;
1076 v.i.b = 1;
1077 v.asi.b = 0;
1078 v.rs2.b = rs2;
1079 ii(v.v);
1080}
1081
4a71579b
PC		 1082static void
1083_f3rx(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1084 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1085{
1086 jit_instr_t v;
1087 assert(!(op & 0xfffffffc));
1088 assert(!(rd & 0xffffffe0));
1089 assert(!(op3 & 0xffffffc0));
1090 assert(!(rs1 & 0xffffffe0));
1091 assert(!(rs2 & 0xffffffe0));
1092 v.op.b = op;
1093 v.rd.b = rd;
1094 v.op3.b = op3;
1095 v.rs1.b = rs1;
1096 v.i.b = 0;
1097 v.x.b = 1;
1098 v.asix.b = 0;
1099 v.rs2.b = rs2;
1100 ii(v.v);
1101}
1102
1103static void
1104_f3s(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1105 jit_int32_t op3, jit_int32_t rs1, jit_int32_t shim)
1106{
1107 jit_instr_t v;
1108 assert(!(op & 0xfffffffc));
1109 assert(!(rd & 0xffffffe0));
1110 assert(!(op3 & 0xffffffc0));
1111 assert(!(rs1 & 0xffffffe0));
1112 assert(!(shim & 0xffffffc0));
1113 v.op.b = op;
1114 v.rd.b = rd;
1115 v.op3.b = op3;
1116 v.rs1.b = rs1;
1117 v.i.b = 1;
1118 v.x.b = 1;
1119 v.asis.b = 0;
1120 v.shim.b = shim;
1121 ii(v.v);
1122}
1123# endif
1124
1125static void
1126_f3i(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1127 jit_int32_t op3, jit_int32_t rs1, jit_int32_t simm13)
1128{
1129 jit_instr_t v;
1130 assert(!(op & 0xfffffffc));
1131 assert(!(rd & 0xffffffe0));
1132 assert(!(op3 & 0xffffffc0));
1133 assert(!(rs1 & 0xffffffe0));
1134 assert(s13_p(simm13));
1135 v.op.b = op;
1136 v.rd.b = rd;
1137 v.op3.b = op3;
1138 v.rs1.b = rs1;
1139 v.i.b = 1;
1140 v.simm13.b = simm13;
1141 ii(v.v);
1142}
1143
1144static void
1145_f3t(jit_state_t *_jit, jit_int32_t cond,
1146 jit_int32_t rs1, jit_int32_t i, jit_int32_t rs2_imm7)
1147{
1148 jit_instr_t v;
1149 assert(!(cond & 0xfffffff0));
1150 assert(!(i & 0xfffffffe));
1151 assert(!(rs1 & 0xffffffe0));
1152 v.op.b = 2;
1153 v.rd.b = cond;
1154 v.op3.b = 58;
1155 v.i.b = i;
1156 if (i) {
1157 assert(s7_p(rs2_imm7));
1158 v.res.b = 0;
1159 v.imm7.b = rs2_imm7;
1160 }
1161 else {
1162 assert(!(rs2_imm7 & 0xffffffe0));
1163 v.asi.b = 0;
1164 v.rs2.b = rs2_imm7;
1165 }
1166 ii(v.v);
1167}
1168
1169static void
1170_f3a(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1171 jit_int32_t op3, jit_int32_t rs1, jit_int32_t asi, jit_int32_t rs2)
1172{
1173 jit_instr_t v;
1174 assert(!(op & 0xfffffffc));
1175 assert(!(rd & 0xffffffe0));
1176 assert(!(op3 & 0xffffffc0));
1177 assert(!(rs1 & 0xffffffe0));
1178 assert(!(asi & 0xffffff00));
1179 assert(!(rs2 & 0xffffffe0));
1180 v.op.b = op;
1181 v.rd.b = rd;
1182 v.op3.b = op3;
1183 v.rs1.b = rs1;
1184 v.i.b = 0;
1185 v.asi.b = asi;
1186 v.rs2.b = rs2;
1187 ii(v.v);
1188}
1189
1190static void
1191_f1(jit_state_t *_jit, jit_int32_t op, jit_int32_t disp30)
1192{
1193 jit_instr_t v;
1194 assert(!(op & 0xfffffffc));
1195 assert(s30_p(disp30));
1196 v.op.b = op;
1197 v.disp30.b = disp30;
1198 ii(v.v);
1199}
1200
79bfeef6
PC		 1201static void
1202_f2c1(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1203 jit_int32_t op3, jit_int32_t rs1, jit_int32_t opf, jit_int32_t rs2)
1204{
1205 jit_instr_t v;
1206 assert(!(op & 0xfffffffc));
1207 assert(!(rd & 0xffffffe0));
1208 assert(!(res & 0xffffffc0));
1209 assert(!(rs1 & 0xffffffe0));
1210 assert(!(opf & 0xfffffe00));
1211 assert(!(rs2 & 0xfffffe00));
1212 v.op.b = op;
1213 v.rd.b = rd;
1214 v.op3.b = op3;
1215 v.rs1.b = rs1;
1216 v.opf.b = opf;
1217 v.rs2.b = rs2;
1218 ii(v.v);
1219}
1220
4a71579b
PC		 1221static void
1222_nop(jit_state_t *_jit, jit_int32_t i0)
1223{
1224 for (; i0 > 0; i0 -= 4)
1225 NOP();
1226 assert(i0 == 0);
1227}
1228
1229static void
1230_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1231{
1232 if (r0 != r1)
1233 ORI(r1, 0, r0);
1234}
1235
1236static void
1237_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1238{
1239 if (s13_p(i0))
1240 ORI(0, i0, r0);
1241 else {
1242# if __WORDSIZE == 64
1243 if (i0 & 0xffffffff00000000) {
1244 jit_int32_t reg = jit_get_reg(jit_class_gpr);
1245 movi(rn(reg), (i0 >> 32) & 0xffffffff);
1246 movi(r0, i0 & 0xffffffff);
1247 lshi(rn(reg), rn(reg), 32);
1248 OR(rn(reg), r0, r0);
1249 jit_unget_reg(reg);
1250 }
1251 else {
1252# endif
1253 SETHI(HI((int)i0), r0);
1254 if (LO(i0))
1255 ORI(r0, LO(i0), r0);
1256# if __WORDSIZE == 64
1257 }
1258# endif
1259 }
1260}
1261
1262static jit_word_t
1263_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1264{
1265 jit_word_t w;
1266# if __WORDSIZE == 64
1267 jit_int32_t reg;
1268# endif
1269 w = _jit->pc.w;
1270# if __WORDSIZE == 64
1271 reg = jit_get_reg(jit_class_gpr);
1272 SETHI(HI((int)i0), r0);
1273 ORI(r0, LO(i0), r0);
1274 i0 = (int)(i0 >> 32);
1275 SETHI(HI(i0), rn(reg));
1276 ORI(rn(reg), LO(i0), rn(reg));
1277 SLLXI(rn(reg), 32, rn(reg));
1278 OR(rn(reg), r0, r0);
1279 jit_unget_reg(reg);
1280# else
1281 SETHI(HI(i0), r0);
1282 ORI(r0, LO(i0), r0);
1283# endif
1284 return (w);
1285}
1286
40a44dcb
PC		 1287static void
1288_movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1289{
1290 jit_word_t w;
1291 w = beqi(_jit->pc.w, r2, 0);
1292 ORI(r1, 0, r0);
1293 patch_at(w, _jit->pc.w);
1294}
1295
1296static void
1297_movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1298{
1299 jit_word_t w;
1300 w = bnei(_jit->pc.w, r2, 0);
1301 ORI(r1, 0, r0);
1302 patch_at(w, _jit->pc.w);
1303}
1304
ba3814c1
PC		 1305static void
1306_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1307 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1308{
c0c16242
PC		 1309 jit_int32_t iscasi, r1_reg;
1310 if ((iscasi = (r1 == _NOREG))) {
1311 r1_reg = jit_get_reg(jit_class_gpr);
1312 r1 = rn(r1_reg);
1313 movi(r1, i0);
1314 }
1315 /* Do not clobber r2 */
1316 movr(r0, r3);
1317 /* The CASXA instruction compares the value in register r[rs2] with
1318 * the doubleword in memory pointed to by the doubleword address in
1319 * r[rs1]. If the values are equal, the value in r[rd] is swapped
1320 * with the doubleword pointed to by the doubleword address in r[rs1].
1321 * If the values are not equal, the contents of the doubleword pointed
1322 * to by r[rs1] replaces the value in r[rd], but the memory location
1323 * remains unchanged.
1324 */
1325# if __WORDSIZE == 32
1326 CASA(r1, r2, r0);
1327# else
1328 CASXA(r1, r2, r0);
1329# endif
1330 eqr(r0, r0, r2);
1331 if (iscasi)
1332 jit_unget_reg(r1_reg);
ba3814c1
PC		 1333}
1334
79bfeef6
PC		 1335static void
1336_bitswap(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1337{
1338 jit_int32_t t0, t1, t2, t3, t4;
1339 movr(r0, r1);
1340 t0 = jit_get_reg(jit_class_gpr);
1341 t1 = jit_get_reg(jit_class_gpr);
1342 t2 = jit_get_reg(jit_class_gpr);
1343 movi(rn(t0), __WORDSIZE == 32 ? 0x55555555L : 0x5555555555555555L);
1344 rshi_u(rn(t1), r0, 1); /* t1 = v >> 1 */
1345 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1346 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1347 lshi(rn(t2), rn(t2), 1); /* t2 <<= 1 */
1348 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1349 movi(rn(t0), __WORDSIZE == 32 ? 0x33333333L : 0x3333333333333333L);
1350 rshi_u(rn(t1), r0, 2); /* t1 = v >> 2 */
1351 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1352 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1353 lshi(rn(t2), rn(t2), 2); /* t2 <<= 2 */
1354 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1355 movi(rn(t0), __WORDSIZE == 32 ? 0x0f0f0f0fL : 0x0f0f0f0f0f0f0f0fL);
1356 rshi_u(rn(t1), r0, 4); /* t1 = v >> 4 */
1357 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1358 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1359 lshi(rn(t2), rn(t2), 4); /* t2 <<= 4 */
1360 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1361 movi(rn(t0), __WORDSIZE == 32 ? 0x00ff00ffL : 0x00ff00ff00ff00ffL);
1362 rshi_u(rn(t1), r0, 8); /* t1 = v >> 8 */
1363 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1364 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1365 lshi(rn(t2), rn(t2), 8); /* t2 <<= 8 */
1366 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1367# if __WORDSIZE == 32
1368 rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */
1369 lshi(rn(t2), r0, 16); /* t2 = v << 16 */
1370 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1371# else
1372 movi(rn(t0), 0x0000ffff0000ffffL);
1373 rshi_u(rn(t1), r0, 16); /* t1 = v >> 16 */
1374 andr(rn(t1), rn(t1), rn(t0)); /* t1 &= t0 */
1375 andr(rn(t2), r0, rn(t0)); /* t2 = v & t0*/
1376 lshi(rn(t2), rn(t2), 16); /* t2 <<= 16 */
1377 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1378 rshi_u(rn(t1), r0, 32); /* t1 = v >> 32 */
1379 lshi(rn(t2), r0, 32); /* t2 = v << 32 */
1380 orr(r0, rn(t1), rn(t2)); /* v = t1 | t2 */
1381# endif
1382 jit_unget_reg(t2);
1383 jit_unget_reg(t1);
1384 jit_unget_reg(t0);
1385}
1386
1387static void
1388_clor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1389{
1390 if (jit_cpu.lzcnt) {
1391 comr(r0, r1);
1392 clzr(r0, r0);
1393 }
1394 else
1395 fallback_clo(r0, r1);
1396}
1397
1398static void
1399_clzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1400{
1401 if (jit_cpu.lzcnt) {
1402#if __WORDSIZE == 32
1403 jit_word_t w;
1404 SLLXI(r1, 32, r0);
1405 LZCNT(r0, r0);
1406#if __WORDSIZE == 32
1407 w = blei(_jit->pc.w, r0, 31);
1408 rshi(r0, r0, 1); /* r0 is 64 */
1409 patch_at(w, _jit->pc.w);
1410#endif
1411#else
1412 LZCNT(r1, r0);
1413 }
1414 else
1415 fallback_clz(r0, r1);
1416}
1417
1418static void
1419_ctor(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1420{
1421 if (jit_cpu.lzcnt) {
1422 bitswap(r0, r1);
1423 clor(r0, r0);
1424 }
1425 else
1426 fallback_cto(r0, r1);
1427}
1428
1429static void
1430_ctzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1431{
1432 if (jit_cpu.lzcnt) {
1433 bitswap(r0, r1);
1434 clzr(r0, r0);
1435 }
1436 else
1437 fallback_ctz(r0, r1);
1438}
1439
4a71579b
PC		 1440static void
1441_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1442{
1443 jit_int32_t reg;
1444 if (s13_p(i0))
1445 ADDI(r1, i0, r0);
1446 else {
1447 reg = jit_get_reg(jit_class_gpr);
1448 movi(rn(reg), i0);
1449 addr(r0, r1, rn(reg));
1450 jit_unget_reg(reg);
1451 }
1452}
1453
1454# if __WORDSIZE == 64
1455static void
1456_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1457{
1458 jit_int32_t reg;
1459 if (jit_carry == _NOREG)
1460 jit_carry = jit_get_reg(jit_class_gpr);
1461 if (r0 == r1) {
1462 reg = jit_get_reg(jit_class_gpr);
1463 addr(rn(reg), r1, r2);
1464 ltr_u(rn(jit_carry), rn(reg), r1);
1465 movr(r0, rn(reg));
1466 jit_unget_reg(reg);
1467 }
1468 else {
1469 addr(r0, r1, r2);
1470 ltr_u(rn(jit_carry), r0, r1);
1471 }
1472}
1473# endif
1474
1475static void
1476_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1477{
1478# if __WORDSIZE == 32
1479 jit_int32_t reg;
1480 if (s13_p(i0))
1481 ADDIcc(r1, i0, r0);
1482 else {
1483 reg = jit_get_reg(jit_class_gpr);
1484 movi(rn(reg), i0);
1485 addcr(r0, r1, rn(reg));
1486 jit_unget_reg(reg);
1487 }
1488# else
1489 jit_int32_t reg;
1490 if (jit_carry == _NOREG)
1491 jit_carry = jit_get_reg(jit_class_gpr);
1492 if (r0 == r1) {
1493 reg = jit_get_reg(jit_class_gpr);
1494 addi(rn(reg), r1, i0);
1495 ltr_u(rn(jit_carry), rn(reg), r1);
1496 movr(r0, rn(reg));
1497 jit_unget_reg(reg);
1498 }
1499 else {
1500 addi(r0, r1, i0);
1501 ltr_u(rn(jit_carry), r0, r1);
1502 }
1503# endif
1504}
1505
1506# if __WORDSIZE == 64
1507static void
1508_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1509{
1510 jit_int32_t reg;
1511 assert(jit_carry != _NOREG);
1512 reg = jit_get_reg(jit_class_gpr);
1513 movr(rn(reg), rn(jit_carry));
1514 addcr(r0, r1, r2);
1515 addcr(r0, r0, rn(reg));
1516 jit_unget_reg(reg);
1517}
1518# endif
1519
1520static void
1521_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1522{
1523# if __WORDSIZE == 32
1524 jit_int32_t reg;
1525 if (s13_p(i0))
1526 ADDXIcc(r1, i0, r0);
1527 else {
1528 reg = jit_get_reg(jit_class_gpr);
1529 movi(rn(reg), i0);
1530 addxr(r0, r1, rn(reg));
1531 jit_unget_reg(reg);
1532 }
1533# else
1534 jit_int32_t reg;
1535 assert(jit_carry != _NOREG);
1536 reg = jit_get_reg(jit_class_gpr);
1537 movr(rn(reg), rn(jit_carry));
1538 addci(r0, r1, i0);
1539 addcr(r0, r0, rn(reg));
1540 jit_unget_reg(reg);
1541# endif
1542}
1543
1544static void
1545_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1546{
1547 jit_int32_t reg;
1548 if (s13_p(i0))
1549 SUBI(r1, i0, r0);
1550 else {
1551 reg = jit_get_reg(jit_class_gpr);
1552 movi(rn(reg), i0);
1553 subr(r0, r1, rn(reg));
1554 jit_unget_reg(reg);
1555 }
1556}
1557
1558# if __WORDSIZE == 64
1559static void
1560_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1561{
1562 jit_int32_t reg;
1563 if (jit_carry == _NOREG)
1564 jit_carry = jit_get_reg(jit_class_gpr);
1565 if (r0 == r1) {
1566 reg = jit_get_reg(jit_class_gpr);
1567 subr(rn(reg), r1, r2);
1568 ltr_u(rn(jit_carry), r1, rn(reg));
1569 movr(r0, rn(reg));
1570 jit_unget_reg(reg);
1571 }
1572 else {
1573 subr(r0, r1, r2);
1574 ltr_u(rn(jit_carry), r1, r0);
1575 }
1576}
1577# endif
1578
1579static void
1580_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1581{
1582# if __WORDSIZE == 32
1583 jit_int32_t reg;
1584 if (s13_p(i0))
1585 SUBIcc(r1, i0, r0);
1586 else {
1587 reg = jit_get_reg(jit_class_gpr);
1588 movi(rn(reg), i0);
1589 subcr(r0, r1, rn(reg));
1590 jit_unget_reg(reg);
1591 }
1592# else
1593 jit_int32_t reg;
1594 if (jit_carry == _NOREG)
1595 jit_carry = jit_get_reg(jit_class_gpr);
1596 if (r0 == r1) {
1597 reg = jit_get_reg(jit_class_gpr);
1598 addi(rn(reg), r1, -i0);
1599 ltr_u(rn(jit_carry), r1, rn(reg));
1600 movr(r0, rn(reg));
1601 jit_unget_reg(reg);
1602 }
1603 else {
1604 addi(r0, r1, -i0);
1605 ltr_u(rn(jit_carry), r1, r0);
1606 }
1607# endif
1608}
1609
1610# if __WORDSIZE == 64
1611static void
1612_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1613{
1614 jit_int32_t reg;
1615 assert(jit_carry != _NOREG);
1616 reg = jit_get_reg(jit_class_gpr);
1617 movr(rn(reg), rn(jit_carry));
1618 subcr(r0, r1, r2);
1619 subcr(r0, r0, rn(reg));
1620 jit_unget_reg(reg);
1621}
1622#endif
1623
1624static void
1625_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1626{
1627# if __WORDSIZE == 32
1628 jit_int32_t reg;
1629 if (s13_p(i0))
1630 SUBXIcc(r1, i0, r0);
1631 else {
1632 reg = jit_get_reg(jit_class_gpr);
1633 movi(rn(reg), i0);
1634 subxr(r0, r1, rn(reg));
1635 jit_unget_reg(reg);
1636 }
1637# else
1638 jit_int32_t reg;
1639 assert(jit_carry != _NOREG);
1640 reg = jit_get_reg(jit_class_gpr);
1641 movr(rn(reg), rn(jit_carry));
1642 subci(r0, r1, i0);
1643 subcr(r0, r0, rn(reg));
1644 jit_unget_reg(reg);
1645# endif
1646}
1647
1648static void
1649_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1650{
1651 subi(r0, r1, i0);
1652 negr(r0, r0);
1653}
1654
1655static void
1656_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1657{
1658 jit_int32_t reg;
1659 if (s13_p(i0)) {
1660# if __WORDSIZE == 32
1661 UMULI(r1, i0, r0);
1662# else
1663 MULXI(r1, i0, r0);
1664# endif
1665 }
1666 else {
1667 reg = jit_get_reg(jit_class_gpr);
1668 movi(rn(reg), i0);
1669 mulr(r0, r1, rn(reg));
1670 jit_unget_reg(reg);
1671 }
1672}
1673
1674# if __WORDSIZE == 32
1675static void
1676_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1677 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1678{
1679 if (sign)
1680 SMUL(r2, r3, r0);
1681 else
1682 UMUL(r2, r3, r0);
1683 RDY(r1);
1684}
1685
1686static void
1687_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1688 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1689{
1690 jit_int32_t reg;
1691 if (s13_p(i0)) {
1692 if (sign)
1693 SMULI(r2, i0, r0);
1694 else
1695 UMULI(r2, i0, r0);
1696 RDY(r1);
1697 }
1698 else {
1699 reg = jit_get_reg(jit_class_gpr);
1700 movi(rn(reg), i0);
1701 iqmulr(r0, r1, r2, rn(reg), sign);
1702 jit_unget_reg(reg);
1703 }
1704}
1705
1706# else
1707static __int128_t __llmul(jit_word_t a, jit_word_t b)
1708{
1709 return (__int128_t)a * (__int128_t)b;
1710}
1711
1712# define QMUL_PROLOG() \
1713 do { \
1714 (void)jit_get_reg(_O0|jit_class_gpr|jit_class_named); \
1715 (void)jit_get_reg(_O1|jit_class_gpr|jit_class_named); \
1716 if (r0 != _G2_REGNO && r1 != _G2_REGNO) \
1717 stxi(BIAS(-8), _FP_REGNO, _G2_REGNO); \
1718 if (r0 != _G3_REGNO && r1 != _G3_REGNO) \
1719 stxi(BIAS(-16), _FP_REGNO, _G3_REGNO); \
1720 if (r0 != _G4_REGNO && r1 != _G4_REGNO) \
1721 stxi(BIAS(-24), _FP_REGNO, _G4_REGNO); \
1722 } while (0)
1723
1724# define QMUL_EPILOG() \
1725 do { \
1726 if (r0 != _G2_REGNO && r1 != _G2_REGNO) \
1727 ldxi(_G2_REGNO, _FP_REGNO, BIAS(-8)); \
1728 if (r0 != _G3_REGNO && r1 != _G3_REGNO) \
1729 ldxi(_G3_REGNO, _FP_REGNO, BIAS(-16)); \
1730 if (r0 != _G4_REGNO && r1 != _G4_REGNO) \
1731 ldxi(_G4_REGNO, _FP_REGNO, BIAS(-24)); \
1732 (void)jit_unget_reg(_O0); \
1733 (void)jit_unget_reg(_O1); \
1734 } while (0)
1735
1736static void
1737_qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1738 jit_int32_t r2, jit_int32_t r3)
1739{
1740 QMUL_PROLOG();
1741 movr(_O0_REGNO, r3);
1742 movr(_O1_REGNO, r2);
1743 calli((jit_word_t)__llmul);
1744 movr(r0, _O1_REGNO);
1745 movr(r1, _O0_REGNO);
1746 QMUL_EPILOG();
1747}
1748
1749static void
1750_qmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1751 jit_int32_t r2, jit_word_t i0)
1752{
1753 QMUL_PROLOG();
1754 movi(_O0_REGNO, i0);
1755 movr(_O1_REGNO, r2);
1756 calli((jit_word_t)__llmul);
1757 movr(r0, _O1_REGNO);
1758 movr(r1, _O0_REGNO);
1759 QMUL_EPILOG();
1760}
1761
1762static __uint128_t __ullmul(jit_uword_t a, jit_uword_t b)
1763{
1764 return (__uint128_t)a * (__uint128_t)b;
1765}
1766
1767static void
1768_qmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1769 jit_int32_t r2, jit_int32_t r3)
1770{
1771 QMUL_PROLOG();
1772 movr(_O0_REGNO, r3);
1773 movr(_O1_REGNO, r2);
1774 calli((jit_word_t)__ullmul);
1775 movr(r0, _O1_REGNO);
1776 movr(r1, _O0_REGNO);
1777 QMUL_EPILOG();
1778}
1779
1780static void
1781_qmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1782 jit_int32_t r2, jit_word_t i0)
1783{
1784 QMUL_PROLOG();
1785 movi(_O0_REGNO, i0);
1786 movr(_O1_REGNO, r2);
1787 calli((jit_word_t)__ullmul);
1788 movr(r0, _O1_REGNO);
1789 movr(r1, _O0_REGNO);
1790 QMUL_EPILOG();
1791}
1792# endif
1793
1794static void
1795_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1796{
1797# if __WORDSIZE == 32
1798 jit_int32_t reg;
1799 reg = jit_get_reg(jit_class_gpr);
1800 rshi(rn(reg), r1, 31);
1801 WRY(rn(reg), 0);
1802 SDIV(r1, r2, r0);
1803 jit_unget_reg(reg);
1804# else
1805 SDIVX(r1, r2, r0);
1806# endif
1807}
1808
1809static void
1810_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1811{
1812 jit_int32_t reg;
1813# if __WORDSIZE == 32
1814 reg = jit_get_reg(jit_class_gpr);
1815# endif
1816 if (s13_p(i0)) {
1817# if __WORDSIZE == 32
1818 rshi(rn(reg), r1, 31);
1819 WRY(rn(reg), 0);
1820 SDIVI(r1, i0, r0);
1821# else
1822 SDIVXI(r1, i0, r0);
1823# endif
1824 }
1825 else {
1826# if __WORDSIZE == 64
1827 reg = jit_get_reg(jit_class_gpr);
1828# endif
1829 movi(rn(reg), i0);
1830 divr(r0, r1, rn(reg));
1831# if __WORDSIZE == 64
1832 jit_unget_reg(reg);
1833# endif
1834 }
1835# if __WORDSIZE == 32
1836 jit_unget_reg(reg);
1837# endif
1838}
1839
1840static void
1841_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1842{
1843# if __WORDSIZE == 32
1844 WRYI(0, 0);
1845 UDIV(r1, r2, r0);
1846# else
1847 UDIVX(r1, r2, r0);
1848# endif
1849}
1850
1851static void
1852_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1853{
1854 jit_int32_t reg;
1855 if (s13_p(i0)) {
1856# if __WORDSIZE == 32
1857 WRYI(0, 0);
1858 UDIVI(r1, i0, r0);
1859# else
1860 UDIVXI(r1, i0, r0);
1861# endif
1862 }
1863 else {
1864 reg = jit_get_reg(jit_class_gpr);
1865 movi(rn(reg), i0);
1866 divr_u(r0, r1, rn(reg));
1867 jit_unget_reg(reg);
1868 }
1869}
1870
1871static void
1872_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1873 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1874{
1875 jit_int32_t sv0, rg0;
1876 jit_int32_t sv1, rg1;
1877
1878 if (r0 == r2 || r0 == r3) {
1879 sv0 = jit_get_reg(jit_class_gpr);
1880 rg0 = rn(sv0);
1881 }
1882 else
1883 rg0 = r0;
1884 if (r1 == r2 || r1 == r3) {
1885 sv1 = jit_get_reg(jit_class_gpr);
1886 rg1 = rn(sv1);
1887 }
1888 else
1889 rg1 = r1;
1890
1891 if (sign)
1892 divr(rg0, r2, r3);
1893 else
1894 divr_u(rg0, r2, r3);
1895 mulr(rg1, r3, rg0);
1896 subr(rg1, r2, rg1);
1897 if (rg0 != r0) {
1898 movr(r0, rg0);
1899 jit_unget_reg(sv0);
1900 }
1901 if (rg1 != r1) {
1902 movr(r1, rg1);
1903 jit_unget_reg(sv1);
1904 }
1905}
1906
1907static void
1908_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1909 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1910{
1911 jit_int32_t reg;
1912 reg = jit_get_reg(jit_class_gpr);
1913 movi(rn(reg), i0);
1914 iqdivr(r0, r1, r2, rn(reg), sign);
1915 jit_unget_reg(reg);
1916}
1917
1918static void
1919_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1920{
1921 jit_int32_t reg;
1922 if (r0 == r1 || r0 == r2) {
1923 reg = jit_get_reg(jit_class_gpr);
1924 divr(rn(reg), r1, r2);
1925 mulr(rn(reg), r2, rn(reg));
1926 subr(r0, r1, rn(reg));
1927 jit_unget_reg(reg);
1928 }
1929 else {
1930 divr(r0, r1, r2);
1931 mulr(r0, r2, r0);
1932 subr(r0, r1, r0);
1933 }
1934}
1935
1936static void
1937_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1938{
1939 jit_int32_t reg;
1940 reg = jit_get_reg(jit_class_gpr);
1941 movi(rn(reg), i0);
1942 remr(r0, r1, rn(reg));
1943 jit_unget_reg(reg);
1944}
1945
1946static void
1947_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1948{
1949 jit_int32_t reg;
1950 if (r0 == r1 || r0 == r2) {
1951 reg = jit_get_reg(jit_class_gpr);
1952 divr_u(rn(reg), r1, r2);
1953 mulr(rn(reg), r2, rn(reg));
1954 subr(r0, r1, rn(reg));
1955 jit_unget_reg(reg);
1956 }
1957 else {
1958 divr_u(r0, r1, r2);
1959 mulr(r0, r2, r0);
1960 subr(r0, r1, r0);
1961 }
1962}
1963
1964static void
1965_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1966{
1967 jit_int32_t reg;
1968 reg = jit_get_reg(jit_class_gpr);
1969 movi(rn(reg), i0);
1970 remr_u(r0, r1, rn(reg));
1971 jit_unget_reg(reg);
1972}
1973
1974static void
1975_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1976{
1977 jit_int32_t reg;
1978 if (s13_p(i0))
1979 ANDI(r1, i0, r0);
1980 else {
1981 reg = jit_get_reg(jit_class_gpr);
1982 movi(rn(reg), i0);
1983 andr(r0, r1, rn(reg));
1984 jit_unget_reg(reg);
1985 }
1986}
1987
1988static void
1989_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1990{
1991 jit_int32_t reg;
1992 if (s13_p(i0))
1993 ORI(r1, i0, r0);
1994 else {
1995 reg = jit_get_reg(jit_class_gpr);
1996 movi(rn(reg), i0);
1997 orr(r0, r1, rn(reg));
1998 jit_unget_reg(reg);
1999 }
2000}
2001
2002static void
2003_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2004{
2005 jit_int32_t reg;
2006 if (s13_p(i0))
2007 XORI(r1, i0, r0);
2008 else {
2009 reg = jit_get_reg(jit_class_gpr);
2010 movi(rn(reg), i0);
2011 xorr(r0, r1, rn(reg));
2012 jit_unget_reg(reg);
2013 }
2014}
2015
2016static void
2017_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2018{
2019 lshi(r0, r1, __WORDSIZE - 8);
2020 rshi(r0, r0, __WORDSIZE - 8);
2021}
2022
2023static void
2024_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2025{
2026 lshi(r0, r1, __WORDSIZE - 16);
2027 rshi(r0, r0, __WORDSIZE - 16);
2028}
2029
2030static void
2031_extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2032{
2033 lshi(r0, r1, __WORDSIZE - 16);
2034 rshi_u(r0, r0, __WORDSIZE - 16);
2035}
2036
2037#if __WORDSIZE == 64
2038static void
2039_extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2040{
2041 lshi(r0, r1, __WORDSIZE - 32);
2042 rshi(r0, r0, __WORDSIZE - 32);
2043}
2044
2045static void
2046_extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2047{
2048 lshi(r0, r1, __WORDSIZE - 32);
2049 rshi_u(r0, r0, __WORDSIZE - 32);
2050}
2051#endif
2052
2053static void
2054_cr(jit_state_t *_jit, jit_int32_t cc,
2055 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
2056{
2057 CMP(r1, r2);
2058# if __WORDSIZE == 32
2059 Ba(cc, 3);
2060# else
2061 BPa(cc, 3);
2062# endif
2063 movi(r0, 1);
2064 movi(r0, 0);
2065}
2066
2067static void
2068_cw(jit_state_t *_jit, jit_int32_t cc,
2069 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2070{
2071 jit_int32_t reg;
2072 if (s13_p(i0)) {
2073 CMPI(r1, i0);
2074# if __WORDSIZE == 32
2075 Ba(cc, 3);
2076# else
2077 BPa(cc, 3);
2078# endif
2079 movi(r0, 1);
2080 movi(r0, 0);
2081 }
2082 else {
2083 reg = jit_get_reg(jit_class_gpr);
2084 movi(rn(reg), i0);
2085 cr(cc, r0, r1, rn(reg));
2086 jit_unget_reg(reg);
2087 }
2088}
2089
2090static void
2091_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2092{
2093 jit_int32_t reg;
2094 if (s13_p(i0))
2095 LDSBI(0, i0, r0);
2096 else {
2097 reg = jit_get_reg(jit_class_gpr);
2098 movi(rn(reg), i0);
2099 ldr_c(r0, rn(reg));
2100 jit_unget_reg(reg);
2101 }
2102}
2103
2104static void
2105_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2106{
2107 jit_int32_t reg;
2108 if (s13_p(i0))
2109 LDUBI(0, i0, r0);
2110 else {
2111 reg = jit_get_reg(jit_class_gpr);
2112 movi(rn(reg), i0);
2113 ldr_uc(r0, rn(reg));
2114 jit_unget_reg(reg);
2115 }
2116}
2117
2118static void
2119_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2120{
2121 jit_int32_t reg;
2122 if (s13_p(i0))
2123 LDSHI(0, i0, r0);
2124 else {
2125 reg = jit_get_reg(jit_class_gpr);
2126 movi(rn(reg), i0);
2127 ldr_s(r0, rn(reg));
2128 jit_unget_reg(reg);
2129 }
2130}
2131
2132static void
2133_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2134{
2135 jit_int32_t reg;
2136 if (s13_p(i0))
2137 LDUHI(0, i0, r0);
2138 else {
2139 reg = jit_get_reg(jit_class_gpr);
2140 movi(rn(reg), i0);
2141 ldr_us(r0, rn(reg));
2142 jit_unget_reg(reg);
2143 }
2144}
2145
2146static void
2147_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2148{
2149 jit_int32_t reg;
2150 if (s13_p(i0)) {
2151# if __WORDSIZE == 32
2152 LDI(0, i0, r0);
2153# else
2154 LDSWI(0, i0, r0);
2155# endif
2156 }
2157 else {
2158 reg = jit_get_reg(jit_class_gpr);
2159 movi(rn(reg), i0);
2160 ldr_i(r0, rn(reg));
2161 jit_unget_reg(reg);
2162 }
2163}
2164
2165# if __WORDSIZE == 64
2166static void
2167_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2168{
2169 jit_int32_t reg;
2170 if (s13_p(i0))
2171 LDUWI(0, i0, r0);
2172 else {
2173 reg = jit_get_reg(jit_class_gpr);
2174 movi(rn(reg), i0);
2175 ldr_ui(r0, rn(reg));
2176 jit_unget_reg(reg);
2177 }
2178}
2179
2180static void
2181_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
2182{
2183 jit_int32_t reg;
2184 if (s13_p(i0))
2185 LDXI(0, i0, r0);
2186 else {
2187 reg = jit_get_reg(jit_class_gpr);
2188 movi(rn(reg), i0);
2189 ldr_l(r0, rn(reg));
2190 jit_unget_reg(reg);
2191 }
2192}
2193# endif
2194
2195static void
2196_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2197{
2198 jit_int32_t reg;
2199 if (s13_p(i0))
2200 LDSBI(r1, i0, r0);
2201 else {
2202 reg = jit_get_reg(jit_class_gpr);
2203 movi(rn(reg), i0);
2204 ldxr_c(r0, r1, rn(reg));
2205 jit_unget_reg(reg);
2206 }
2207}
2208
2209static void
2210_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2211{
2212 jit_int32_t reg;
2213 if (s13_p(i0))
2214 LDUBI(r1, i0, r0);
2215 else {
2216 reg = jit_get_reg(jit_class_gpr);
2217 movi(rn(reg), i0);
2218 ldxr_uc(r0, r1, rn(reg));
2219 jit_unget_reg(reg);
2220 }
2221}
2222
2223static void
2224_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2225{
2226 jit_int32_t reg;
2227 if (s13_p(i0))
2228 LDSHI(r1, i0, r0);
2229 else {
2230 reg = jit_get_reg(jit_class_gpr);
2231 movi(rn(reg), i0);
2232 ldxr_s(r0, r1, rn(reg));
2233 jit_unget_reg(reg);
2234 }
2235}
2236
2237static void
2238_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2239{
2240 jit_int32_t reg;
2241 if (s13_p(i0))
2242 LDUHI(r1, i0, r0);
2243 else {
2244 reg = jit_get_reg(jit_class_gpr);
2245 movi(rn(reg), i0);
2246 ldxr_us(r0, r1, rn(reg));
2247 jit_unget_reg(reg);
2248 }
2249}
2250
2251static void
2252_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2253{
2254 jit_int32_t reg;
2255 if (s13_p(i0)) {
2256# if __WORDSIZE == 32
2257 LDI(r1, i0, r0);
2258# else
2259 LDSWI(r1, i0, r0);
2260# endif
2261 }
2262 else {
2263 reg = jit_get_reg(jit_class_gpr);
2264 movi(rn(reg), i0);
2265 ldxr_i(r0, r1, rn(reg));
2266 jit_unget_reg(reg);
2267 }
2268}
2269
2270# if __WORDSIZE == 64
2271static void
2272_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2273{
2274 jit_int32_t reg;
2275 if (s13_p(i0))
2276 LDUWI(r1, i0, r0);
2277 else {
2278 reg = jit_get_reg(jit_class_gpr);
2279 movi(rn(reg), i0);
2280 ldxr_ui(r0, r1, rn(reg));
2281 jit_unget_reg(reg);
2282 }
2283}
2284
2285static void
2286_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2287{
2288 jit_int32_t reg;
2289 if (s13_p(i0))
2290 LDXI(r1, i0, r0);
2291 else {
2292 reg = jit_get_reg(jit_class_gpr);
2293 movi(rn(reg), i0);
2294 ldxr_l(r0, r1, rn(reg));
2295 jit_unget_reg(reg);
2296 }
2297}
2298# endif
2299
2300static void
2301_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2302{
2303 jit_int32_t reg;
2304 if (s13_p(i0))
2305 STBI(r0, 0, i0);
2306 else {
2307 reg = jit_get_reg(jit_class_gpr);
2308 movi(rn(reg), i0);
2309 str_c(rn(reg), r0);
2310 jit_unget_reg(reg);
2311 }
2312}
2313
2314static void
2315_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2316{
2317 jit_int32_t reg;
2318 if (s13_p(i0))
2319 STHI(r0, 0, i0);
2320 else {
2321 reg = jit_get_reg(jit_class_gpr);
2322 movi(rn(reg), i0);
2323 str_s(rn(reg), r0);
2324 jit_unget_reg(reg);
2325 }
2326}
2327
2328static void
2329_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2330{
2331 jit_int32_t reg;
2332 if (s13_p(i0)) {
2333# if __WORDSIZE == 32
2334 STI(r0, 0, i0);
2335# else
2336 STWI(r0, 0, i0);
2337# endif
2338 }
2339 else {
2340 reg = jit_get_reg(jit_class_gpr);
2341 movi(rn(reg), i0);
2342 str_i(rn(reg), r0);
2343 jit_unget_reg(reg);
2344 }
2345}
2346
2347# if __WORDSIZE == 64
2348static void
2349_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2350{
2351 jit_int32_t reg;
2352 if (s13_p(i0))
2353 STXI(r0, 0, i0);
2354 else {
2355 reg = jit_get_reg(jit_class_gpr);
2356 movi(rn(reg), i0);
2357 str_l(rn(reg), r0);
2358 jit_unget_reg(reg);
2359 }
2360}
2361# endif
2362
2363static void
2364_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2365{
2366 jit_int32_t reg;
2367 if (s13_p(i0))
2368 STBI(r1, r0, i0);
2369 else {
2370 reg = jit_get_reg(jit_class_gpr);
2371 movi(rn(reg), i0);
2372 stxr_c(r0, rn(reg), r1);
2373 jit_unget_reg(reg);
2374 }
2375}
2376
2377static void
2378_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2379{
2380 jit_int32_t reg;
2381 if (s13_p(i0))
2382 STHI(r1, r0, i0);
2383 else {
2384 reg = jit_get_reg(jit_class_gpr);
2385 movi(rn(reg), i0);
2386 stxr_s(r0, rn(reg), r1);
2387 jit_unget_reg(reg);
2388 }
2389}
2390
2391static void
2392_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2393{
2394 jit_int32_t reg;
2395 if (s13_p(i0)) {
2396# if __WORDSIZE == 32
2397 STI(r1, r0, i0);
2398# else
2399 STWI(r1, r0, i0);
2400# endif
2401 }
2402 else {
2403 reg = jit_get_reg(jit_class_gpr);
2404 movi(rn(reg), i0);
2405 stxr_i(r0, rn(reg), r1);
2406 jit_unget_reg(reg);
2407 }
2408}
2409
2410# if __WORDSIZE == 64
2411static void
2412_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2413{
2414 jit_int32_t reg;
2415 if (s13_p(i0))
2416 STXI(r1, r0, i0);
2417 else {
2418 reg = jit_get_reg(jit_class_gpr);
2419 movi(rn(reg), i0);
2420 stxr_l(r0, rn(reg), r1);
2421 jit_unget_reg(reg);
2422 }
2423}
2424# endif
2425
2426static jit_word_t
2427_br(jit_state_t *_jit, jit_int32_t cc,
2428 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2429{
2430 jit_word_t w;
2431 CMP(r0, r1);
2432 w = _jit->pc.w;
2433# if __WORDSIZE == 32
2434 B(cc, (i0 - w) >> 2);
2435# else
2436 BP(cc, (i0 - w) >> 2);
2437# endif
2438 NOP();
2439 return (w);
2440}
2441
2442static jit_word_t
2443_bw(jit_state_t *_jit, jit_int32_t cc,
2444 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2445{
2446 jit_word_t w;
2447 jit_int32_t reg;
2448 if (s13_p(i1)) {
2449 CMPI(r0, i1);
2450 w = _jit->pc.w;
2451# if __WORDSIZE == 32
2452 B(cc, (i0 - w) >> 2);
2453# else
79bfeef6 2454 BP(cc, (i0 - w) >> 2);
4a71579b
PC		 2455# endif
2456 NOP();
2457 }
2458 else {
2459 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2460 movi(rn(reg), i1);
2461 w = br(cc, i0, r0, rn(reg));
2462 jit_unget_reg(reg);
2463 }
2464 return (w);
2465}
2466
2467static jit_word_t
2468_b_asr(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2469 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2470{
2471 jit_word_t w;
2472 if (add)
2473 ADDcc(r0, r1, r0);
2474 else
2475 SUBcc(r0, r1, r0);
2476 w = _jit->pc.w;
2477# if __WORDSIZE == 32
2478 B(sgn ?
2479 (jif ? SPARC_BVS : SPARC_BVC) :
2480 (jif ? SPARC_BCS : SPARC_BCC),
2481 (i0 - w) >> 2);
2482# else
2483 BP(sgn ?
2484 (jif ? SPARC_BPVS : SPARC_BPVC) :
2485 (jif ? SPARC_BPCS : SPARC_BPCC),
2486 (i0 - w) >> 2);
2487# endif
2488 NOP();
2489 return (w);
2490}
2491
2492static jit_word_t
2493_b_asw(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2494 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2495{
2496 jit_word_t w;
2497 jit_int32_t reg;
2498 if (s13_p(i1)) {
2499 if (add)
2500 ADDIcc(r0, i1, r0);
2501 else
2502 SUBIcc(r0, i1, r0);
2503 w = _jit->pc.w;
2504# if __WORDSIZE == 32
2505 B(sgn ?
2506 (jif ? SPARC_BVS : SPARC_BVC) :
2507 (jif ? SPARC_BCS : SPARC_BCC),
2508 (i0 - w) >> 2);
2509# else
2510 BP(sgn ?
2511 (jif ? SPARC_BPVS : SPARC_BPVC) :
2512 (jif ? SPARC_BPCS : SPARC_BPCC),
2513 (i0 - w) >> 2);
2514# endif
2515 NOP();
2516 }
2517 else {
2518 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2519 movi(rn(reg), i1);
2520 w = b_asr(jif, add, sgn, i0, r0, rn(reg));
2521 jit_unget_reg(reg);
2522 }
2523 return (w);
2524}
2525
2526static jit_word_t
2527_bm_r(jit_state_t *_jit, jit_bool_t set,
2528 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2529{
2530 jit_word_t w;
2531 BTST(r0, r1);
2532 w = _jit->pc.w;
2533# if __WORDSIZE == 32
2534 B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2535# else
2536 BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2537# endif
2538 NOP();
2539 return (w);
2540}
2541
2542static jit_word_t
2543_bm_w(jit_state_t *_jit, jit_bool_t set,
2544 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2545{
2546 jit_word_t w;
2547 jit_int32_t reg;
2548 if (s13_p(i1)) {
2549 BTSTI(r0, i1);
2550 w = _jit->pc.w;
2551# if __WORDSIZE == 32
2552 B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2553# else
2554 BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2555# endif
2556 NOP();
2557 }
2558 else {
2559 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2560 movi(rn(reg), i1);
2561 w = bm_r(set, i0, r0, rn(reg));
2562 jit_unget_reg(reg);
2563 }
2564 return (w);
2565}
2566
2567static void
2568_jmpr(jit_state_t *_jit, jit_int32_t r0)
2569{
2570 JMPL(0, r0, 0);
2571 NOP();
2572}
2573
79bfeef6 2574static jit_word_t
4a71579b
PC		 2575_jmpi(jit_state_t *_jit, jit_word_t i0)
2576{
4a71579b 2577 jit_int32_t reg;
79bfeef6
PC		 2578 jit_word_t d, w;
2579 w = _jit->pc.w;
2580 d = (i0 - w) >> 2;
2581 if (s22_p(d)) {
2582 BA(d);
4a71579b
PC		 2583 NOP();
2584 }
2585 else {
2586 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2587 movi(rn(reg), i0);
2588 jmpr(rn(reg));
2589 jit_unget_reg(reg);
2590 }
79bfeef6 2591 return (w);
4a71579b
PC		 2592}
2593
2594static jit_word_t
2595_jmpi_p(jit_state_t *_jit, jit_word_t i0)
2596{
2597 jit_word_t w;
2598 jit_int32_t reg;
2599 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2600 w = movi_p(rn(reg), i0);
2601 jmpr(rn(reg));
2602 jit_unget_reg(reg);
2603 return (w);
2604}
2605
2606static void
2607_callr(jit_state_t *_jit, jit_int32_t r0)
2608{
2609 CALL(r0);
2610 NOP();
2611}
2612
79bfeef6 2613static jit_word_t
4a71579b
PC		 2614_calli(jit_state_t *_jit, jit_word_t i0)
2615{
79bfeef6
PC		 2616 jit_word_t d, w;
2617 w = _jit->pc.w;
2618 d = (i0 - w) >> 2;
2619 if (s30_p(d)) {
2620 CALLI(d);
c0c16242
PC		 2621 NOP();
2622 }
2623 else
79bfeef6
PC		 2624 w = calli_p(i0);
2625 return (w);
4a71579b
PC		 2626}
2627
2628static jit_word_t
2629_calli_p(jit_state_t *_jit, jit_word_t i0)
2630{
2631 jit_word_t w;
2632 jit_int32_t reg;
2633 reg = jit_get_reg(jit_class_gpr);
2634 w = movi_p(rn(reg), i0);
2635 callr(rn(reg));
2636 jit_unget_reg(reg);
2637 return (w);
2638}
2639
2640#define OFF(n) BIAS(((n) * sizeof(jit_word_t)))
2641static void
2642_prolog(jit_state_t *_jit, jit_node_t *node)
2643{
2644 jit_int32_t reg;
2645 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2646 jit_int32_t frame = -_jitc->function->frame;
2647 assert(_jitc->function->self.aoff >= frame);
2648 if (_jitc->function->assume_frame)
2649 return;
2650 _jitc->function->self.aoff = frame;
2651 }
2652 if (_jitc->function->allocar)
2653 _jitc->function->self.aoff &= -16;
2654 /* align at 16 bytes boundary */
2655 _jitc->function->stack = ((stack_framesize +
2656 _jitc->function->self.alen -
2657 _jitc->function->self.aoff) + 15) & -16;
2658 SAVEI(_SP_REGNO, -_jitc->function->stack, _SP_REGNO);
2659
2660 /* (most) other backends do not save incoming arguments, so,
2661 * only save locals here */
2662 if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2663 stxi(OFF(0), _SP_REGNO, _L0_REGNO);
2664 if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2665 stxi(OFF(1), _SP_REGNO, _L1_REGNO);
2666 if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2667 stxi(OFF(2), _SP_REGNO, _L2_REGNO);
2668 if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2669 stxi(OFF(3), _SP_REGNO, _L3_REGNO);
2670 if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2671 stxi(OFF(4), _SP_REGNO, _L4_REGNO);
2672 if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2673 stxi(OFF(5), _SP_REGNO, _L5_REGNO);
2674 if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2675 stxi(OFF(6), _SP_REGNO, _L6_REGNO);
2676 if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2677 stxi(OFF(7), _SP_REGNO, _L7_REGNO);
2678
2679 if (_jitc->function->allocar) {
2680 reg = jit_get_reg(jit_class_gpr);
2681 movi(rn(reg), BIAS(_jitc->function->self.aoff));
2682 /* Already "biased" by allocai */
2683 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2684 jit_unget_reg(reg);
2685 }
2686
2687 if (_jitc->function->self.call & jit_call_varargs) {
2688 for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2689 stxi(BIAS((16 + (__WORDSIZE == 32)) * sizeof(jit_word_t) +
2690 reg * sizeof(jit_word_t)), _FP_REGNO, rn(_I0 + reg));
2691 }
2692}
2693
2694static void
2695_epilog(jit_state_t *_jit, jit_node_t *node)
2696{
2697 if (_jitc->function->assume_frame)
2698 return;
79bfeef6
PC		 2699 if (_jitc->function->allocar)
2700 subi(_SP_REGNO, _FP_REGNO, _jitc->function->stack);
4a71579b 2701 if (jit_regset_tstbit(&_jitc->function->regset, _L0))
79bfeef6 2702 ldxi(_L0_REGNO, _SP_REGNO, _jitc->function->stack + OFF(0));
4a71579b 2703 if (jit_regset_tstbit(&_jitc->function->regset, _L1))
79bfeef6 2704 ldxi(_L1_REGNO, _SP_REGNO, _jitc->function->stack + OFF(1));
4a71579b 2705 if (jit_regset_tstbit(&_jitc->function->regset, _L2))
79bfeef6 2706 ldxi(_L2_REGNO, _SP_REGNO, _jitc->function->stack + OFF(2));
4a71579b 2707 if (jit_regset_tstbit(&_jitc->function->regset, _L3))
79bfeef6 2708 ldxi(_L3_REGNO, _SP_REGNO, _jitc->function->stack + OFF(3));
4a71579b 2709 if (jit_regset_tstbit(&_jitc->function->regset, _L4))
79bfeef6 2710 ldxi(_L4_REGNO, _SP_REGNO, _jitc->function->stack + OFF(4));
4a71579b 2711 if (jit_regset_tstbit(&_jitc->function->regset, _L5))
79bfeef6 2712 ldxi(_L5_REGNO, _SP_REGNO, _jitc->function->stack + OFF(5));
4a71579b 2713 if (jit_regset_tstbit(&_jitc->function->regset, _L6))
79bfeef6 2714 ldxi(_L6_REGNO, _SP_REGNO, _jitc->function->stack + OFF(6));
4a71579b 2715 if (jit_regset_tstbit(&_jitc->function->regset, _L7))
79bfeef6 2716 ldxi(_L7_REGNO, _SP_REGNO, _jitc->function->stack + OFF(7));
4a71579b
PC		 2717 RESTOREI(0, 0, 0);
2718 RETL();
2719 NOP();
2720}
2721
2722static void
2723_vastart(jit_state_t *_jit, jit_int32_t r0)
2724{
2725 /* Initialize stack pointer to the first stack argument. */
2726 if (jit_arg_reg_p(_jitc->function->vagp))
2727 addi(r0, _FP_REGNO, BIAS((16 + (__WORDSIZE == 32) +
2728 _jitc->function->vagp) *
2729 sizeof(jit_word_t)));
2730 else
2731 addi(r0, _FP_REGNO, BIAS(_jitc->function->self.size));
2732}
2733
2734static void
2735_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2736{
2737 assert(_jitc->function->self.call & jit_call_varargs);
2738
2739 /* Load argument. */
2740 ldr(r0, r1);
2741
2742 /* Update vararg stack pointer. */
2743 addi(r1, r1, sizeof(jit_word_t));
2744}
2745
2746static void
2747_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2748{
2749 jit_instr_t i;
2750 union {
2751 jit_int32_t *i;
2752 jit_word_t w;
2753 } u;
2754
2755 u.w = instr;
2756 i.v = u.i[0];
2757
2758 if (i.op.b == 0) { /* conditional branch */
2759 if (i.op2.b == 2 || i.op2.b == 6) { /* int or float condition */
2760 i.disp22.b = (label - instr) >> 2;
2761 u.i[0] = i.v;
2762 }
2763# if __WORDSIZE == 64
2764 else if (i.op2.b == 1) {
2765 i.disp19.b = (label - instr) >> 2;
2766 u.i[0] = i.v;
2767 }
2768# endif
2769 else if (i.op2.b == 4) { /* movi_p */
2770 /* SETHI */
2771 i.imm22.b = HI((int)label);
2772 u.i[0] = i.v;
2773 i.v = u.i[1];
2774 if (i.op.b == 2 && i.op3.b == 2) {
2775 /* ORI */
2776 i.simm13.b = LO(label);
2777 u.i[1] = i.v;
2778# if __WORDSIZE == 64
2779 i.v = u.i[2];
2780 assert(i.op2.b == 4);
2781 label = (label >> 32) & 0xffffffff;
2782 i.imm22.b = HI((int)label);
2783 u.i[2] = i.v;
2784 i.v = u.i[3];
2785 assert(i.op.b == 2 && i.op3.b == 2);
2786 /* ORI */
2787 i.simm13.b = LO(label);
2788 u.i[3] = i.v;
2789# endif
2790 }
2791 else
2792 abort();
2793 }
2794 else
2795 abort();
2796 }
79bfeef6
PC		 2797 else if (i.op.b == 1) {
2798 assert(s30_p((label - instr) >> 2));
2799 i.disp30.b = (label - instr) >> 2;
2800 u.i[0] = i.v;
2801 }
4a71579b
PC		 2802 else
2803 abort();
2804}
2805#endif
ARM optimized PCSX fork