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