notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update lightrec 20220910 (#686)
[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);
ba3814c1
PC		 555# define casx(r0, r1, r2, r3, i0) _casx(_jit, r0, r1, r2, r3, i0)
556static void _casx(jit_state_t *_jit,jit_int32_t,jit_int32_t,
557 jit_int32_t,jit_int32_t,jit_word_t);
558#define casr(r0, r1, r2, r3) casx(r0, r1, r2, r3, 0)
559#define casi(r0, i0, r1, r2) casx(r0, _NOREG, r1, r2, i0)
4a71579b
PC		 560# define comr(r0, r1) XNOR(r1, 0, r0)
561# define negr(r0, r1) NEG(r1, r0)
562# define addr(r0, r1, r2) ADD(r1, r2, r0)
563# define addi(r0, r1, i0) _addi(_jit, r0, r1, i0)
564static void _addi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
565# if __WORDSIZE == 32
566# define addcr(r0, r1, r2) ADDcc(r1, r2, r0)
567# else
568# define addcr(r0, r1, r2) _addcr(_jit, r0, r1, r2)
569static void _addcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
570# endif
571# define addci(r0, r1, i0) _addci(_jit, r0, r1, i0)
572static void _addci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
573# if __WORDSIZE == 32
574# define addxr(r0, r1, r2) ADDXcc(r1, r2, r0)
575# else
576# define addxr(r0, r1, r2) _addxr(_jit, r0, r1, r2)
577static void _addxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
578# endif
579# define addxi(r0, r1, i0) _addxi(_jit, r0, r1, i0)
580static void _addxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
581# define subr(r0, r1, r2) SUB(r1, r2, r0)
582# define subi(r0, r1, i0) _subi(_jit, r0, r1, i0)
583static void _subi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
584# if __WORDSIZE == 32
585# define subcr(r0, r1, r2) SUBcc(r1, r2, r0)
586# else
587# define subcr(r0, r1, r2) _subcr(_jit, r0, r1, r2)
588static void _subcr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
589# endif
590# define subci(r0, r1, i0) _subci(_jit, r0, r1, i0)
591static void _subci(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
592# if __WORDSIZE == 32
593# define subxr(r0, r1, r2) SUBXcc(r1, r2, r0)
594# else
595# define subxr(r0, r1, r2) _subxr(_jit, r0, r1, r2)
596static void _subxr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
597# endif
598# define subxi(r0, r1, i0) _subxi(_jit, r0, r1, i0)
599static void _subxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
600# define rsbi(r0, r1, i0) _rsbi(_jit, r0, r1, i0)
601static void _rsbi(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
602# if __WORDSIZE == 32
603# define mulr(r0, r1, r2) UMUL(r1, r2, r0)
604# else
605# define mulr(r0, r1, r2) MULX(r1, r2, r0)
606# endif
607# define muli(r0, r1, i0) _muli(_jit, r0, r1, i0)
608static void _muli(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
609# if __WORDSIZE == 32
610# define qmulr(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,1)
611# define qmulr_u(r0,r1,r2,r3) iqmulr(r0,r1,r2,r3,0)
612# define iqmulr(r0,r1,r2,r3,cc) _iqmulr(_jit,r0,r1,r2,r3,cc)
613static void _iqmulr(jit_state_t*,jit_int32_t,jit_int32_t,
614 jit_int32_t,jit_int32_t,jit_bool_t);
615# define qmuli(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,1)
616# define qmuli_u(r0,r1,r2,i0) iqmuli(r0,r1,r2,i0,0)
617# define iqmuli(r0,r1,r2,i0,cc) _iqmuli(_jit,r0,r1,r2,i0,cc)
618static void _iqmuli(jit_state_t*,jit_int32_t,jit_int32_t,
619 jit_int32_t,jit_word_t,jit_bool_t);
620# else
621# define qmulr(r0,r1,r2,r3) _qmulr(_jit,r0,r1,r2,r3)
622static void _qmulr(jit_state_t*,jit_int32_t,jit_int32_t,
623 jit_int32_t,jit_int32_t);
624# define qmuli(r0,r1,r2,i0) _qmuli(_jit,r0,r1,r2,i0)
625static void _qmuli(jit_state_t*,jit_int32_t,jit_int32_t,
626 jit_int32_t,jit_word_t);
627# define qmulr_u(r0,r1,r2,r3) _qmulr_u(_jit,r0,r1,r2,r3)
628static void _qmulr_u(jit_state_t*,jit_int32_t,jit_int32_t,
629 jit_int32_t,jit_int32_t);
630# define qmuli_u(r0,r1,r2,i0) _qmuli_u(_jit,r0,r1,r2,i0)
631static void _qmuli_u(jit_state_t*,jit_int32_t,jit_int32_t,
632 jit_int32_t,jit_word_t);
633# endif
634# define divr(r0, r1, r2) _divr(_jit, r0, r1, r2)
635static void _divr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
636# define divi(r0, r1, i0) _divi(_jit, r0, r1, i0)
637static void _divi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
638# define divr_u(r0, r1, r2) _divr_u(_jit, r0, r1, r2)
639static void _divr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
640# define divi_u(r0, r1, i0) _divi_u(_jit, r0, r1, i0)
641static void _divi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
642# define qdivr(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,1)
643# define qdivr_u(r0,r1,r2,r3) iqdivr(r0,r1,r2,r3,0)
644# define iqdivr(r0,r1,r2,r3,cc) _iqdivr(_jit,r0,r1,r2,r3,cc)
645static void _iqdivr(jit_state_t*,jit_int32_t,jit_int32_t,
646 jit_int32_t,jit_int32_t,jit_bool_t);
647# define qdivi(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,1)
648# define qdivi_u(r0,r1,r2,i0) iqdivi(r0,r1,r2,i0,0)
649# define iqdivi(r0,r1,r2,i0,cc) _iqdivi(_jit,r0,r1,r2,i0,cc)
650static void _iqdivi(jit_state_t*,jit_int32_t,jit_int32_t,
651 jit_int32_t,jit_word_t,jit_bool_t);
652# define remr(r0, r1, r2) _remr(_jit, r0, r1, r2)
653static void _remr(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
654# define remi(r0, r1, i0) _remi(_jit, r0, r1, i0)
655static void _remi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
656# define remr_u(r0, r1, r2) _remr_u(_jit, r0, r1, r2)
657static void _remr_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_int32_t);
658# define remi_u(r0, r1, i0) _remi_u(_jit, r0, r1, i0)
659static void _remi_u(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
660# define andr(r0, r1, r2) AND(r1, r2, r0)
661# define andi(r0, r1, i0) _andi(_jit, r0, r1, i0)
662static void _andi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
663# define orr(r0, r1, r2) OR(r1, r2, r0)
664# define ori(r0, r1, i0) _ori(_jit, r0, r1, i0)
665static void _ori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
666# define xorr(r0, r1, r2) XOR(r1, r2, r0)
667# define xori(r0, r1, i0) _xori(_jit, r0, r1, i0)
668static void _xori(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
669# if __WORDSIZE == 32
670# define lshr(r0, r1, r2) SLL(r1, r2, r0)
671# define lshi(r0, r1, i0) SLLI(r1, i0, r0)
672# define rshr(r0, r1, r2) SRA(r1, r2, r0)
673# define rshi(r0, r1, i0) SRAI(r1, i0, r0)
674# define rshr_u(r0, r1, r2) SRL(r1, r2, r0)
675# define rshi_u(r0, r1, i0) SRLI(r1, i0, r0)
676# else
677# define lshr(r0, r1, r2) SLLX(r1, r2, r0)
678# define lshi(r0, r1, i0) SLLXI(r1, i0, r0)
679# define rshr(r0, r1, r2) SRAX(r1, r2, r0)
680# define rshi(r0, r1, i0) SRAXI(r1, i0, r0)
681# define rshr_u(r0, r1, r2) SRLX(r1, r2, r0)
682# define rshi_u(r0, r1, i0) SRLXI(r1, i0, r0)
683# endif
4a71579b
PC		 684# define extr_c(r0,r1) _extr_c(_jit,r0,r1)
685static void _extr_c(jit_state_t*,jit_int32_t,jit_int32_t);
686# define extr_uc(r0,r1) andi(r0, r1, 0xff)
687# define extr_s(r0,r1) _extr_s(_jit,r0,r1)
688static void _extr_s(jit_state_t*,jit_int32_t,jit_int32_t);
689# define extr_us(r0,r1) _extr_us(_jit,r0,r1)
690static void _extr_us(jit_state_t*,jit_int32_t,jit_int32_t);
40a44dcb 691# if __WORDSIZE == 64
4a71579b
PC		 692# define extr_i(r0,r1) _extr_i(_jit,r0,r1)
693static void _extr_i(jit_state_t*,jit_int32_t,jit_int32_t);
694# define extr_ui(r0,r1) _extr_ui(_jit,r0,r1)
695static void _extr_ui(jit_state_t*,jit_int32_t,jit_int32_t);
696# endif
697# define cr(cc, r0, r1, r2) _cr(_jit, cc, r0, r1, r2)
698static void _cr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
699# define cw(cc, r0, r1, i0) _cw(_jit, cc, r0, r1, i0)
700static void _cw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_word_t);
701# if __WORDSIZE == 32
702# define ltr(r0, r1, r2) cr(SPARC_BL, r0, r1, r2)
703# define lti(r0, r1, i0) cw(SPARC_BL, r0, r1, i0)
704# define ltr_u(r0, r1, r2) cr(SPARC_BLU, r0, r1, r2)
705# define lti_u(r0, r1, i0) cw(SPARC_BLU, r0, r1, i0)
706# define ler(r0, r1, r2) cr(SPARC_BLE, r0, r1, r2)
707# define lei(r0, r1, i0) cw(SPARC_BLE, r0, r1, i0)
708# define ler_u(r0, r1, r2) cr(SPARC_BLEU, r0, r1, r2)
709# define lei_u(r0, r1, i0) cw(SPARC_BLEU, r0, r1, i0)
710# define eqr(r0, r1, r2) cr(SPARC_BE, r0, r1, r2)
711# define eqi(r0, r1, i0) cw(SPARC_BE, r0, r1, i0)
712# define ger(r0, r1, r2) cr(SPARC_BGE, r0, r1, r2)
713# define gei(r0, r1, i0) cw(SPARC_BGE, r0, r1, i0)
714# define ger_u(r0, r1, r2) cr(SPARC_BGEU, r0, r1, r2)
715# define gei_u(r0, r1, i0) cw(SPARC_BGEU, r0, r1, i0)
716# define gtr(r0, r1, r2) cr(SPARC_BG, r0, r1, r2)
717# define gti(r0, r1, i0) cw(SPARC_BG, r0, r1, i0)
718# define gtr_u(r0, r1, r2) cr(SPARC_BGU, r0, r1, r2)
719# define gti_u(r0, r1, i0) cw(SPARC_BGU, r0, r1, i0)
720# define ner(r0, r1, r2) cr(SPARC_BNE, r0, r1, r2)
721# define nei(r0, r1, i0) cw(SPARC_BNE, r0, r1, i0)
722# else
723# define ltr(r0, r1, r2) cr(SPARC_BPL, r0, r1, r2)
724# define lti(r0, r1, i0) cw(SPARC_BPL, r0, r1, i0)
725# define ltr_u(r0, r1, r2) cr(SPARC_BPCS, r0, r1, r2)
726# define lti_u(r0, r1, i0) cw(SPARC_BPCS, r0, r1, i0)
727# define ler(r0, r1, r2) cr(SPARC_BPLE, r0, r1, r2)
728# define lei(r0, r1, i0) cw(SPARC_BPLE, r0, r1, i0)
729# define ler_u(r0, r1, r2) cr(SPARC_BPLEU, r0, r1, r2)
730# define lei_u(r0, r1, i0) cw(SPARC_BPLEU, r0, r1, i0)
731# define eqr(r0, r1, r2) cr(SPARC_BPE, r0, r1, r2)
732# define eqi(r0, r1, i0) cw(SPARC_BPE, r0, r1, i0)
733# define ger(r0, r1, r2) cr(SPARC_BPGE, r0, r1, r2)
734# define gei(r0, r1, i0) cw(SPARC_BPGE, r0, r1, i0)
735# define ger_u(r0, r1, r2) cr(SPARC_BPCC, r0, r1, r2)
736# define gei_u(r0, r1, i0) cw(SPARC_BPCC, r0, r1, i0)
737# define gtr(r0, r1, r2) cr(SPARC_BPG, r0, r1, r2)
738# define gti(r0, r1, i0) cw(SPARC_BPG, r0, r1, i0)
739# define gtr_u(r0, r1, r2) cr(SPARC_BPGU, r0, r1, r2)
740# define gti_u(r0, r1, i0) cw(SPARC_BPGU, r0, r1, i0)
741# define ner(r0, r1, r2) cr(SPARC_BPNE, r0, r1, r2)
742# define nei(r0, r1, i0) cw(SPARC_BPNE, r0, r1, i0)
743# endif
744# define ldr_c(r0, r1) LDSB(r1, 0, r0)
745# define ldi_c(r0, i0) _ldi_c(_jit, r0, i0)
746static void _ldi_c(jit_state_t*,jit_int32_t,jit_word_t);
747# define ldr_uc(r0, r1) LDUB(r1, 0, r0)
748# define ldi_uc(r0, i0) _ldi_uc(_jit, r0, i0)
749static void _ldi_uc(jit_state_t*,jit_int32_t,jit_word_t);
750# define ldr_s(r0, r1) LDSH(r1, 0, r0)
751# define ldi_s(r0, i0) _ldi_s(_jit, r0, i0)
752static void _ldi_s(jit_state_t*,jit_int32_t,jit_word_t);
753# define ldr_us(r0, r1) LDUH(r1, 0, r0)
754# define ldi_us(r0, i0) _ldi_us(_jit, r0, i0)
755static void _ldi_us(jit_state_t*,jit_int32_t,jit_word_t);
756# if __WORDSIZE == 32
757# define ldr_i(r0, r1) LD(r1, 0, r0)
758# define ldr(u, v) ldr_i(u, v)
759# define ldi(u, v) ldi_i(u, v)
760# else
761# define ldr_i(r0, r1) LDSW(r1, 0, r0)
762# define ldr_ui(r0, r1) LDUW(r1, 0, r0)
763# define ldr_l(r0, r1) LDX(r1, 0, r0)
764# define ldr(u, v) ldr_l(u, v)
765# define ldi(u, v) ldi_l(u, v)
766# endif
767# define ldi_i(r0, i0) _ldi_i(_jit, r0, i0)
768static void _ldi_i(jit_state_t*,jit_int32_t,jit_word_t);
769# if __WORDSIZE == 64
770# define ldi_ui(r0, i0) _ldi_ui(_jit, r0, i0)
771static void _ldi_ui(jit_state_t*,jit_int32_t,jit_word_t);
772# define ldi_l(r0, i0) _ldi_l(_jit, r0, i0)
773static void _ldi_l(jit_state_t*,jit_int32_t,jit_word_t);
774# endif
775# define ldxr_c(r0, r1, r2) LDSB(r1, r2, r0)
776# define ldxi_c(r0, r1, i0) _ldxi_c(_jit, r0, r1, i0)
777static void _ldxi_c(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
778# define ldxr_uc(r0, r1, r2) LDUB(r1, r2, r0)
779# define ldxi_uc(r0, r1, i0) _ldxi_uc(_jit, r0, r1, i0)
780static void _ldxi_uc(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
781# define ldxr_s(r0, r1, r2) LDSH(r1, r2, r0)
782# define ldxi_s(r0, r1, i0) _ldxi_s(_jit, r0, r1, i0)
783static void _ldxi_s(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
784# define ldxr_us(r0, r1, r2) LDUH(r1, r2, r0)
785# define ldxi_us(r0, r1, i0) _ldxi_us(_jit, r0, r1, i0)
786static void _ldxi_us(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
787# if __WORDSIZE == 32
788# define ldxr(u, v, w) ldxr_i(u, v, w)
789# define ldxr_i(r0, r1, r2) LD(r1, r2, r0)
790# define ldxi(u, v, w) ldxi_i(u, v, w)
791# else
792# define ldxr(u, v, w) ldxr_l(u, v, w)
793# define ldxr_i(r0, r1, r2) LDSW(r1, r2, r0)
794# define ldxr_ui(r0, r1, r2) LDUW(r1, r2, r0)
795# define ldxr_l(r0, r1, r2) LDX(r1, r2, r0)
796# define ldxi(u, v, w) ldxi_l(u, v, w)
797# endif
798# define ldxi_i(r0, r1, i0) _ldxi_i(_jit, r0, r1, i0)
799static void _ldxi_i(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
800# if __WORDSIZE == 64
801# define ldxi_ui(r0, r1, i0) _ldxi_ui(_jit, r0, r1, i0)
802static void _ldxi_ui(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
803# define ldxi_l(r0, r1, i0) _ldxi_l(_jit, r0, r1, i0)
804static void _ldxi_l(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
805# endif
806# define str_c(r0, r1) STB(r1, r0, 0)
807# define sti_c(i0, r0) _sti_c(_jit, i0, r0)
808static void _sti_c(jit_state_t*,jit_word_t,jit_int32_t);
809# define str_s(r0, r1) STH(r1, r0, 0)
810# define sti_s(i0, r0) _sti_s(_jit, i0, r0)
811static void _sti_s(jit_state_t*,jit_word_t,jit_int32_t);
812# if __WORDSIZE == 32
813# define str(u, v) str_i(u, v)
814# define str_i(r0, r1) STI(r1, r0, 0)
815# define sti(u, v) sti_i(u, v)
816# else
817# define str(u, v) str_l(u, v)
818# define str_i(r0, r1) STW(r1, r0, 0)
819# define str_l(r0, r1) STX(r1, r0, 0)
820# define sti(u, v) sti_l(u, v)
821# endif
822# define sti_i(i0, r0) _sti_i(_jit, i0, r0)
823static void _sti_i(jit_state_t*,jit_word_t,jit_int32_t);
824# if __WORDSIZE == 64
825# define sti_l(i0, r0) _sti_l(_jit, i0, r0)
826static void _sti_l(jit_state_t*,jit_word_t,jit_int32_t);
827# endif
828# define stxr_c(r0, r1, r2) STB(r2, r1, r0)
829# define stxi_c(i0, r0, r1) _stxi_c(_jit, i0, r0, r1)
830static void _stxi_c(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
831# define stxr_s(r0, r1, r2) STH(r2, r1, r0)
832# define stxi_s(i0, r0, r1) _stxi_s(_jit, i0, r0, r1)
833static void _stxi_s(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
834# if __WORDSIZE == 32
835# define stxr(u, v, w) stxr_i(u, v, w)
836# define stxr_i(r0, r1, r2) ST(r2, r1, r0)
837# define stxi(u, v, w) stxi_i(u, v, w)
838# else
839# define stxr(u, v, w) stxr_l(u, v, w)
840# define stxr_i(r0, r1, r2) STW(r2, r1, r0)
841# define stxi(u, v, w) stxi_l(u, v, w)
842# define stxr_l(r0, r1, r2) STX(r2, r1, r0)
843# endif
844# define stxi_i(i0, r0, r1) _stxi_i(_jit, i0, r0, r1)
845static void _stxi_i(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
846# if __WORDSIZE == 64
847# define stxi_l(i0, r0, r1) _stxi_l(_jit, i0, r0, r1)
848static void _stxi_l(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
849# endif
850# define br(cc, i0, r0, r1) _br(_jit, cc, i0, r0, r1)
851static jit_word_t
852_br(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
853# define bw(cc, i0, r0, i1) _bw(_jit, cc, i0, r0, i1)
854static jit_word_t
855_bw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_word_t);
856# if __WORDSIZE == 32
857# define bltr(i0, r0, r1) br(SPARC_BL, i0, r0, r1)
858# define blti(i0, r0, i1) bw(SPARC_BL, i0, r0, i1)
859# define bltr_u(i0, r0, r1) br(SPARC_BLU, i0, r0, r1)
860# define blti_u(i0, r0, i1) bw(SPARC_BLU, i0, r0, i1)
861# define bler(i0, r0, r1) br(SPARC_BLE, i0, r0, r1)
862# define blei(i0, r0, i1) bw(SPARC_BLE, i0, r0, i1)
863# define bler_u(i0, r0, r1) br(SPARC_BLEU, i0, r0, r1)
864# define blei_u(i0, r0, i1) bw(SPARC_BLEU, i0, r0, i1)
865# define beqr(i0, r0, r1) br(SPARC_BE, i0, r0, r1)
866# define beqi(i0, r0, i1) bw(SPARC_BE, i0, r0, i1)
867# define bger(i0, r0, r1) br(SPARC_BGE, i0, r0, r1)
868# define bgei(i0, r0, i1) bw(SPARC_BGE, i0, r0, i1)
869# define bger_u(i0, r0, r1) br(SPARC_BGEU, i0, r0, r1)
870# define bgei_u(i0, r0, i1) bw(SPARC_BGEU, i0, r0, i1)
871# define bgtr(i0, r0, r1) br(SPARC_BG, i0, r0, r1)
872# define bgti(i0, r0, i1) bw(SPARC_BG, i0, r0, i1)
873# define bgtr_u(i0, r0, r1) br(SPARC_BGU, i0, r0, r1)
874# define bgti_u(i0, r0, i1) bw(SPARC_BGU, i0, r0, i1)
875# define bner(i0, r0, r1) br(SPARC_BNE, i0, r0, r1)
876# define bnei(i0, r0, i1) bw(SPARC_BNE, i0, r0, i1)
877# else
878# define bltr(i0, r0, r1) br(SPARC_BPL, i0, r0, r1)
879# define blti(i0, r0, i1) bw(SPARC_BPL, i0, r0, i1)
880# define bltr_u(i0, r0, r1) br(SPARC_BPCS, i0, r0, r1)
881# define blti_u(i0, r0, i1) bw(SPARC_BPCS, i0, r0, i1)
882# define bler(i0, r0, r1) br(SPARC_BPLE, i0, r0, r1)
883# define blei(i0, r0, i1) bw(SPARC_BPLE, i0, r0, i1)
884# define bler_u(i0, r0, r1) br(SPARC_BPLEU, i0, r0, r1)
885# define blei_u(i0, r0, i1) bw(SPARC_BPLEU, i0, r0, i1)
886# define beqr(i0, r0, r1) br(SPARC_BPE, i0, r0, r1)
887# define beqi(i0, r0, i1) bw(SPARC_BPE, i0, r0, i1)
888# define bger(i0, r0, r1) br(SPARC_BPGE, i0, r0, r1)
889# define bgei(i0, r0, i1) bw(SPARC_BPGE, i0, r0, i1)
890# define bger_u(i0, r0, r1) br(SPARC_BPCC, i0, r0, r1)
891# define bgei_u(i0, r0, i1) bw(SPARC_BPCC, i0, r0, i1)
892# define bgtr(i0, r0, r1) br(SPARC_BPG, i0, r0, r1)
893# define bgti(i0, r0, i1) bw(SPARC_BPG, i0, r0, i1)
894# define bgtr_u(i0, r0, r1) br(SPARC_BPGU, i0, r0, r1)
895# define bgti_u(i0, r0, i1) bw(SPARC_BPGU, i0, r0, i1)
896# define bner(i0, r0, r1) br(SPARC_BPNE, i0, r0, r1)
897# define bnei(i0, r0, i1) bw(SPARC_BPNE, i0, r0, i1)
898# endif
899# define b_asr(jif,add,sgn,i0,r0,r1) _b_asr(_jit,jif,add,sgn,i0,r0,r1)
900static jit_word_t
901_b_asr(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
902 jit_word_t,jit_int32_t,jit_int32_t);
903# define b_asw(jif,add,sgn,i0,r0,i1) _b_asw(_jit,jif,add,sgn,i0,r0,i1)
904static jit_word_t
905_b_asw(jit_state_t*,jit_bool_t,jit_bool_t,jit_bool_t,
906 jit_word_t,jit_int32_t,jit_word_t);
907# define boaddr(i0, r0, r1) b_asr(1, 1, 1, i0, r0, r1)
908# define boaddi(i0, r0, i1) b_asw(1, 1, 1, i0, r0, i1)
909# define boaddr_u(i0, r0, r1) b_asr(1, 1, 0, i0, r0, r1)
910# define boaddi_u(i0, r0, i1) b_asw(1, 1, 0, i0, r0, i1)
911# define bxaddr(i0, r0, r1) b_asr(0, 1, 1, i0, r0, r1)
912# define bxaddi(i0, r0, i1) b_asw(0, 1, 1, i0, r0, i1)
913# define bxaddr_u(i0, r0, r1) b_asr(0, 1, 0, i0, r0, r1)
914# define bxaddi_u(i0, r0, i1) b_asw(0, 1, 0, i0, r0, i1)
915# define bosubr(i0, r0, r1) b_asr(1, 0, 1, i0, r0, r1)
916# define bosubi(i0, r0, i1) b_asw(1, 0, 1, i0, r0, i1)
917# define bosubr_u(i0, r0, r1) b_asr(1, 0, 0, i0, r0, r1)
918# define bosubi_u(i0, r0, i1) b_asw(1, 0, 0, i0, r0, i1)
919# define bxsubr(i0, r0, r1) b_asr(0, 0, 1, i0, r0, r1)
920# define bxsubi(i0, r0, i1) b_asw(0, 0, 1, i0, r0, i1)
921# define bxsubr_u(i0, r0, r1) b_asr(0, 0, 0, i0, r0, r1)
922# define bxsubi_u(i0, r0, i1) b_asw(0, 0, 0, i0, r0, i1)
923# define bm_r(set, i0, r0, r1) _bm_r(_jit,set,i0,r0,r1)
924static jit_word_t
925_bm_r(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_int32_t);
926# define bm_w(set,i0,r0,i1) _bm_w(_jit,set,i0,r0,i1)
927static jit_word_t
928_bm_w(jit_state_t*,jit_bool_t,jit_word_t,jit_int32_t,jit_word_t);
929# define bmsr(i0, r0, r1) bm_r(1, i0, r0, r1)
930# define bmsi(i0, r0, i1) bm_w(1, i0, r0, i1)
931# define bmcr(i0, r0, r1) bm_r(0, i0, r0, r1)
932# define bmci(i0, r0, i1) bm_w(0, i0, r0, i1)
933# define jmpr(r0) _jmpr(_jit, r0)
934static void _jmpr(jit_state_t*,jit_int32_t);
935# define jmpi(i0) _jmpi(_jit, i0)
936static void _jmpi(jit_state_t*,jit_word_t);
937# define jmpi_p(i0) _jmpi_p(_jit, i0)
938static jit_word_t _jmpi_p(jit_state_t*,jit_word_t);
939# define callr(r0) _callr(_jit, r0)
940static void _callr(jit_state_t*,jit_int32_t);
941# define calli(i0) _calli(_jit, i0)
942static void _calli(jit_state_t*,jit_word_t);
943# define calli_p(i0) _calli_p(_jit, i0)
944static jit_word_t _calli_p(jit_state_t*,jit_word_t);
945# define prolog(node) _prolog(_jit, node)
946static void _prolog(jit_state_t*,jit_node_t*);
947# define epilog(node) _epilog(_jit, node)
948static void _epilog(jit_state_t*,jit_node_t*);
949#define vastart(r0) _vastart(_jit, r0)
950static void _vastart(jit_state_t*, jit_int32_t);
951#define vaarg(r0, r1) _vaarg(_jit, r0, r1)
952static void _vaarg(jit_state_t*, jit_int32_t, jit_int32_t);
953#define patch_at(jump, label) _patch_at(_jit, jump, label)
954static void _patch_at(jit_state_t*,jit_word_t,jit_word_t);
955#endif
956
957#if CODE
958static void
959_f2r(jit_state_t *_jit,
960 jit_int32_t op, jit_int32_t rd, jit_int32_t op2, jit_int32_t imm22)
961{
962 jit_instr_t v;
963 assert(!(op & 0xfffffffc));
964 assert(!(rd & 0xffffffe0));
965 assert(!(op2 & 0xfffffff8));
966 assert(s22_p(imm22));
967 v.op.b = op;
968 v.rd.b = rd;
969 v.op2.b = op2;
970 v.imm22.b = imm22;
971 ii(v.v);
972}
973
974static void
975_f2b(jit_state_t *_jit,
976 jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
977 jit_int32_t disp22)
978{
979 jit_instr_t v;
980 assert(!(op & 0xfffffffc));
981 assert(!(a & 0xfffffffe));
982 assert(!(cond & 0xfffffff0));
983 assert(!(op2 & 0xfffffff8));
984 assert(s22_p(disp22));
985 v.op.b = op;
986 v.a.b = a;
987 v.cond.b = cond;
988 v.op2.b = op2;
989 v.disp22.b = disp22;
990 ii(v.v);
991}
992
993# if __WORDSIZE == 64
994static void
995_f2bp(jit_state_t *_jit,
996 jit_int32_t op, jit_int32_t a, jit_int32_t cond, jit_int32_t op2,
997 jit_int32_t cc1, jit_int32_t cc0, jit_int32_t p, jit_int32_t disp19)
998{
999 jit_instr_t v;
1000 assert(!(op & 0xfffffffc));
1001 assert(!(a & 0xfffffffe));
1002 assert(!(cond & 0xfffffff0));
1003 assert(!(op2 & 0xfffffff8));
1004 assert(s19_p(disp19));
1005 v.op.b = op;
1006 v.a.b = a;
1007 v.cond.b = cond;
1008 v.op2.b = op2;
1009 v.cc1.b = cc1;
1010 v.cc0.b = cc0;
1011 v.p.b = p;
1012 v.disp19.b = disp19;
1013 ii(v.v);
1014}
1015# endif
1016
1017static void
1018_f3r(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1019 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1020{
1021 jit_instr_t v;
1022 assert(!(op & 0xfffffffc));
1023 assert(!(rd & 0xffffffe0));
1024 assert(!(op3 & 0xffffffc0));
1025 assert(!(rs1 & 0xffffffe0));
1026 assert(!(rs2 & 0xffffffe0));
1027 v.op.b = op;
1028 v.rd.b = rd;
1029 v.op3.b = op3;
1030 v.rs1.b = rs1;
1031 v.i.b = 0;
1032 v.asi.b = 0;
1033 v.rs2.b = rs2;
1034 ii(v.v);
1035}
1036
1037# if __WORDSIZE == 64
1038static void
1039_f3rx(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1040 jit_int32_t op3, jit_int32_t rs1, jit_int32_t rs2)
1041{
1042 jit_instr_t v;
1043 assert(!(op & 0xfffffffc));
1044 assert(!(rd & 0xffffffe0));
1045 assert(!(op3 & 0xffffffc0));
1046 assert(!(rs1 & 0xffffffe0));
1047 assert(!(rs2 & 0xffffffe0));
1048 v.op.b = op;
1049 v.rd.b = rd;
1050 v.op3.b = op3;
1051 v.rs1.b = rs1;
1052 v.i.b = 0;
1053 v.x.b = 1;
1054 v.asix.b = 0;
1055 v.rs2.b = rs2;
1056 ii(v.v);
1057}
1058
1059static void
1060_f3s(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1061 jit_int32_t op3, jit_int32_t rs1, jit_int32_t shim)
1062{
1063 jit_instr_t v;
1064 assert(!(op & 0xfffffffc));
1065 assert(!(rd & 0xffffffe0));
1066 assert(!(op3 & 0xffffffc0));
1067 assert(!(rs1 & 0xffffffe0));
1068 assert(!(shim & 0xffffffc0));
1069 v.op.b = op;
1070 v.rd.b = rd;
1071 v.op3.b = op3;
1072 v.rs1.b = rs1;
1073 v.i.b = 1;
1074 v.x.b = 1;
1075 v.asis.b = 0;
1076 v.shim.b = shim;
1077 ii(v.v);
1078}
1079# endif
1080
1081static void
1082_f3i(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1083 jit_int32_t op3, jit_int32_t rs1, jit_int32_t simm13)
1084{
1085 jit_instr_t v;
1086 assert(!(op & 0xfffffffc));
1087 assert(!(rd & 0xffffffe0));
1088 assert(!(op3 & 0xffffffc0));
1089 assert(!(rs1 & 0xffffffe0));
1090 assert(s13_p(simm13));
1091 v.op.b = op;
1092 v.rd.b = rd;
1093 v.op3.b = op3;
1094 v.rs1.b = rs1;
1095 v.i.b = 1;
1096 v.simm13.b = simm13;
1097 ii(v.v);
1098}
1099
1100static void
1101_f3t(jit_state_t *_jit, jit_int32_t cond,
1102 jit_int32_t rs1, jit_int32_t i, jit_int32_t rs2_imm7)
1103{
1104 jit_instr_t v;
1105 assert(!(cond & 0xfffffff0));
1106 assert(!(i & 0xfffffffe));
1107 assert(!(rs1 & 0xffffffe0));
1108 v.op.b = 2;
1109 v.rd.b = cond;
1110 v.op3.b = 58;
1111 v.i.b = i;
1112 if (i) {
1113 assert(s7_p(rs2_imm7));
1114 v.res.b = 0;
1115 v.imm7.b = rs2_imm7;
1116 }
1117 else {
1118 assert(!(rs2_imm7 & 0xffffffe0));
1119 v.asi.b = 0;
1120 v.rs2.b = rs2_imm7;
1121 }
1122 ii(v.v);
1123}
1124
1125static void
1126_f3a(jit_state_t *_jit, jit_int32_t op, jit_int32_t rd,
1127 jit_int32_t op3, jit_int32_t rs1, jit_int32_t asi, jit_int32_t rs2)
1128{
1129 jit_instr_t v;
1130 assert(!(op & 0xfffffffc));
1131 assert(!(rd & 0xffffffe0));
1132 assert(!(op3 & 0xffffffc0));
1133 assert(!(rs1 & 0xffffffe0));
1134 assert(!(asi & 0xffffff00));
1135 assert(!(rs2 & 0xffffffe0));
1136 v.op.b = op;
1137 v.rd.b = rd;
1138 v.op3.b = op3;
1139 v.rs1.b = rs1;
1140 v.i.b = 0;
1141 v.asi.b = asi;
1142 v.rs2.b = rs2;
1143 ii(v.v);
1144}
1145
1146static void
1147_f1(jit_state_t *_jit, jit_int32_t op, jit_int32_t disp30)
1148{
1149 jit_instr_t v;
1150 assert(!(op & 0xfffffffc));
1151 assert(s30_p(disp30));
1152 v.op.b = op;
1153 v.disp30.b = disp30;
1154 ii(v.v);
1155}
1156
1157static void
1158_nop(jit_state_t *_jit, jit_int32_t i0)
1159{
1160 for (; i0 > 0; i0 -= 4)
1161 NOP();
1162 assert(i0 == 0);
1163}
1164
1165static void
1166_movr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1167{
1168 if (r0 != r1)
1169 ORI(r1, 0, r0);
1170}
1171
1172static void
1173_movi(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1174{
1175 if (s13_p(i0))
1176 ORI(0, i0, r0);
1177 else {
1178# if __WORDSIZE == 64
1179 if (i0 & 0xffffffff00000000) {
1180 jit_int32_t reg = jit_get_reg(jit_class_gpr);
1181 movi(rn(reg), (i0 >> 32) & 0xffffffff);
1182 movi(r0, i0 & 0xffffffff);
1183 lshi(rn(reg), rn(reg), 32);
1184 OR(rn(reg), r0, r0);
1185 jit_unget_reg(reg);
1186 }
1187 else {
1188# endif
1189 SETHI(HI((int)i0), r0);
1190 if (LO(i0))
1191 ORI(r0, LO(i0), r0);
1192# if __WORDSIZE == 64
1193 }
1194# endif
1195 }
1196}
1197
1198static jit_word_t
1199_movi_p(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1200{
1201 jit_word_t w;
1202# if __WORDSIZE == 64
1203 jit_int32_t reg;
1204# endif
1205 w = _jit->pc.w;
1206# if __WORDSIZE == 64
1207 reg = jit_get_reg(jit_class_gpr);
1208 SETHI(HI((int)i0), r0);
1209 ORI(r0, LO(i0), r0);
1210 i0 = (int)(i0 >> 32);
1211 SETHI(HI(i0), rn(reg));
1212 ORI(rn(reg), LO(i0), rn(reg));
1213 SLLXI(rn(reg), 32, rn(reg));
1214 OR(rn(reg), r0, r0);
1215 jit_unget_reg(reg);
1216# else
1217 SETHI(HI(i0), r0);
1218 ORI(r0, LO(i0), r0);
1219# endif
1220 return (w);
1221}
1222
40a44dcb
PC		 1223static void
1224_movnr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1225{
1226 jit_word_t w;
1227 w = beqi(_jit->pc.w, r2, 0);
1228 ORI(r1, 0, r0);
1229 patch_at(w, _jit->pc.w);
1230}
1231
1232static void
1233_movzr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1234{
1235 jit_word_t w;
1236 w = bnei(_jit->pc.w, r2, 0);
1237 ORI(r1, 0, r0);
1238 patch_at(w, _jit->pc.w);
1239}
1240
ba3814c1
PC		 1241static void
1242_casx(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1243 jit_int32_t r2, jit_int32_t r3, jit_word_t i0)
1244{
1245 fallback_casx(r0, r1, r2, r3, i0);
1246}
1247
4a71579b
PC		 1248static void
1249_addi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1250{
1251 jit_int32_t reg;
1252 if (s13_p(i0))
1253 ADDI(r1, i0, r0);
1254 else {
1255 reg = jit_get_reg(jit_class_gpr);
1256 movi(rn(reg), i0);
1257 addr(r0, r1, rn(reg));
1258 jit_unget_reg(reg);
1259 }
1260}
1261
1262# if __WORDSIZE == 64
1263static void
1264_addcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1265{
1266 jit_int32_t reg;
1267 if (jit_carry == _NOREG)
1268 jit_carry = jit_get_reg(jit_class_gpr);
1269 if (r0 == r1) {
1270 reg = jit_get_reg(jit_class_gpr);
1271 addr(rn(reg), r1, r2);
1272 ltr_u(rn(jit_carry), rn(reg), r1);
1273 movr(r0, rn(reg));
1274 jit_unget_reg(reg);
1275 }
1276 else {
1277 addr(r0, r1, r2);
1278 ltr_u(rn(jit_carry), r0, r1);
1279 }
1280}
1281# endif
1282
1283static void
1284_addci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1285{
1286# if __WORDSIZE == 32
1287 jit_int32_t reg;
1288 if (s13_p(i0))
1289 ADDIcc(r1, i0, r0);
1290 else {
1291 reg = jit_get_reg(jit_class_gpr);
1292 movi(rn(reg), i0);
1293 addcr(r0, r1, rn(reg));
1294 jit_unget_reg(reg);
1295 }
1296# else
1297 jit_int32_t reg;
1298 if (jit_carry == _NOREG)
1299 jit_carry = jit_get_reg(jit_class_gpr);
1300 if (r0 == r1) {
1301 reg = jit_get_reg(jit_class_gpr);
1302 addi(rn(reg), r1, i0);
1303 ltr_u(rn(jit_carry), rn(reg), r1);
1304 movr(r0, rn(reg));
1305 jit_unget_reg(reg);
1306 }
1307 else {
1308 addi(r0, r1, i0);
1309 ltr_u(rn(jit_carry), r0, r1);
1310 }
1311# endif
1312}
1313
1314# if __WORDSIZE == 64
1315static void
1316_addxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1317{
1318 jit_int32_t reg;
1319 assert(jit_carry != _NOREG);
1320 reg = jit_get_reg(jit_class_gpr);
1321 movr(rn(reg), rn(jit_carry));
1322 addcr(r0, r1, r2);
1323 addcr(r0, r0, rn(reg));
1324 jit_unget_reg(reg);
1325}
1326# endif
1327
1328static void
1329_addxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1330{
1331# if __WORDSIZE == 32
1332 jit_int32_t reg;
1333 if (s13_p(i0))
1334 ADDXIcc(r1, i0, r0);
1335 else {
1336 reg = jit_get_reg(jit_class_gpr);
1337 movi(rn(reg), i0);
1338 addxr(r0, r1, rn(reg));
1339 jit_unget_reg(reg);
1340 }
1341# else
1342 jit_int32_t reg;
1343 assert(jit_carry != _NOREG);
1344 reg = jit_get_reg(jit_class_gpr);
1345 movr(rn(reg), rn(jit_carry));
1346 addci(r0, r1, i0);
1347 addcr(r0, r0, rn(reg));
1348 jit_unget_reg(reg);
1349# endif
1350}
1351
1352static void
1353_subi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1354{
1355 jit_int32_t reg;
1356 if (s13_p(i0))
1357 SUBI(r1, i0, r0);
1358 else {
1359 reg = jit_get_reg(jit_class_gpr);
1360 movi(rn(reg), i0);
1361 subr(r0, r1, rn(reg));
1362 jit_unget_reg(reg);
1363 }
1364}
1365
1366# if __WORDSIZE == 64
1367static void
1368_subcr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1369{
1370 jit_int32_t reg;
1371 if (jit_carry == _NOREG)
1372 jit_carry = jit_get_reg(jit_class_gpr);
1373 if (r0 == r1) {
1374 reg = jit_get_reg(jit_class_gpr);
1375 subr(rn(reg), r1, r2);
1376 ltr_u(rn(jit_carry), r1, rn(reg));
1377 movr(r0, rn(reg));
1378 jit_unget_reg(reg);
1379 }
1380 else {
1381 subr(r0, r1, r2);
1382 ltr_u(rn(jit_carry), r1, r0);
1383 }
1384}
1385# endif
1386
1387static void
1388_subci(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1389{
1390# if __WORDSIZE == 32
1391 jit_int32_t reg;
1392 if (s13_p(i0))
1393 SUBIcc(r1, i0, r0);
1394 else {
1395 reg = jit_get_reg(jit_class_gpr);
1396 movi(rn(reg), i0);
1397 subcr(r0, r1, rn(reg));
1398 jit_unget_reg(reg);
1399 }
1400# else
1401 jit_int32_t reg;
1402 if (jit_carry == _NOREG)
1403 jit_carry = jit_get_reg(jit_class_gpr);
1404 if (r0 == r1) {
1405 reg = jit_get_reg(jit_class_gpr);
1406 addi(rn(reg), r1, -i0);
1407 ltr_u(rn(jit_carry), r1, rn(reg));
1408 movr(r0, rn(reg));
1409 jit_unget_reg(reg);
1410 }
1411 else {
1412 addi(r0, r1, -i0);
1413 ltr_u(rn(jit_carry), r1, r0);
1414 }
1415# endif
1416}
1417
1418# if __WORDSIZE == 64
1419static void
1420_subxr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1421{
1422 jit_int32_t reg;
1423 assert(jit_carry != _NOREG);
1424 reg = jit_get_reg(jit_class_gpr);
1425 movr(rn(reg), rn(jit_carry));
1426 subcr(r0, r1, r2);
1427 subcr(r0, r0, rn(reg));
1428 jit_unget_reg(reg);
1429}
1430#endif
1431
1432static void
1433_subxi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1434{
1435# if __WORDSIZE == 32
1436 jit_int32_t reg;
1437 if (s13_p(i0))
1438 SUBXIcc(r1, i0, r0);
1439 else {
1440 reg = jit_get_reg(jit_class_gpr);
1441 movi(rn(reg), i0);
1442 subxr(r0, r1, rn(reg));
1443 jit_unget_reg(reg);
1444 }
1445# else
1446 jit_int32_t reg;
1447 assert(jit_carry != _NOREG);
1448 reg = jit_get_reg(jit_class_gpr);
1449 movr(rn(reg), rn(jit_carry));
1450 subci(r0, r1, i0);
1451 subcr(r0, r0, rn(reg));
1452 jit_unget_reg(reg);
1453# endif
1454}
1455
1456static void
1457_rsbi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1458{
1459 subi(r0, r1, i0);
1460 negr(r0, r0);
1461}
1462
1463static void
1464_muli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1465{
1466 jit_int32_t reg;
1467 if (s13_p(i0)) {
1468# if __WORDSIZE == 32
1469 UMULI(r1, i0, r0);
1470# else
1471 MULXI(r1, i0, r0);
1472# endif
1473 }
1474 else {
1475 reg = jit_get_reg(jit_class_gpr);
1476 movi(rn(reg), i0);
1477 mulr(r0, r1, rn(reg));
1478 jit_unget_reg(reg);
1479 }
1480}
1481
1482# if __WORDSIZE == 32
1483static void
1484_iqmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1485 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1486{
1487 if (sign)
1488 SMUL(r2, r3, r0);
1489 else
1490 UMUL(r2, r3, r0);
1491 RDY(r1);
1492}
1493
1494static void
1495_iqmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1496 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1497{
1498 jit_int32_t reg;
1499 if (s13_p(i0)) {
1500 if (sign)
1501 SMULI(r2, i0, r0);
1502 else
1503 UMULI(r2, i0, r0);
1504 RDY(r1);
1505 }
1506 else {
1507 reg = jit_get_reg(jit_class_gpr);
1508 movi(rn(reg), i0);
1509 iqmulr(r0, r1, r2, rn(reg), sign);
1510 jit_unget_reg(reg);
1511 }
1512}
1513
1514# else
1515static __int128_t __llmul(jit_word_t a, jit_word_t b)
1516{
1517 return (__int128_t)a * (__int128_t)b;
1518}
1519
1520# define QMUL_PROLOG() \
1521 do { \
1522 (void)jit_get_reg(_O0|jit_class_gpr|jit_class_named); \
1523 (void)jit_get_reg(_O1|jit_class_gpr|jit_class_named); \
1524 if (r0 != _G2_REGNO && r1 != _G2_REGNO) \
1525 stxi(BIAS(-8), _FP_REGNO, _G2_REGNO); \
1526 if (r0 != _G3_REGNO && r1 != _G3_REGNO) \
1527 stxi(BIAS(-16), _FP_REGNO, _G3_REGNO); \
1528 if (r0 != _G4_REGNO && r1 != _G4_REGNO) \
1529 stxi(BIAS(-24), _FP_REGNO, _G4_REGNO); \
1530 } while (0)
1531
1532# define QMUL_EPILOG() \
1533 do { \
1534 if (r0 != _G2_REGNO && r1 != _G2_REGNO) \
1535 ldxi(_G2_REGNO, _FP_REGNO, BIAS(-8)); \
1536 if (r0 != _G3_REGNO && r1 != _G3_REGNO) \
1537 ldxi(_G3_REGNO, _FP_REGNO, BIAS(-16)); \
1538 if (r0 != _G4_REGNO && r1 != _G4_REGNO) \
1539 ldxi(_G4_REGNO, _FP_REGNO, BIAS(-24)); \
1540 (void)jit_unget_reg(_O0); \
1541 (void)jit_unget_reg(_O1); \
1542 } while (0)
1543
1544static void
1545_qmulr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1546 jit_int32_t r2, jit_int32_t r3)
1547{
1548 QMUL_PROLOG();
1549 movr(_O0_REGNO, r3);
1550 movr(_O1_REGNO, r2);
1551 calli((jit_word_t)__llmul);
1552 movr(r0, _O1_REGNO);
1553 movr(r1, _O0_REGNO);
1554 QMUL_EPILOG();
1555}
1556
1557static void
1558_qmuli(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1559 jit_int32_t r2, jit_word_t i0)
1560{
1561 QMUL_PROLOG();
1562 movi(_O0_REGNO, i0);
1563 movr(_O1_REGNO, r2);
1564 calli((jit_word_t)__llmul);
1565 movr(r0, _O1_REGNO);
1566 movr(r1, _O0_REGNO);
1567 QMUL_EPILOG();
1568}
1569
1570static __uint128_t __ullmul(jit_uword_t a, jit_uword_t b)
1571{
1572 return (__uint128_t)a * (__uint128_t)b;
1573}
1574
1575static void
1576_qmulr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1577 jit_int32_t r2, jit_int32_t r3)
1578{
1579 QMUL_PROLOG();
1580 movr(_O0_REGNO, r3);
1581 movr(_O1_REGNO, r2);
1582 calli((jit_word_t)__ullmul);
1583 movr(r0, _O1_REGNO);
1584 movr(r1, _O0_REGNO);
1585 QMUL_EPILOG();
1586}
1587
1588static void
1589_qmuli_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1590 jit_int32_t r2, jit_word_t i0)
1591{
1592 QMUL_PROLOG();
1593 movi(_O0_REGNO, i0);
1594 movr(_O1_REGNO, r2);
1595 calli((jit_word_t)__ullmul);
1596 movr(r0, _O1_REGNO);
1597 movr(r1, _O0_REGNO);
1598 QMUL_EPILOG();
1599}
1600# endif
1601
1602static void
1603_divr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1604{
1605# if __WORDSIZE == 32
1606 jit_int32_t reg;
1607 reg = jit_get_reg(jit_class_gpr);
1608 rshi(rn(reg), r1, 31);
1609 WRY(rn(reg), 0);
1610 SDIV(r1, r2, r0);
1611 jit_unget_reg(reg);
1612# else
1613 SDIVX(r1, r2, r0);
1614# endif
1615}
1616
1617static void
1618_divi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1619{
1620 jit_int32_t reg;
1621# if __WORDSIZE == 32
1622 reg = jit_get_reg(jit_class_gpr);
1623# endif
1624 if (s13_p(i0)) {
1625# if __WORDSIZE == 32
1626 rshi(rn(reg), r1, 31);
1627 WRY(rn(reg), 0);
1628 SDIVI(r1, i0, r0);
1629# else
1630 SDIVXI(r1, i0, r0);
1631# endif
1632 }
1633 else {
1634# if __WORDSIZE == 64
1635 reg = jit_get_reg(jit_class_gpr);
1636# endif
1637 movi(rn(reg), i0);
1638 divr(r0, r1, rn(reg));
1639# if __WORDSIZE == 64
1640 jit_unget_reg(reg);
1641# endif
1642 }
1643# if __WORDSIZE == 32
1644 jit_unget_reg(reg);
1645# endif
1646}
1647
1648static void
1649_divr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1650{
1651# if __WORDSIZE == 32
1652 WRYI(0, 0);
1653 UDIV(r1, r2, r0);
1654# else
1655 UDIVX(r1, r2, r0);
1656# endif
1657}
1658
1659static void
1660_divi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1661{
1662 jit_int32_t reg;
1663 if (s13_p(i0)) {
1664# if __WORDSIZE == 32
1665 WRYI(0, 0);
1666 UDIVI(r1, i0, r0);
1667# else
1668 UDIVXI(r1, i0, r0);
1669# endif
1670 }
1671 else {
1672 reg = jit_get_reg(jit_class_gpr);
1673 movi(rn(reg), i0);
1674 divr_u(r0, r1, rn(reg));
1675 jit_unget_reg(reg);
1676 }
1677}
1678
1679static void
1680_iqdivr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1681 jit_int32_t r2, jit_int32_t r3, jit_bool_t sign)
1682{
1683 jit_int32_t sv0, rg0;
1684 jit_int32_t sv1, rg1;
1685
1686 if (r0 == r2 || r0 == r3) {
1687 sv0 = jit_get_reg(jit_class_gpr);
1688 rg0 = rn(sv0);
1689 }
1690 else
1691 rg0 = r0;
1692 if (r1 == r2 || r1 == r3) {
1693 sv1 = jit_get_reg(jit_class_gpr);
1694 rg1 = rn(sv1);
1695 }
1696 else
1697 rg1 = r1;
1698
1699 if (sign)
1700 divr(rg0, r2, r3);
1701 else
1702 divr_u(rg0, r2, r3);
1703 mulr(rg1, r3, rg0);
1704 subr(rg1, r2, rg1);
1705 if (rg0 != r0) {
1706 movr(r0, rg0);
1707 jit_unget_reg(sv0);
1708 }
1709 if (rg1 != r1) {
1710 movr(r1, rg1);
1711 jit_unget_reg(sv1);
1712 }
1713}
1714
1715static void
1716_iqdivi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1,
1717 jit_int32_t r2, jit_word_t i0, jit_bool_t sign)
1718{
1719 jit_int32_t reg;
1720 reg = jit_get_reg(jit_class_gpr);
1721 movi(rn(reg), i0);
1722 iqdivr(r0, r1, r2, rn(reg), sign);
1723 jit_unget_reg(reg);
1724}
1725
1726static void
1727_remr(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1728{
1729 jit_int32_t reg;
1730 if (r0 == r1 || r0 == r2) {
1731 reg = jit_get_reg(jit_class_gpr);
1732 divr(rn(reg), r1, r2);
1733 mulr(rn(reg), r2, rn(reg));
1734 subr(r0, r1, rn(reg));
1735 jit_unget_reg(reg);
1736 }
1737 else {
1738 divr(r0, r1, r2);
1739 mulr(r0, r2, r0);
1740 subr(r0, r1, r0);
1741 }
1742}
1743
1744static void
1745_remi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1746{
1747 jit_int32_t reg;
1748 reg = jit_get_reg(jit_class_gpr);
1749 movi(rn(reg), i0);
1750 remr(r0, r1, rn(reg));
1751 jit_unget_reg(reg);
1752}
1753
1754static void
1755_remr_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1756{
1757 jit_int32_t reg;
1758 if (r0 == r1 || r0 == r2) {
1759 reg = jit_get_reg(jit_class_gpr);
1760 divr_u(rn(reg), r1, r2);
1761 mulr(rn(reg), r2, rn(reg));
1762 subr(r0, r1, rn(reg));
1763 jit_unget_reg(reg);
1764 }
1765 else {
1766 divr_u(r0, r1, r2);
1767 mulr(r0, r2, r0);
1768 subr(r0, r1, r0);
1769 }
1770}
1771
1772static void
1773_remi_u(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1774{
1775 jit_int32_t reg;
1776 reg = jit_get_reg(jit_class_gpr);
1777 movi(rn(reg), i0);
1778 remr_u(r0, r1, rn(reg));
1779 jit_unget_reg(reg);
1780}
1781
1782static void
1783_andi(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1784{
1785 jit_int32_t reg;
1786 if (s13_p(i0))
1787 ANDI(r1, i0, r0);
1788 else {
1789 reg = jit_get_reg(jit_class_gpr);
1790 movi(rn(reg), i0);
1791 andr(r0, r1, rn(reg));
1792 jit_unget_reg(reg);
1793 }
1794}
1795
1796static void
1797_ori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1798{
1799 jit_int32_t reg;
1800 if (s13_p(i0))
1801 ORI(r1, i0, r0);
1802 else {
1803 reg = jit_get_reg(jit_class_gpr);
1804 movi(rn(reg), i0);
1805 orr(r0, r1, rn(reg));
1806 jit_unget_reg(reg);
1807 }
1808}
1809
1810static void
1811_xori(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1812{
1813 jit_int32_t reg;
1814 if (s13_p(i0))
1815 XORI(r1, i0, r0);
1816 else {
1817 reg = jit_get_reg(jit_class_gpr);
1818 movi(rn(reg), i0);
1819 xorr(r0, r1, rn(reg));
1820 jit_unget_reg(reg);
1821 }
1822}
1823
1824static void
1825_extr_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1826{
1827 lshi(r0, r1, __WORDSIZE - 8);
1828 rshi(r0, r0, __WORDSIZE - 8);
1829}
1830
1831static void
1832_extr_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1833{
1834 lshi(r0, r1, __WORDSIZE - 16);
1835 rshi(r0, r0, __WORDSIZE - 16);
1836}
1837
1838static void
1839_extr_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1840{
1841 lshi(r0, r1, __WORDSIZE - 16);
1842 rshi_u(r0, r0, __WORDSIZE - 16);
1843}
1844
1845#if __WORDSIZE == 64
1846static void
1847_extr_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1848{
1849 lshi(r0, r1, __WORDSIZE - 32);
1850 rshi(r0, r0, __WORDSIZE - 32);
1851}
1852
1853static void
1854_extr_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1855{
1856 lshi(r0, r1, __WORDSIZE - 32);
1857 rshi_u(r0, r0, __WORDSIZE - 32);
1858}
1859#endif
1860
1861static void
1862_cr(jit_state_t *_jit, jit_int32_t cc,
1863 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1864{
1865 CMP(r1, r2);
1866# if __WORDSIZE == 32
1867 Ba(cc, 3);
1868# else
1869 BPa(cc, 3);
1870# endif
1871 movi(r0, 1);
1872 movi(r0, 0);
1873}
1874
1875static void
1876_cw(jit_state_t *_jit, jit_int32_t cc,
1877 jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1878{
1879 jit_int32_t reg;
1880 if (s13_p(i0)) {
1881 CMPI(r1, i0);
1882# if __WORDSIZE == 32
1883 Ba(cc, 3);
1884# else
1885 BPa(cc, 3);
1886# endif
1887 movi(r0, 1);
1888 movi(r0, 0);
1889 }
1890 else {
1891 reg = jit_get_reg(jit_class_gpr);
1892 movi(rn(reg), i0);
1893 cr(cc, r0, r1, rn(reg));
1894 jit_unget_reg(reg);
1895 }
1896}
1897
1898static void
1899_ldi_c(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1900{
1901 jit_int32_t reg;
1902 if (s13_p(i0))
1903 LDSBI(0, i0, r0);
1904 else {
1905 reg = jit_get_reg(jit_class_gpr);
1906 movi(rn(reg), i0);
1907 ldr_c(r0, rn(reg));
1908 jit_unget_reg(reg);
1909 }
1910}
1911
1912static void
1913_ldi_uc(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1914{
1915 jit_int32_t reg;
1916 if (s13_p(i0))
1917 LDUBI(0, i0, r0);
1918 else {
1919 reg = jit_get_reg(jit_class_gpr);
1920 movi(rn(reg), i0);
1921 ldr_uc(r0, rn(reg));
1922 jit_unget_reg(reg);
1923 }
1924}
1925
1926static void
1927_ldi_s(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1928{
1929 jit_int32_t reg;
1930 if (s13_p(i0))
1931 LDSHI(0, i0, r0);
1932 else {
1933 reg = jit_get_reg(jit_class_gpr);
1934 movi(rn(reg), i0);
1935 ldr_s(r0, rn(reg));
1936 jit_unget_reg(reg);
1937 }
1938}
1939
1940static void
1941_ldi_us(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1942{
1943 jit_int32_t reg;
1944 if (s13_p(i0))
1945 LDUHI(0, i0, r0);
1946 else {
1947 reg = jit_get_reg(jit_class_gpr);
1948 movi(rn(reg), i0);
1949 ldr_us(r0, rn(reg));
1950 jit_unget_reg(reg);
1951 }
1952}
1953
1954static void
1955_ldi_i(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1956{
1957 jit_int32_t reg;
1958 if (s13_p(i0)) {
1959# if __WORDSIZE == 32
1960 LDI(0, i0, r0);
1961# else
1962 LDSWI(0, i0, r0);
1963# endif
1964 }
1965 else {
1966 reg = jit_get_reg(jit_class_gpr);
1967 movi(rn(reg), i0);
1968 ldr_i(r0, rn(reg));
1969 jit_unget_reg(reg);
1970 }
1971}
1972
1973# if __WORDSIZE == 64
1974static void
1975_ldi_ui(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1976{
1977 jit_int32_t reg;
1978 if (s13_p(i0))
1979 LDUWI(0, i0, r0);
1980 else {
1981 reg = jit_get_reg(jit_class_gpr);
1982 movi(rn(reg), i0);
1983 ldr_ui(r0, rn(reg));
1984 jit_unget_reg(reg);
1985 }
1986}
1987
1988static void
1989_ldi_l(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1990{
1991 jit_int32_t reg;
1992 if (s13_p(i0))
1993 LDXI(0, i0, r0);
1994 else {
1995 reg = jit_get_reg(jit_class_gpr);
1996 movi(rn(reg), i0);
1997 ldr_l(r0, rn(reg));
1998 jit_unget_reg(reg);
1999 }
2000}
2001# endif
2002
2003static void
2004_ldxi_c(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2005{
2006 jit_int32_t reg;
2007 if (s13_p(i0))
2008 LDSBI(r1, i0, r0);
2009 else {
2010 reg = jit_get_reg(jit_class_gpr);
2011 movi(rn(reg), i0);
2012 ldxr_c(r0, r1, rn(reg));
2013 jit_unget_reg(reg);
2014 }
2015}
2016
2017static void
2018_ldxi_uc(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2019{
2020 jit_int32_t reg;
2021 if (s13_p(i0))
2022 LDUBI(r1, i0, r0);
2023 else {
2024 reg = jit_get_reg(jit_class_gpr);
2025 movi(rn(reg), i0);
2026 ldxr_uc(r0, r1, rn(reg));
2027 jit_unget_reg(reg);
2028 }
2029}
2030
2031static void
2032_ldxi_s(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2033{
2034 jit_int32_t reg;
2035 if (s13_p(i0))
2036 LDSHI(r1, i0, r0);
2037 else {
2038 reg = jit_get_reg(jit_class_gpr);
2039 movi(rn(reg), i0);
2040 ldxr_s(r0, r1, rn(reg));
2041 jit_unget_reg(reg);
2042 }
2043}
2044
2045static void
2046_ldxi_us(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2047{
2048 jit_int32_t reg;
2049 if (s13_p(i0))
2050 LDUHI(r1, i0, r0);
2051 else {
2052 reg = jit_get_reg(jit_class_gpr);
2053 movi(rn(reg), i0);
2054 ldxr_us(r0, r1, rn(reg));
2055 jit_unget_reg(reg);
2056 }
2057}
2058
2059static void
2060_ldxi_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2061{
2062 jit_int32_t reg;
2063 if (s13_p(i0)) {
2064# if __WORDSIZE == 32
2065 LDI(r1, i0, r0);
2066# else
2067 LDSWI(r1, i0, r0);
2068# endif
2069 }
2070 else {
2071 reg = jit_get_reg(jit_class_gpr);
2072 movi(rn(reg), i0);
2073 ldxr_i(r0, r1, rn(reg));
2074 jit_unget_reg(reg);
2075 }
2076}
2077
2078# if __WORDSIZE == 64
2079static void
2080_ldxi_ui(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2081{
2082 jit_int32_t reg;
2083 if (s13_p(i0))
2084 LDUWI(r1, i0, r0);
2085 else {
2086 reg = jit_get_reg(jit_class_gpr);
2087 movi(rn(reg), i0);
2088 ldxr_ui(r0, r1, rn(reg));
2089 jit_unget_reg(reg);
2090 }
2091}
2092
2093static void
2094_ldxi_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
2095{
2096 jit_int32_t reg;
2097 if (s13_p(i0))
2098 LDXI(r1, i0, r0);
2099 else {
2100 reg = jit_get_reg(jit_class_gpr);
2101 movi(rn(reg), i0);
2102 ldxr_l(r0, r1, rn(reg));
2103 jit_unget_reg(reg);
2104 }
2105}
2106# endif
2107
2108static void
2109_sti_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2110{
2111 jit_int32_t reg;
2112 if (s13_p(i0))
2113 STBI(r0, 0, i0);
2114 else {
2115 reg = jit_get_reg(jit_class_gpr);
2116 movi(rn(reg), i0);
2117 str_c(rn(reg), r0);
2118 jit_unget_reg(reg);
2119 }
2120}
2121
2122static void
2123_sti_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2124{
2125 jit_int32_t reg;
2126 if (s13_p(i0))
2127 STHI(r0, 0, i0);
2128 else {
2129 reg = jit_get_reg(jit_class_gpr);
2130 movi(rn(reg), i0);
2131 str_s(rn(reg), r0);
2132 jit_unget_reg(reg);
2133 }
2134}
2135
2136static void
2137_sti_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2138{
2139 jit_int32_t reg;
2140 if (s13_p(i0)) {
2141# if __WORDSIZE == 32
2142 STI(r0, 0, i0);
2143# else
2144 STWI(r0, 0, i0);
2145# endif
2146 }
2147 else {
2148 reg = jit_get_reg(jit_class_gpr);
2149 movi(rn(reg), i0);
2150 str_i(rn(reg), r0);
2151 jit_unget_reg(reg);
2152 }
2153}
2154
2155# if __WORDSIZE == 64
2156static void
2157_sti_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
2158{
2159 jit_int32_t reg;
2160 if (s13_p(i0))
2161 STXI(r0, 0, i0);
2162 else {
2163 reg = jit_get_reg(jit_class_gpr);
2164 movi(rn(reg), i0);
2165 str_l(rn(reg), r0);
2166 jit_unget_reg(reg);
2167 }
2168}
2169# endif
2170
2171static void
2172_stxi_c(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2173{
2174 jit_int32_t reg;
2175 if (s13_p(i0))
2176 STBI(r1, r0, i0);
2177 else {
2178 reg = jit_get_reg(jit_class_gpr);
2179 movi(rn(reg), i0);
2180 stxr_c(r0, rn(reg), r1);
2181 jit_unget_reg(reg);
2182 }
2183}
2184
2185static void
2186_stxi_s(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2187{
2188 jit_int32_t reg;
2189 if (s13_p(i0))
2190 STHI(r1, r0, i0);
2191 else {
2192 reg = jit_get_reg(jit_class_gpr);
2193 movi(rn(reg), i0);
2194 stxr_s(r0, rn(reg), r1);
2195 jit_unget_reg(reg);
2196 }
2197}
2198
2199static void
2200_stxi_i(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2201{
2202 jit_int32_t reg;
2203 if (s13_p(i0)) {
2204# if __WORDSIZE == 32
2205 STI(r1, r0, i0);
2206# else
2207 STWI(r1, r0, i0);
2208# endif
2209 }
2210 else {
2211 reg = jit_get_reg(jit_class_gpr);
2212 movi(rn(reg), i0);
2213 stxr_i(r0, rn(reg), r1);
2214 jit_unget_reg(reg);
2215 }
2216}
2217
2218# if __WORDSIZE == 64
2219static void
2220_stxi_l(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2221{
2222 jit_int32_t reg;
2223 if (s13_p(i0))
2224 STXI(r1, r0, i0);
2225 else {
2226 reg = jit_get_reg(jit_class_gpr);
2227 movi(rn(reg), i0);
2228 stxr_l(r0, rn(reg), r1);
2229 jit_unget_reg(reg);
2230 }
2231}
2232# endif
2233
2234static jit_word_t
2235_br(jit_state_t *_jit, jit_int32_t cc,
2236 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2237{
2238 jit_word_t w;
2239 CMP(r0, r1);
2240 w = _jit->pc.w;
2241# if __WORDSIZE == 32
2242 B(cc, (i0 - w) >> 2);
2243# else
2244 BP(cc, (i0 - w) >> 2);
2245# endif
2246 NOP();
2247 return (w);
2248}
2249
2250static jit_word_t
2251_bw(jit_state_t *_jit, jit_int32_t cc,
2252 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2253{
2254 jit_word_t w;
2255 jit_int32_t reg;
2256 if (s13_p(i1)) {
2257 CMPI(r0, i1);
2258 w = _jit->pc.w;
2259# if __WORDSIZE == 32
2260 B(cc, (i0 - w) >> 2);
2261# else
2262 B(cc, (i0 - w) >> 2);
2263# endif
2264 NOP();
2265 }
2266 else {
2267 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2268 movi(rn(reg), i1);
2269 w = br(cc, i0, r0, rn(reg));
2270 jit_unget_reg(reg);
2271 }
2272 return (w);
2273}
2274
2275static jit_word_t
2276_b_asr(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2277 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2278{
2279 jit_word_t w;
2280 if (add)
2281 ADDcc(r0, r1, r0);
2282 else
2283 SUBcc(r0, r1, r0);
2284 w = _jit->pc.w;
2285# if __WORDSIZE == 32
2286 B(sgn ?
2287 (jif ? SPARC_BVS : SPARC_BVC) :
2288 (jif ? SPARC_BCS : SPARC_BCC),
2289 (i0 - w) >> 2);
2290# else
2291 BP(sgn ?
2292 (jif ? SPARC_BPVS : SPARC_BPVC) :
2293 (jif ? SPARC_BPCS : SPARC_BPCC),
2294 (i0 - w) >> 2);
2295# endif
2296 NOP();
2297 return (w);
2298}
2299
2300static jit_word_t
2301_b_asw(jit_state_t *_jit, jit_bool_t jif, jit_bool_t add, jit_bool_t sgn,
2302 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2303{
2304 jit_word_t w;
2305 jit_int32_t reg;
2306 if (s13_p(i1)) {
2307 if (add)
2308 ADDIcc(r0, i1, r0);
2309 else
2310 SUBIcc(r0, i1, r0);
2311 w = _jit->pc.w;
2312# if __WORDSIZE == 32
2313 B(sgn ?
2314 (jif ? SPARC_BVS : SPARC_BVC) :
2315 (jif ? SPARC_BCS : SPARC_BCC),
2316 (i0 - w) >> 2);
2317# else
2318 BP(sgn ?
2319 (jif ? SPARC_BPVS : SPARC_BPVC) :
2320 (jif ? SPARC_BPCS : SPARC_BPCC),
2321 (i0 - w) >> 2);
2322# endif
2323 NOP();
2324 }
2325 else {
2326 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2327 movi(rn(reg), i1);
2328 w = b_asr(jif, add, sgn, i0, r0, rn(reg));
2329 jit_unget_reg(reg);
2330 }
2331 return (w);
2332}
2333
2334static jit_word_t
2335_bm_r(jit_state_t *_jit, jit_bool_t set,
2336 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
2337{
2338 jit_word_t w;
2339 BTST(r0, r1);
2340 w = _jit->pc.w;
2341# if __WORDSIZE == 32
2342 B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2343# else
2344 BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2345# endif
2346 NOP();
2347 return (w);
2348}
2349
2350static jit_word_t
2351_bm_w(jit_state_t *_jit, jit_bool_t set,
2352 jit_word_t i0, jit_int32_t r0, jit_word_t i1)
2353{
2354 jit_word_t w;
2355 jit_int32_t reg;
2356 if (s13_p(i1)) {
2357 BTSTI(r0, i1);
2358 w = _jit->pc.w;
2359# if __WORDSIZE == 32
2360 B(set ? SPARC_BNZ : SPARC_BZ, (i0 - w) >> 2);
2361# else
2362 BP(set ? SPARC_BPNE : SPARC_BPE, (i0 - w) >> 2);
2363# endif
2364 NOP();
2365 }
2366 else {
2367 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2368 movi(rn(reg), i1);
2369 w = bm_r(set, i0, r0, rn(reg));
2370 jit_unget_reg(reg);
2371 }
2372 return (w);
2373}
2374
2375static void
2376_jmpr(jit_state_t *_jit, jit_int32_t r0)
2377{
2378 JMPL(0, r0, 0);
2379 NOP();
2380}
2381
2382static void
2383_jmpi(jit_state_t *_jit, jit_word_t i0)
2384{
2385 jit_word_t w;
2386 jit_int32_t reg;
2387 w = (i0 - _jit->pc.w) >> 2;
2388 if (s22_p(w)) {
2389 BA(w);
2390 NOP();
2391 }
2392 else {
2393 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2394 movi(rn(reg), i0);
2395 jmpr(rn(reg));
2396 jit_unget_reg(reg);
2397 }
2398}
2399
2400static jit_word_t
2401_jmpi_p(jit_state_t *_jit, jit_word_t i0)
2402{
2403 jit_word_t w;
2404 jit_int32_t reg;
2405 reg = jit_get_reg(jit_class_gpr|jit_class_nospill);
2406 w = movi_p(rn(reg), i0);
2407 jmpr(rn(reg));
2408 jit_unget_reg(reg);
2409 return (w);
2410}
2411
2412static void
2413_callr(jit_state_t *_jit, jit_int32_t r0)
2414{
2415 CALL(r0);
2416 NOP();
2417}
2418
2419static void
2420_calli(jit_state_t *_jit, jit_word_t i0)
2421{
2422 jit_word_t w;
2423 w = (i0 - _jit->pc.w) >> 2;
2424 CALLI(w);
2425 NOP();
2426}
2427
2428static jit_word_t
2429_calli_p(jit_state_t *_jit, jit_word_t i0)
2430{
2431 jit_word_t w;
2432 jit_int32_t reg;
2433 reg = jit_get_reg(jit_class_gpr);
2434 w = movi_p(rn(reg), i0);
2435 callr(rn(reg));
2436 jit_unget_reg(reg);
2437 return (w);
2438}
2439
2440#define OFF(n) BIAS(((n) * sizeof(jit_word_t)))
2441static void
2442_prolog(jit_state_t *_jit, jit_node_t *node)
2443{
2444 jit_int32_t reg;
2445 if (_jitc->function->define_frame || _jitc->function->assume_frame) {
2446 jit_int32_t frame = -_jitc->function->frame;
2447 assert(_jitc->function->self.aoff >= frame);
2448 if (_jitc->function->assume_frame)
2449 return;
2450 _jitc->function->self.aoff = frame;
2451 }
2452 if (_jitc->function->allocar)
2453 _jitc->function->self.aoff &= -16;
2454 /* align at 16 bytes boundary */
2455 _jitc->function->stack = ((stack_framesize +
2456 _jitc->function->self.alen -
2457 _jitc->function->self.aoff) + 15) & -16;
2458 SAVEI(_SP_REGNO, -_jitc->function->stack, _SP_REGNO);
2459
2460 /* (most) other backends do not save incoming arguments, so,
2461 * only save locals here */
2462 if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2463 stxi(OFF(0), _SP_REGNO, _L0_REGNO);
2464 if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2465 stxi(OFF(1), _SP_REGNO, _L1_REGNO);
2466 if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2467 stxi(OFF(2), _SP_REGNO, _L2_REGNO);
2468 if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2469 stxi(OFF(3), _SP_REGNO, _L3_REGNO);
2470 if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2471 stxi(OFF(4), _SP_REGNO, _L4_REGNO);
2472 if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2473 stxi(OFF(5), _SP_REGNO, _L5_REGNO);
2474 if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2475 stxi(OFF(6), _SP_REGNO, _L6_REGNO);
2476 if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2477 stxi(OFF(7), _SP_REGNO, _L7_REGNO);
2478
2479 if (_jitc->function->allocar) {
2480 reg = jit_get_reg(jit_class_gpr);
2481 movi(rn(reg), BIAS(_jitc->function->self.aoff));
2482 /* Already "biased" by allocai */
2483 stxi_i(_jitc->function->aoffoff, _FP_REGNO, rn(reg));
2484 jit_unget_reg(reg);
2485 }
2486
2487 if (_jitc->function->self.call & jit_call_varargs) {
2488 for (reg = _jitc->function->vagp; jit_arg_reg_p(reg); ++reg)
2489 stxi(BIAS((16 + (__WORDSIZE == 32)) * sizeof(jit_word_t) +
2490 reg * sizeof(jit_word_t)), _FP_REGNO, rn(_I0 + reg));
2491 }
2492}
2493
2494static void
2495_epilog(jit_state_t *_jit, jit_node_t *node)
2496{
2497 if (_jitc->function->assume_frame)
2498 return;
2499 /* (most) other backends do not save incoming arguments, so,
2500 * only save locals here */
2501 if (jit_regset_tstbit(&_jitc->function->regset, _L0))
2502 ldxi(_L0_REGNO, _FP_REGNO, _jitc->function->stack + OFF(0));
2503 if (jit_regset_tstbit(&_jitc->function->regset, _L1))
2504 ldxi(_L1_REGNO, _FP_REGNO, _jitc->function->stack + OFF(1));
2505 if (jit_regset_tstbit(&_jitc->function->regset, _L2))
2506 ldxi(_L2_REGNO, _FP_REGNO, _jitc->function->stack + OFF(2));
2507 if (jit_regset_tstbit(&_jitc->function->regset, _L3))
2508 ldxi(_L3_REGNO, _FP_REGNO, _jitc->function->stack + OFF(3));
2509 if (jit_regset_tstbit(&_jitc->function->regset, _L4))
2510 ldxi(_L4_REGNO, _FP_REGNO, _jitc->function->stack + OFF(4));
2511 if (jit_regset_tstbit(&_jitc->function->regset, _L5))
2512 ldxi(_L5_REGNO, _FP_REGNO, _jitc->function->stack + OFF(5));
2513 if (jit_regset_tstbit(&_jitc->function->regset, _L6))
2514 ldxi(_L6_REGNO, _FP_REGNO, _jitc->function->stack + OFF(6));
2515 if (jit_regset_tstbit(&_jitc->function->regset, _L7))
2516 ldxi(_L7_REGNO, _FP_REGNO, _jitc->function->stack + OFF(7));
2517 RESTOREI(0, 0, 0);
2518 RETL();
2519 NOP();
2520}
2521
2522static void
2523_vastart(jit_state_t *_jit, jit_int32_t r0)
2524{
2525 /* Initialize stack pointer to the first stack argument. */
2526 if (jit_arg_reg_p(_jitc->function->vagp))
2527 addi(r0, _FP_REGNO, BIAS((16 + (__WORDSIZE == 32) +
2528 _jitc->function->vagp) *
2529 sizeof(jit_word_t)));
2530 else
2531 addi(r0, _FP_REGNO, BIAS(_jitc->function->self.size));
2532}
2533
2534static void
2535_vaarg(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
2536{
2537 assert(_jitc->function->self.call & jit_call_varargs);
2538
2539 /* Load argument. */
2540 ldr(r0, r1);
2541
2542 /* Update vararg stack pointer. */
2543 addi(r1, r1, sizeof(jit_word_t));
2544}
2545
2546static void
2547_patch_at(jit_state_t *_jit, jit_word_t instr, jit_word_t label)
2548{
2549 jit_instr_t i;
2550 union {
2551 jit_int32_t *i;
2552 jit_word_t w;
2553 } u;
2554
2555 u.w = instr;
2556 i.v = u.i[0];
2557
2558 if (i.op.b == 0) { /* conditional branch */
2559 if (i.op2.b == 2 || i.op2.b == 6) { /* int or float condition */
2560 i.disp22.b = (label - instr) >> 2;
2561 u.i[0] = i.v;
2562 }
2563# if __WORDSIZE == 64
2564 else if (i.op2.b == 1) {
2565 i.disp19.b = (label - instr) >> 2;
2566 u.i[0] = i.v;
2567 }
2568# endif
2569 else if (i.op2.b == 4) { /* movi_p */
2570 /* SETHI */
2571 i.imm22.b = HI((int)label);
2572 u.i[0] = i.v;
2573 i.v = u.i[1];
2574 if (i.op.b == 2 && i.op3.b == 2) {
2575 /* ORI */
2576 i.simm13.b = LO(label);
2577 u.i[1] = i.v;
2578# if __WORDSIZE == 64
2579 i.v = u.i[2];
2580 assert(i.op2.b == 4);
2581 label = (label >> 32) & 0xffffffff;
2582 i.imm22.b = HI((int)label);
2583 u.i[2] = i.v;
2584 i.v = u.i[3];
2585 assert(i.op.b == 2 && i.op3.b == 2);
2586 /* ORI */
2587 i.simm13.b = LO(label);
2588 u.i[3] = i.v;
2589# endif
2590 }
2591 else
2592 abort();
2593 }
2594 else
2595 abort();
2596 }
2597 else
2598 abort();
2599}
2600#endif
ARM optimized PCSX fork