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