notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sync to latest upstream
[pcsx_rearmed.git] / deps / lightning / lib / jit_sparc-fpu.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# if __WORDSIZE == 32
22# define FPR(r) (r)
23# define CLASS_SNG jit_class_fpr
24# define CLASS_DBL jit_class_fpr
25# else
26# define single_precision_p(r) ((r) >= 0 && (r) <= 31)
27# define FPR(r) ((r) > 31 ? (r) - 31 : (r))
28# define CLASS_SNG (jit_class_fpr | jit_class_sng)
29# define CLASS_DBL (jit_class_fpr | jit_class_dbl)
30# endif
31# define LDF(rs1, rs2, rd) f3r(3, FPR(rd), 32, FPR(rs1), FPR(rs2))
32# define LDFI(rs1, imm, rd) f3i(3, FPR(rd), 32, FPR(rs1), imm)
33# define LDDF(rs1, rs2, rd) f3r(3, FPR(rd), 35, FPR(rs1), FPR(rs2))
34# define LDDFI(rs1, imm, rd) f3i(3, FPR(rd), 35, FPR(rs1), imm)
35# define LDFSR(rs1, rs2, rd) f3r(3, FPR(rd), 33, FPR(rs1), FPR(rs2))
36# define LDFSRI(rs1, imm, rd) f3i(3, FPR(rd), 33, FPR(rs1), imm)
37# define STF(rd, rs1, rs2) f3r(3, FPR(rd), 36, FPR(rs1), FPR(rs2))
38# define STFI(rd, rs1, imm) f3i(3, FPR(rd), 36, FPR(rs1), imm)
39# define STDF(rd, rs1, rs2) f3r(3, FPR(rd), 39, FPR(rs1), FPR(rs2))
40# define STDFI(rd, rs1, imm) f3i(3, FPR(rd), 39, FPR(rs1), imm)
41# define STFSR(rd, rs1, rs2) f3r(3, FPR(rd), 37, FPR(rs1), FPR(rs2))
42# define STFSRI(rd, rs1, imm) f3i(3, FPR(rd), 37, FPR(rs1), imm)
43# define STDFQ(rd, rs1, rs2) f3r(3, FPR(rd), 38, FPR(rs1), FPR(rs2))
44# define STFDFQ(rd, rs1, imm) f3i(3, FPR(rd), 38, FPR(rs1), imm)
45# define SPARC_FBA 8 /* always - 1 */
46# define SPARC_FBN 0 /* never - 0 */
47# define SPARC_FBU 7 /* unordered - U */
48# define SPARC_FBG 6 /* greater - G */
49# define SPARC_FBUG 5 /* unordered or greater - G or U */
50# define SPARC_FBL 4 /* less - L */
51# define SPARC_FBUL 3 /* unordered or less - L or U */
52# define SPARC_FBLG 2 /* less or greater - L or G */
53# define SPARC_FBNE 1 /* not equal - L or G or U */
54# define SPARC_FBNZ SPARC_FBNE
55# define SPARC_FBE 9 /* equal - E */
56# define SPARC_FBZ SPARC_FBE
57# define SPARC_FBUE 10 /* unordered or equal - E or U */
58# define SPARC_FBGE 11 /* greater or equal - E or G */
59# define SPARC_FBUGE 12 /* unordered or greater or equal - E or G or U */
60# define SPARC_FBLE 13 /* less or equal - E or L */
61# define SPARC_FBULE 14 /* unordered or less or equal - E or L or U */
62# define SPARC_FBO 15 /* ordered - E or L or G */
63# define FB(cc, imm) f2b(0, 0, cc, 6, imm)
64# define FBa(cc, imm) f2b(0, 1, cc, 6, imm)
65# define FBA(imm) FB(SPARC_FBA, imm)
66# define FBAa(imm) FBa(SPARC_FBA, imm)
67# define FBN(imm) FB(SPARC_FBN, imm)
68# define FBNa(imm) FBa(SPARC_FBN, imm)
69# define FBU(imm) FB(SPARC_FBU, imm)
70# define FBUa(imm) FBa(SPARC_FBU, imm)
71# define FBG(imm) FB(SPARC_FBG, imm)
72# define FBGa(imm) FBa(SPARC_FBG, imm)
73# define FBUG(imm) FB(SPARC_FBUG, imm)
74# define FBUGa(imm) FBa(SPARC_FBUG, imm)
75# define FBL(imm) FB(SPARC_FBL, imm)
76# define FBLa(imm) FBa(SPARC_FBL, imm)
77# define FBUL(imm) FB(SPARC_FBUL, imm)
78# define FBULa(imm) FBa(SPARC_FBUL, imm)
79# define FBLG(imm) FB(SPARC_FBLG, imm)
80# define FBLGa(imm) FBa(SPARC_FBLG, imm)
81# define FBNE(imm) FB(SPARC_FBNE, imm)
82# define FBNEa(imm) FBa(SPARC_FBNE, imm)
83# define FBE(imm) FB(SPARC_FBE, imm)
84# define FBEa(imm) FBa(SPARC_FBE, imm)
85# define FBUE(imm) FB(SPARC_FBUE, imm)
86# define FBUEa(imm) FBa(SPARC_FBUE, imm)
87# define FBLE(imm) FB(SPARC_FBLE, imm)
88# define FBLEa(imm) FBa(SPARC_FBLE, imm)
89# define FBO(imm) FB(SPARC_FBO, imm)
90# define FBOa(imm) FBa(SPARC_FBO, imm)
91# define FPop1(rd, rs1, opf, rs2) f3f(rd, 52, rs1, opf, rs2)
92# define FPop2(rd, rs1, opf, rs2) f3f(rd, 53, rs1, opf, rs2)
93# define f3f(rd, op3, rs1, opf, rs2) _f3f(_jit, rd, op3, rs1, opf, rs2)
94static void
95_f3f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t, jit_int32_t,jit_int32_t);
96# define FITOS(rs2, rd) FPop1(rd, 0, 196, rs2)
97# define FITOD(rs2, rd) FPop1(rd, 0, 200, rs2)
98# define FITOQ(rs2, rd) FPop1(rd, 0, 204, rs2)
99# if __WORDSIZE == 64
100# define FXTOS(rs2, rd) FPop1(rd, 0, 132, rs2)
101# define FXTOD(rs2, rd) FPop1(rd, 0, 136, rs2)
102# define FxTOQ(rs2, rd) FPop1(rd, 0, 140, rs2)
103# endif
104# define FSTOI(rs2, rd) FPop1(rd, 0, 209, rs2)
105# define FDTOI(rs2, rd) FPop1(rd, 0, 210, rs2)
106# define FQTOI(rs2, rd) FPop1(rd, 0, 211, rs2)
107# define FSTOX(rs2, rd) FPop1(rd, 0, 129, rs2)
108# define FDTOX(rs2, rd) FPop1(rd, 0, 130, rs2)
109# define FQTOX(rs2, rd) FPop1(rd, 0, 131, rs2)
110# define FSTOD(rs2, rd) FPop1(rd, 0, 201, rs2)
111# define FSTOQ(rs2, rd) FPop1(rd, 0, 205, rs2)
112# define FDTOS(rs2, rd) FPop1(rd, 0, 198, rs2)
113# define FDTOQ(rs2, rd) FPop1(rd, 0, 206, rs2)
114# define FQTOS(rs2, rd) FPop1(rd, 0, 199, rs2)
115# define FQTOD(rs2, rd) FPop1(rd, 0, 203, rs2)
116# define FMOVS(rs2, rd) FPop1(rd, 0, 1, rs2)
117# define FMOVD(rs2, rd) FPop1(rd, 0, 2, rs2)
118# define FMOVQ(rs2, rd) FPop1(rd, 0, 3, rs2)
119# define FNEGS(rs2, rd) FPop1(rd, 0, 5, rs2)
120# define FNEGD(rs2, rd) FPop1(rd, 0, 6, rs2)
121# define FNEGQ(rs2, rd) FPop1(rd, 0, 7, rs2)
122# define FABSS(rs2, rd) FPop1(rd, 0, 9, rs2)
123# define FABSD(rs2, rd) FPop1(rd, 0, 10, rs2)
124# define FABSQ(rs2, rd) FPop1(rd, 0, 11, rs2)
125# define FSQRTS(rs2, rd) FPop1(rd, 0, 41, rs2)
126# define FSQRTD(rs2, rd) FPop1(rd, 0, 42, rs2)
127# define FSQRTQ(rs2, rd) FPop1(rd, 0, 43, rs2)
128# define SPARC_FADDS 65
129# define SPARC_FADDD 66
130# define SPARC_FADDQ 67
131# define SPARC_FSUBS 69
132# define SPARC_FSUBD 70
133# define SPARC_FSUBQ 71
134# define SPARC_FMULS 73
135# define SPARC_FMULD 74
136# define SPARC_FMULQ 75
137# define SPARC_FSMULD 105
138# define SPARC_FDMULQ 110
139# define SPARC_FDIVS 77
140# define SPARC_FDIVD 78
141# define SPARC_FDIVQ 79
142# define FADDS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDS, rs2)
143# define FADDD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDD, rs2)
144# define FADDQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDQ, rs2)
145# define FSUBS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBS, rs2)
146# define FSUBD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBD, rs2)
147# define FSUBQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBQ, rs2)
148# define FMULS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULS, rs2)
149# define FMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULD, rs2)
150# define FMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULQ, rs2)
151# define FSMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSMULD, rs2)
152# define FDMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDMULQ, rs2)
153# define FDIVS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVS, rs2)
154# define FDIVD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVD, rs2)
155# define FDIVQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVQ, rs2)
156# define SPARC_FCMPS 81
157# define SPARC_FCMPD 82
158# define SPARC_FCMPQ 83
159# define SPARC_FCMPES 85
160# define SPARC_FCMPED 86
161# define SPARC_FCMPEQ 87
162# define FCMPS(rs1, rs2) FPop2(0, rs1, SPARC_FCMPS, rs2)
163# define FCMPD(rs1, rs2) FPop2(0, rs1, SPARC_FCMPD, rs2)
164# define FCMPQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPQ, rs2)
165# define FCMPES(rs1, rs2) FPop2(0, rs1, SPARC_FCMPES, rs2)
166# define FCMPED(rs1, rs2) FPop2(0, rs1, SPARC_FCMPED, rs2)
167# define FCMPEQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPEQ, rs2)
168# define CPop1(rd, rs1, opc, rs2) f3f(rd, 54, rs1, opf, rs2)
169# define CPop2(rd, rs1, opc, rs2) f3f(rd, 55, rs1, opf, rs2)
170# define extr_f(r0, r1) _extr_f(_jit, r0, r1)
171static void _extr_f(jit_state_t*, jit_int32_t, jit_int32_t);
172# if __WORDSIZSE == 32
173# define truncr_f(r0, r1) truncr_f_i(r0, r1)
174# define truncr_d(r0, r1) truncr_d_i(r0, r1)
175# else
176# define truncr_f(r0, r1) truncr_f_l(r0, r1)
177# define truncr_d(r0, r1) truncr_d_l(r0, r1)
178# endif
179# define truncr_f_i(r0, r1) _truncr_f_i(_jit, r0, r1)
180static void _truncr_f_i(jit_state_t*, jit_int32_t, jit_int32_t);
181# if __WORDSIZE == 64
182# define truncr_f_l(r0, r1) _truncr_f_l(_jit, r0, r1)
183static void _truncr_f_l(jit_state_t*, jit_int32_t, jit_int32_t);
184# endif
185# if __WORDSIZE == 32
186# define extr_d_f(r0, r1) FDTOS(r1, r0)
187# else
188# define extr_d_f(r0, r1) _extr_d_f(_jit, r0, r1)
189static void _extr_d_f(jit_state_t*, jit_int32_t, jit_int32_t);
190# endif
191# define movi_f(r0, i0) _movi_f(_jit, r0, i0)
192# if __WORDSIZE == 32
193# define movr_f(r0, r1) FMOVS(r1, r0)
194# else
195# define movr_f(r0, r1) _movr_f(_jit, r0, r1)
196static void _movr_f(jit_state_t*, jit_int32_t, jit_int32_t);
197# endif
198static void _movi_f(jit_state_t*, jit_int32_t, jit_float32_t*);
199# if __WORDSIZE == 32
200# define negr_f(r0, r1) FNEGS(r1, r0)
201# define absr_f(r0, r1) FABSS(r1, r0)
202# define sqrtr_f(r0, r1) FSQRTS(r1, r0)
203# else
204# define negr_f(r0, r1) _negr_f(_jit, r0, r1)
205static void _negr_f(jit_state_t*, jit_int32_t, jit_int32_t);
206# define absr_f(r0, r1) _absr_f(_jit, r0, r1)
207static void _absr_f(jit_state_t*, jit_int32_t, jit_int32_t);
208# define sqrtr_f(r0, r1) _sqrtr_f(_jit, r0, r1)
209static void _sqrtr_f(jit_state_t*, jit_int32_t, jit_int32_t);
210# endif
211# define extr_d(r0, r1) _extr_d(_jit, r0, r1)
212static void _extr_d(jit_state_t*, jit_int32_t, jit_int32_t);
213# define truncr_d_i(r0, r1) _truncr_d_i(_jit, r0, r1)
214static void _truncr_d_i(jit_state_t*, jit_int32_t, jit_int32_t);
215# if __WORDSIZE == 64
216# define truncr_d_l(r0, r1) _truncr_d_l(_jit, r0, r1)
217static void _truncr_d_l(jit_state_t*, jit_int32_t, jit_int32_t);
218# endif
219# if __WORDSIZE == 32
220# define extr_f_d(r0, r1) FSTOD(r1, r0)
221# else
222# define extr_f_d(r0, r1) _extr_f_d(_jit, r0, r1)
223static void _extr_f_d(jit_state_t*, jit_int32_t, jit_int32_t);
224# endif
225# define movi_d(r0, i0) _movi_d(_jit, r0, i0)
226static void _movi_d(jit_state_t*, jit_int32_t, jit_float64_t*);
227# if __WORDSIZE == 32
228# define movr_d(r0, r1) _movr_d(_jit, r0, r1)
229static void _movr_d(jit_state_t*, jit_int32_t, jit_int32_t);
230# define negr_d(r0, r1) _negr_d(_jit, r0, r1)
231static void _negr_d(jit_state_t*, jit_int32_t, jit_int32_t);
232# define absr_d(r0, r1) _absr_d(_jit, r0, r1)
233static void _absr_d(jit_state_t*, jit_int32_t, jit_int32_t);
234# else
235# define movr_d(r0, r1) FMOVD(r1, r0)
236# define negr_d(r0, r1) FNEGD(r1, r0)
237# define absr_d(r0, r1) FABSD(r1, r0)
238# endif
239# define sqrtr_d(r0, r1) FSQRTD(r1, r0)
240# define fop1f(op, r0, r1, i0) _fop1f(_jit, op, r0, r1, i0)
241static void _fop1f(jit_state_t*,jit_int32_t,
242 jit_int32_t,jit_int32_t,jit_float32_t*);
243# define rfop1f(op, r0, r1, i0) _rfop1f(_jit, op, r0, r1, i0)
244static void _rfop1f(jit_state_t*,jit_int32_t,
245 jit_int32_t,jit_int32_t,jit_float32_t*);
246# define fop1d(op, r0, r1, i0) _fop1d(_jit, op, r0, r1, i0)
247static void _fop1d(jit_state_t*,jit_int32_t,
248 jit_int32_t,jit_int32_t,jit_float64_t*);
249# define rfop1d(op, r0, r1, i0) _rfop1d(_jit, op, r0, r1, i0)
250static void _rfop1d(jit_state_t*,jit_int32_t,
251 jit_int32_t,jit_int32_t,jit_float64_t*);
252# if __WORDSIZE == 32
253# define addr_f(r0, r1, r2) FADDS(r1, r2, r0)
254# define subr_f(r0, r1, r2) FSUBS(r1, r2, r0)
255# define mulr_f(r0, r1, r2) FMULS(r1, r2, r0)
256# define divr_f(r0, r1, r2) FDIVS(r1, r2, r0)
257# else
258# define fop2f(op, r0, r1, r2) _fop2f(_jit, op, r0, r1, r2)
259static void _fop2f(jit_state_t*, jit_int32_t,
260 jit_int32_t, jit_int32_t, jit_int32_t);
261# define addr_f(r0, r1, r2) fop2f(SPARC_FADDS, r0, r1, r2)
262# define subr_f(r0, r1, r2) fop2f(SPARC_FSUBS, r0, r1, r2)
263# define mulr_f(r0, r1, r2) fop2f(SPARC_FMULS, r0, r1, r2)
264# define divr_f(r0, r1, r2) fop2f(SPARC_FDIVS, r0, r1, r2)
265# endif
266# define addi_f(r0, r1, i0) fop1f(SPARC_FADDS, r0, r1, i0)
267# define subi_f(r0, r1, i0) fop1f(SPARC_FSUBS, r0, r1, i0)
268# define rsbr_f(r0, r1, r2) subr_f(r0, r2, r1)
269# define rsbi_f(r0, r1, i0) rfop1f(SPARC_FSUBS, r0, r1, i0)
270# define rsbr_d(r0, r1, r2) subr_d(r0, r2, r1)
271# define rsbi_d(r0, r1, i0) rfop1d(SPARC_FSUBD, r0, r1, i0)
272# define muli_f(r0, r1, i0) fop1f(SPARC_FMULS, r0, r1, i0)
273# define divi_f(r0, r1, i0) fop1f(SPARC_FDIVS, r0, r1, i0)
274# define addr_d(r0, r1, r2) FADDD(r1, r2, r0)
275# define addi_d(r0, r1, i0) fop1d(SPARC_FADDD, r0, r1, i0)
276# define subr_d(r0, r1, r2) FSUBD(r1, r2, r0)
277# define subi_d(r0, r1, i0) fop1d(SPARC_FSUBD, r0, r1, i0)
278# define rsbr_d(r0, r1, r2) subr_d(r0, r2, r1)
279# define rsbi_d(r0, r1, i0) rfop1d(SPARC_FSUBD, r0, r1, i0)
280# define mulr_d(r0, r1, r2) FMULD(r1, r2, r0)
281# define muli_d(r0, r1, i0) fop1d(SPARC_FMULD, r0, r1, i0)
282# define divr_d(r0, r1, r2) FDIVD(r1, r2, r0)
283# define divi_d(r0, r1, i0) fop1d(SPARC_FDIVD, r0, r1, i0)
284#define fcr(cc, r0, r1, r2) _fcr(_jit, cc, r0, r1, r2)
285static void _fcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
286#define fcw(cc, r0, r1, i0) _fcw(_jit, cc, r0, r1, i0)
287static void
288_fcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float32_t*);
289# define ltr_f(r0, r1, r2) fcr(SPARC_FBL, r0, r1, r2)
290# define lti_f(r0, r1, i0) fcw(SPARC_FBL, r0, r1, i0)
291# define ler_f(r0, r1, r2) fcr(SPARC_FBLE, r0, r1, r2)
292# define lei_f(r0, r1, i0) fcw(SPARC_FBLE, r0, r1, i0)
293# define eqr_f(r0, r1, r2) fcr(SPARC_FBE, r0, r1, r2)
294# define eqi_f(r0, r1, i0) fcw(SPARC_FBE, r0, r1, i0)
295# define ger_f(r0, r1, r2) fcr(SPARC_FBGE, r0, r1, r2)
296# define gei_f(r0, r1, i0) fcw(SPARC_FBGE, r0, r1, i0)
297# define gtr_f(r0, r1, r2) fcr(SPARC_FBG, r0, r1, r2)
298# define gti_f(r0, r1, i0) fcw(SPARC_FBG, r0, r1, i0)
299# define ner_f(r0, r1, r2) fcr(SPARC_FBNE, r0, r1, r2)
300# define nei_f(r0, r1, i0) fcw(SPARC_FBNE, r0, r1, i0)
301# define unltr_f(r0, r1, r2) fcr(SPARC_FBUL, r0, r1, r2)
302# define unlti_f(r0, r1, i0) fcw(SPARC_FBUL, r0, r1, i0)
303# define unler_f(r0, r1, r2) fcr(SPARC_FBULE, r0, r1, r2)
304# define unlei_f(r0, r1, i0) fcw(SPARC_FBULE, r0, r1, i0)
305# define uneqr_f(r0, r1, r2) fcr(SPARC_FBUE, r0, r1, r2)
306# define uneqi_f(r0, r1, i0) fcw(SPARC_FBUE, r0, r1, i0)
307# define unger_f(r0, r1, r2) fcr(SPARC_FBUGE, r0, r1, r2)
308# define ungei_f(r0, r1, i0) fcw(SPARC_FBUGE, r0, r1, i0)
309# define ungtr_f(r0, r1, r2) fcr(SPARC_FBUG, r0, r1, r2)
310# define ungti_f(r0, r1, i0) fcw(SPARC_FBUG, r0, r1, i0)
311# define ltgtr_f(r0, r1, r2) fcr(SPARC_FBLG, r0, r1, r2)
312# define ltgti_f(r0, r1, i0) fcw(SPARC_FBLG, r0, r1, i0)
313# define ordr_f(r0, r1, r2) fcr(SPARC_FBO, r0, r1, r2)
314# define ordi_f(r0, r1, i0) fcw(SPARC_FBO, r0, r1, i0)
315# define unordr_f(r0, r1, r2) fcr(SPARC_FBU, r0, r1, r2)
316# define unordi_f(r0, r1, i0) fcw(SPARC_FBU, r0, r1, i0)
317#define dcr(cc, r0, r1, r2) _dcr(_jit, cc, r0, r1, r2)
318static void _dcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
319#define dcw(cc, r0, r1, i0) _dcw(_jit, cc, r0, r1, i0)
320static void
321_dcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float64_t*);
322# define ltr_d(r0, r1, r2) dcr(SPARC_FBL, r0, r1, r2)
323# define lti_d(r0, r1, i0) dcw(SPARC_FBL, r0, r1, i0)
324# define ler_d(r0, r1, r2) dcr(SPARC_FBLE, r0, r1, r2)
325# define lei_d(r0, r1, i0) dcw(SPARC_FBLE, r0, r1, i0)
326# define eqr_d(r0, r1, r2) dcr(SPARC_FBE, r0, r1, r2)
327# define eqi_d(r0, r1, i0) dcw(SPARC_FBE, r0, r1, i0)
328# define ger_d(r0, r1, r2) dcr(SPARC_FBGE, r0, r1, r2)
329# define gei_d(r0, r1, i0) dcw(SPARC_FBGE, r0, r1, i0)
330# define gtr_d(r0, r1, r2) dcr(SPARC_FBG, r0, r1, r2)
331# define gti_d(r0, r1, i0) dcw(SPARC_FBG, r0, r1, i0)
332# define ner_d(r0, r1, r2) dcr(SPARC_FBNE, r0, r1, r2)
333# define nei_d(r0, r1, i0) dcw(SPARC_FBNE, r0, r1, i0)
334# define unltr_d(r0, r1, r2) dcr(SPARC_FBUL, r0, r1, r2)
335# define unlti_d(r0, r1, i0) dcw(SPARC_FBUL, r0, r1, i0)
336# define unler_d(r0, r1, r2) dcr(SPARC_FBULE, r0, r1, r2)
337# define unlei_d(r0, r1, i0) dcw(SPARC_FBULE, r0, r1, i0)
338# define uneqr_d(r0, r1, r2) dcr(SPARC_FBUE, r0, r1, r2)
339# define uneqi_d(r0, r1, i0) dcw(SPARC_FBUE, r0, r1, i0)
340# define unger_d(r0, r1, r2) dcr(SPARC_FBUGE, r0, r1, r2)
341# define ungei_d(r0, r1, i0) dcw(SPARC_FBUGE, r0, r1, i0)
342# define ungtr_d(r0, r1, r2) dcr(SPARC_FBUG, r0, r1, r2)
343# define ungti_d(r0, r1, i0) dcw(SPARC_FBUG, r0, r1, i0)
344# define ltgtr_d(r0, r1, r2) dcr(SPARC_FBLG, r0, r1, r2)
345# define ltgti_d(r0, r1, i0) dcw(SPARC_FBLG, r0, r1, i0)
346# define ordr_d(r0, r1, r2) dcr(SPARC_FBO, r0, r1, r2)
347# define ordi_d(r0, r1, i0) dcw(SPARC_FBO, r0, r1, i0)
348# define unordr_d(r0, r1, r2) dcr(SPARC_FBU, r0, r1, r2)
349# define unordi_d(r0, r1, i0) dcw(SPARC_FBU, r0, r1, i0)
350# if __WORDSIZE == 32
351# define ldr_f(r0, r1) LDF(r1, 0, r0)
352# else
353# define ldr_f(r0, r1) _ldr_f(_jit, r0, r1)
354static void _ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
355# endif
356# define ldi_f(r0, i0) _ldi_f(_jit, r0, i0)
357static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
358# if __WORDSIZE == 32
359# define ldxr_f(r0, r1, r2) LDF(r1, r2, r0)
360# else
361# define ldxr_f(r0, r1, r2) _ldxr_f(_jit, r0, r1, r2)
362static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
363# endif
364# define ldxi_f(r0, r1, i0) _ldxi_f(_jit, r0, r1, i0)
365static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
366# if __WORDSIZE == 32
367# define str_f(r0, r1) STF(r1, r0, 0)
368# else
369# define str_f(r0, r1) _str_f(_jit, r0, r1)
370static void _str_f(jit_state_t*,jit_int32_t,jit_int32_t);
371# endif
372# define sti_f(r0, i0) _sti_f(_jit, r0, i0)
373static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
374# if __WORDSIZE == 32
375# define stxr_f(r0, r1, r2) STF(r2, r1, r0)
376# else
377# define stxr_f(r0, r1, r2) _stxr_f(_jit, r0, r1, r2)
378static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
379# endif
380# define stxi_f(r0, r1, i0) _stxi_f(_jit, r0, r1, i0)
381static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
382# define ldr_d(r0, r1) LDDF(r1, 0, r0)
383# define ldi_d(r0, i0) _ldi_d(_jit, r0, i0)
384static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
385# define ldxr_d(r0, r1, r2) LDDF(r1, r2, r0)
386# define ldxi_d(r0, r1, i0) _ldxi_d(_jit, r0, r1, i0)
387static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
388# define str_d(r0, r1) STDF(r1, r0, 0)
389# define sti_d(r0, i0) _sti_d(_jit, r0, i0)
390static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
391# define stxr_d(r0, r1, r2) STDF(r2, r1, r0)
392# define stxi_d(r0, r1, i0) _stxi_d(_jit, r0, r1, i0)
393static void _stxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
394# define fbr(cc, i0, r0, r1) _fbr(_jit, cc, i0, r0, r1)
395static jit_word_t
396_fbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
397# define fbw(cc, i0, r0, i1) _fbw(_jit, cc, i0, r0, i1)
398static jit_word_t
399_fbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t*);
400# define bltr_f(i0, r0, r1) fbr(SPARC_FBL, i0, r0, r1)
401# define blti_f(i0, r0, i1) fbw(SPARC_FBL, i0, r0, i1)
402# define bler_f(i0, r0, r1) fbr(SPARC_FBLE, i0, r0, r1)
403# define blei_f(i0, r0, i1) fbw(SPARC_FBLE, i0, r0, i1)
404# define beqr_f(i0, r0, r1) fbr(SPARC_FBE, i0, r0, r1)
405# define beqi_f(i0, r0, i1) fbw(SPARC_FBE, i0, r0, i1)
406# define bger_f(i0, r0, r1) fbr(SPARC_FBGE, i0, r0, r1)
407# define bgei_f(i0, r0, i1) fbw(SPARC_FBGE, i0, r0, i1)
408# define bgtr_f(i0, r0, r1) fbr(SPARC_FBG, i0, r0, r1)
409# define bgti_f(i0, r0, i1) fbw(SPARC_FBG, i0, r0, i1)
410# define bner_f(i0, r0, r1) fbr(SPARC_FBNE, i0, r0, r1)
411# define bnei_f(i0, r0, i1) fbw(SPARC_FBNE, i0, r0, i1)
412# define bunltr_f(i0, r0, r1) fbr(SPARC_FBUL, i0, r0, r1)
413# define bunlti_f(i0, r0, i1) fbw(SPARC_FBUL, i0, r0, i1)
414# define bunler_f(i0, r0, r1) fbr(SPARC_FBULE, i0, r0, r1)
415# define bunlei_f(i0, r0, i1) fbw(SPARC_FBULE, i0, r0, i1)
416# define buneqr_f(i0, r0, r1) fbr(SPARC_FBUE, i0, r0, r1)
417# define buneqi_f(i0, r0, i1) fbw(SPARC_FBUE, i0, r0, i1)
418# define bunger_f(i0, r0, r1) fbr(SPARC_FBUGE, i0, r0, r1)
419# define bungei_f(i0, r0, i1) fbw(SPARC_FBUGE, i0, r0, i1)
420# define bungtr_f(i0, r0, r1) fbr(SPARC_FBUG, i0, r0, r1)
421# define bungti_f(i0, r0, i1) fbw(SPARC_FBUG, i0, r0, i1)
422# define bltgtr_f(i0, r0, r1) fbr(SPARC_FBLG, i0, r0, r1)
423# define bltgti_f(i0, r0, i1) fbw(SPARC_FBLG, i0, r0, i1)
424# define bordr_f(i0, r0, r1) fbr(SPARC_FBO, i0, r0, r1)
425# define bordi_f(i0, r0, i1) fbw(SPARC_FBO, i0, r0, i1)
426# define bunordr_f(i0, r0, r1) fbr(SPARC_FBU, i0, r0, r1)
427# define bunordi_f(i0, r0, i1) fbw(SPARC_FBU, i0, r0, i1)
428# define dbr(cc, i0, r0, r1) _dbr(_jit, cc, i0, r0, r1)
429static jit_word_t
430_dbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
431# define dbw(cc, i0, r0, i1) _dbw(_jit, cc, i0, r0, i1)
432static jit_word_t
433_dbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t*);
434# define bltr_d(i0, r0, r1) dbr(SPARC_FBL, i0, r0, r1)
435# define blti_d(i0, r0, i1) dbw(SPARC_FBL, i0, r0, i1)
436# define bler_d(i0, r0, r1) dbr(SPARC_FBLE, i0, r0, r1)
437# define blei_d(i0, r0, i1) dbw(SPARC_FBLE, i0, r0, i1)
438# define beqr_d(i0, r0, r1) dbr(SPARC_FBE, i0, r0, r1)
439# define beqi_d(i0, r0, i1) dbw(SPARC_FBE, i0, r0, i1)
440# define bger_d(i0, r0, r1) dbr(SPARC_FBGE, i0, r0, r1)
441# define bgei_d(i0, r0, i1) dbw(SPARC_FBGE, i0, r0, i1)
442# define bgtr_d(i0, r0, r1) dbr(SPARC_FBG, i0, r0, r1)
443# define bgti_d(i0, r0, i1) dbw(SPARC_FBG, i0, r0, i1)
444# define bner_d(i0, r0, r1) dbr(SPARC_FBNE, i0, r0, r1)
445# define bnei_d(i0, r0, i1) dbw(SPARC_FBNE, i0, r0, i1)
446# define bunltr_d(i0, r0, r1) dbr(SPARC_FBUL, i0, r0, r1)
447# define bunlti_d(i0, r0, i1) dbw(SPARC_FBUL, i0, r0, i1)
448# define bunler_d(i0, r0, r1) dbr(SPARC_FBULE, i0, r0, r1)
449# define bunlei_d(i0, r0, i1) dbw(SPARC_FBULE, i0, r0, i1)
450# define buneqr_d(i0, r0, r1) dbr(SPARC_FBUE, i0, r0, r1)
451# define buneqi_d(i0, r0, i1) dbw(SPARC_FBUE, i0, r0, i1)
452# define bunger_d(i0, r0, r1) dbr(SPARC_FBUGE, i0, r0, r1)
453# define bungei_d(i0, r0, i1) dbw(SPARC_FBUGE, i0, r0, i1)
454# define bungtr_d(i0, r0, r1) dbr(SPARC_FBUG, i0, r0, r1)
455# define bungti_d(i0, r0, i1) dbw(SPARC_FBUG, i0, r0, i1)
456# define bltgtr_d(i0, r0, r1) dbr(SPARC_FBLG, i0, r0, r1)
457# define bltgti_d(i0, r0, i1) dbw(SPARC_FBLG, i0, r0, i1)
458# define bordr_d(i0, r0, r1) dbr(SPARC_FBO, i0, r0, r1)
459# define bordi_d(i0, r0, i1) dbw(SPARC_FBO, i0, r0, i1)
460# define bunordr_d(i0, r0, r1) dbr(SPARC_FBU, i0, r0, r1)
461# define bunordi_d(i0, r0, i1) dbw(SPARC_FBU, i0, r0, i1)
462# define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
463static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
464#endif
465
466#if CODE
467static void
468_f3f(jit_state_t *_jit, jit_int32_t rd,
469 jit_int32_t op3, jit_int32_t rs1, jit_int32_t opf, jit_int32_t rs2)
470{
471 jit_instr_t v;
472# if __WORDSIZE == 64
473 if (rd > 31) {
474 assert(rd <= 63 && (rd & 1) == 0);
475 rd -= 31;
476 }
477 if (rs1 > 31) {
478 assert(rs1 <= 63 && (rs1 & 1) == 0);
479 rs1 -= 31;
480 }
481 if (rs2 > 31) {
482 assert(rs2 <= 63 && (rs2 & 1) == 0);
483 rs2 -= 31;
484 }
485# endif
486 assert(!(rd & 0xffffffe0));
487 assert(!(op3 & 0xffffffc0));
488 assert(!(rs1 & 0xffffffe0));
489 assert(!(opf & 0xfffffe00));
490 assert(!(rs2 & 0xffffffe0));
491 v.op.b = 2;
492 v.rd.b = rd;
493 v.op3.b = op3;
494 v.rs1.b = rs1;
495 v.opf.b = opf;
496 v.rs2.b = rs2;
497 ii(v.v);
498}
499
500# if __WORDSIZE == 64
501static void
502_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
503{
504 jit_int32_t t0, t1;
505 if (r0 != r1) {
506 if (single_precision_p(r0)) {
507 if (single_precision_p(r1))
508 FMOVS(r1, r0);
509 else {
510 t1 = jit_get_reg(CLASS_SNG);
511 movr_d(rn(t1), r1);
512 FMOVS(rn(t1), r0);
513 jit_unget_reg(t1);
514 }
515 }
516 else {
517 if (single_precision_p(r1)) {
518 t0 = jit_get_reg(CLASS_SNG);
519 FMOVS(r1, rn(t0));
520 movr_d(r0, rn(t0));
521 jit_unget_reg(t0);
522 }
523 else {
524 t1 = jit_get_reg(CLASS_SNG);
525 movr_d(rn(t1), r1);
526 FMOVS(rn(t1), rn(t1));
527 movr_d(r0, rn(t1));
528 jit_unget_reg(t1);
529 }
530 }
531 }
532}
533
534static void
535_negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
536{
537 jit_int32_t t0, t1;
538 if (single_precision_p(r0)) {
539 if (single_precision_p(r1))
540 FNEGS(r1, r0);
541 else {
542 t1 = jit_get_reg(CLASS_SNG);
543 movr_d(rn(t1), r1);
544 FNEGS(rn(t1), r0);
545 jit_unget_reg(t1);
546 }
547 }
548 else {
549 if (single_precision_p(r1)) {
550 t0 = jit_get_reg(CLASS_SNG);
551 FNEGS(r1, rn(t0));
552 movr_d(r0, rn(t0));
553 jit_unget_reg(t0);
554 }
555 else {
556 t1 = jit_get_reg(CLASS_SNG);
557 movr_d(rn(t1), r1);
558 FNEGS(rn(t1), rn(t1));
559 movr_d(r0, rn(t1));
560 jit_unget_reg(t1);
561 }
562 }
563}
564
565static void
566_absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
567{
568 jit_int32_t t0, t1;
569 if (single_precision_p(r0)) {
570 if (single_precision_p(r1))
571 FABSS(r1, r0);
572 else {
573 t1 = jit_get_reg(CLASS_SNG);
574 movr_d(rn(t1), r1);
575 FABSS(rn(t1), r0);
576 jit_unget_reg(t1);
577 }
578 }
579 else {
580 if (single_precision_p(r1)) {
581 t0 = jit_get_reg(CLASS_SNG);
582 FABSS(r1, rn(t0));
583 movr_d(r0, rn(t0));
584 jit_unget_reg(t0);
585 }
586 else {
587 t1 = jit_get_reg(CLASS_SNG);
588 movr_d(rn(t1), r1);
589 FABSS(rn(t1), rn(t1));
590 movr_d(r0, rn(t1));
591 jit_unget_reg(t1);
592 }
593 }
594}
595
596static void
597_sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
598{
599 jit_int32_t t0, t1;
600 if (single_precision_p(r0)) {
601 if (single_precision_p(r1))
602 FSQRTS(r1, r0);
603 else {
604 t1 = jit_get_reg(CLASS_SNG);
605 movr_d(rn(t1), r1);
606 FSQRTS(rn(t1), r0);
607 jit_unget_reg(t1);
608 }
609 }
610 else {
611 if (single_precision_p(r1)) {
612 t0 = jit_get_reg(CLASS_SNG);
613 FSQRTS(r1, rn(t0));
614 movr_d(r0, rn(t0));
615 jit_unget_reg(t0);
616 }
617 else {
618 t1 = jit_get_reg(CLASS_SNG);
619 movr_d(rn(t1), r1);
620 FSQRTS(rn(t1), rn(t1));
621 movr_d(r0, rn(t1));
622 jit_unget_reg(t1);
623 }
624 }
625}
626# endif
627
628# if __WORDSIZE == 64
629static void
630_extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
631{
632 jit_int32_t reg;
633 if (!single_precision_p(r0)) {
634 reg = jit_get_reg(CLASS_SNG);
635 movr_d(rn(reg), r0);
636 FDTOS(r1, rn(reg));
637 movr_d(r0, rn(reg));
638 jit_unget_reg(reg);
639 }
640 else
641 FDTOS(r1, r0);
642}
643# endif
644
645static void
646_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
647{
648 union {
649 jit_int32_t i;
650 jit_float32_t f;
651 } data;
652 jit_int32_t reg;
653
654 if (_jitc->no_data) {
655 data.f = *i0;
656 reg = jit_get_reg(jit_class_gpr);
657 movi(rn(reg), data.i & 0xffffffff);
658 stxi_i(BIAS(-8), _FP_REGNO, rn(reg));
659 jit_unget_reg(reg);
660 ldxi_f(r0, _FP_REGNO, BIAS(-8));
661 }
662 else
663 ldi_f(r0, (jit_word_t)i0);
664}
665
666# if __WORDSIZE == 64
667static void
668_extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
669{
670 jit_int32_t reg;
671 if (!single_precision_p(r1)) {
672 reg = jit_get_reg(CLASS_SNG);
673 movr_d(rn(reg), r1);
674 FSTOD(rn(reg), r0);
675 jit_unget_reg(reg);
676 }
677 else
678 FSTOD(r1, r0);
679}
680# endif
681
682static void
683_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
684{
685 union {
686# if __WORDSIZE == 32
687 jit_int32_t i[2];
688# else
689 jit_word_t w;
690# endif
691 jit_float64_t d;
692 } data;
693 jit_int32_t reg;
694
695 if (_jitc->no_data) {
696 data.d = *i0;
697 reg = jit_get_reg(jit_class_gpr);
698# if __WORDSIZE == 32
699 movi(rn(reg), data.i[0]);
700# else
701 movi(rn(reg), data.w);
702# endif
703 stxi(BIAS(-8), _FP_REGNO, rn(reg));
704# if __WORDSIZE == 32
705 movi(rn(reg), data.i[1]);
706 stxi_i(BIAS(-4), _FP_REGNO, rn(reg));
707# endif
708 jit_unget_reg(reg);
709 ldxi_d(r0, _FP_REGNO, BIAS(-8));
710 }
711 else
712 ldi_d(r0, (jit_word_t)i0);
713}
714
715# if __WORDSIZE == 32
716static void
717_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
718{
719 assert(!(r0 & 1));
720 assert(!(r1 & 1));
721 if (r0 != r1) {
722 FMOVS(r1, r0);
723 FMOVS(r1 + 1, r0 + 1);
724 }
725}
726
727static void
728_negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
729{
730 assert(!(r0 & 1));
731 assert(!(r1 & 1));
732 FNEGS(r1, r0);
733 if (r0 != r1)
734 FMOVS(r1 + 1, r0 + 1);
735}
736
737static void
738_absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
739{
740 assert(!(r0 & 1));
741 assert(!(r1 & 1));
742 FABSS(r1, r0);
743 if (r0 != r1)
744 FMOVS(r1 + 1, r0 + 1);
745}
746# endif
747
748# if __WORDSIZE == 64
749# define single_rrr(NAME, CODE) \
750static void \
751NAME(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) \
752{ \
753 jit_int32_t x0, t0, x1, t1, x2, t2, mask = 0; \
754 if (!single_precision_p(r0)) { \
755 mask |= 1; \
756 t0 = jit_get_reg(CLASS_SNG); \
757 x0 = rn(t0); \
758 if (r0 == r1) { \
759 x1 = x0; \
760 movr_d(x1, r1); \
761 if (r0 == r2) \
762 x2 = x0; \
763 } \
764 else if (r0 == r2) { \
765 x2 = x0; \
766 movr_d(x2, r2); \
767 } \
768 } \
769 else \
770 x0 = r0; \
771 if (!single_precision_p(r1)) { \
772 if (r0 != r1) { \
773 mask |= 2; \
774 t1 = jit_get_reg(CLASS_SNG); \
775 x1 = rn(t1); \
776 movr_d(x1, r1); \
777 if (r1 == r2) \
778 x2 = x1; \
779 } \
780 } \
781 else \
782 x1 = r1; \
783 if (!single_precision_p(r2)) { \
784 if (r0 != r2 && r1 != r2) { \
785 mask |= 4; \
786 t2 = jit_get_reg(CLASS_SNG); \
787 x2 = rn(t2); \
788 movr_d(x2, r2); \
789 } \
790 } \
791 else \
792 x2 = r2; \
793 CODE(x1, x2, x0); \
794 if (mask & 1) { \
795 movr_d(r0, x0); \
796 jit_unget_reg(t0); \
797 } \
798 if (mask & 2) \
799 jit_unget_reg(t1); \
800 if (mask & 4) \
801 jit_unget_reg(t2); \
802}
803
804static void
805_fop2f(jit_state_t *_jit, jit_int32_t op,
806 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
807{
808 jit_int32_t x0, t0, x1, t1, x2, t2, mask = 0;
809 if (!single_precision_p(r0)) {
810 mask |= 1;
811 t0 = jit_get_reg(CLASS_SNG);
812 x0 = rn(t0);
813 if (r0 == r1) {
814 x1 = x0;
815 movr_d(x1, r1);
816 if (r0 == r2)
817 x2 = x0;
818 }
819 else if (r0 == r2) {
820 x2 = x0;
821 movr_d(x2, r2);
822 }
823 }
824 else
825 x0 = r0;
826 if (!single_precision_p(r1)) {
827 if (r0 != r1) {
828 mask |= 2;
829 t1 = jit_get_reg(CLASS_SNG);
830 x1 = rn(t1);
831 movr_d(x1, r1);
832 if (r1 == r2)
833 x2 = x1;
834 }
835 }
836 else
837 x1 = r1;
838 if (!single_precision_p(r2)) {
839 if (r0 != r2 && r1 != r2) {
840 mask |= 4;
841 t2 = jit_get_reg(CLASS_SNG);
842 x2 = rn(t2);
843 movr_d(x2, r2);
844 }
845 }
846 else
847 x2 = r2;
848 FPop1(x0, x1, op, x2);
849 if (mask & 1) {
850 movr_d(r0, x0);
851 jit_unget_reg(t0);
852 }
853 if (mask & 2)
854 jit_unget_reg(t1);
855 if (mask & 4)
856 jit_unget_reg(t2);
857}
858# endif
859
860static void
861_fop1f(jit_state_t *_jit, jit_int32_t op,
862 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
863{
864 jit_int32_t reg;
865# if __WORDSIZE == 64
866 jit_int32_t x0, t0, x1, t1, mask = 0;
867# endif
868 reg = jit_get_reg(CLASS_SNG);
869 movi_f(rn(reg), i0);
870# if __WORDSIZE == 64
871 if (!single_precision_p(r0)) {
872 mask |= 1;
873 t0 = jit_get_reg(CLASS_SNG);
874 x0 = rn(t0);
875 if (r0 == r1) {
876 x1 = x0;
877 movr_d(x1, r1);
878 }
879 }
880 else
881 x0 = r0;
882 if (!single_precision_p(r1)) {
883 if (r0 != r1) {
884 mask |= 2;
885 t1 = jit_get_reg(CLASS_SNG);
886 x1 = rn(t1);
887 movr_d(x1, r1);
888 }
889 }
890 else
891 x1 = r1;
892 FPop1(x0, x1, op, rn(reg));
893 if (mask & 1) {
894 movr_d(r0, x0);
895 jit_unget_reg(t0);
896 }
897 if (mask & 2)
898 jit_unget_reg(t1);
899# else
900 FPop1(r0, r1, op, rn(reg));
901# endif
902 jit_unget_reg(reg);
903}
904
905static void
906_rfop1f(jit_state_t *_jit, jit_int32_t op,
907 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
908{
909 jit_int32_t reg;
910# if __WORDSIZE == 64
911 jit_int32_t x0, t0, x1, t1, mask = 0;
912# endif
913 reg = jit_get_reg(CLASS_SNG);
914 movi_f(rn(reg), i0);
915# if __WORDSIZE == 64
916 if (!single_precision_p(r0)) {
917 mask |= 1;
918 t0 = jit_get_reg(CLASS_SNG);
919 x0 = rn(t0);
920 if (r0 == r1) {
921 x1 = x0;
922 movr_d(x1, r1);
923 }
924 }
925 else
926 x0 = r0;
927 if (!single_precision_p(r1)) {
928 if (r0 != r1) {
929 mask |= 2;
930 t1 = jit_get_reg(CLASS_SNG);
931 x1 = rn(t1);
932 movr_d(x1, r1);
933 }
934 }
935 else
936 x1 = r1;
937 FPop1(x0, rn(reg), op, x1);
938 if (mask & 1) {
939 movr_d(r0, x0);
940 jit_unget_reg(t0);
941 }
942 if (mask & 2)
943 jit_unget_reg(t1);
944# else
945 FPop1(r0, rn(reg), op, r1);
946# endif
947 jit_unget_reg(reg);
948}
949
950static void
951_fop1d(jit_state_t *_jit, jit_int32_t op,
952 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
953{
954 jit_int32_t reg;
955 reg = jit_get_reg(CLASS_DBL);
956 movi_d(rn(reg), i0);
957 FPop1(r0, r1, op, rn(reg));
958 jit_unget_reg(reg);
959}
960
961static void
962_rfop1d(jit_state_t *_jit, jit_int32_t op,
963 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
964{
965 jit_int32_t reg;
966 reg = jit_get_reg(CLASS_DBL);
967 movi_d(rn(reg), i0);
968 FPop1(r0, rn(reg), op, r1);
969 jit_unget_reg(reg);
970}
971
972static void
973_extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
974{
975 stxi(BIAS(-8), _FP_REGNO, r1);
976# if __WORDSIZE == 32
977 ldxi_f(r0, _FP_REGNO, BIAS(-8));
978 FITOS(r0, r0);
979# else
980 ldxi_d(r0, _FP_REGNO, BIAS(-8));
981 if (!single_precision_p(r0)) {
982 jit_int32_t reg;
983 reg = jit_get_reg(CLASS_SNG);
984 movr_d(rn(reg), r0);
985 FXTOS(rn(reg), rn(reg));
986 movr_d(r0, rn(reg));
987 jit_unget_reg(reg);
988 }
989 else
990 FXTOS(r0, r0);
991# endif
992}
993
994static void
995_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
996{
997 jit_int32_t reg;
998 reg = jit_get_reg(CLASS_SNG);
999# if __WORDSIZE == 64
1000 if (!single_precision_p(r1)) {
1001 movr_d(rn(reg), r1);
1002 FSTOI(rn(reg), rn(reg));
1003 }
1004 else
1005# endif
1006 FSTOI(r1, rn(reg));
1007 stxi_f(BIAS(-8), _FP_REGNO, rn(reg));
1008 ldxi_i(r0, _FP_REGNO, BIAS(-8));
1009 jit_unget_reg(reg);
1010}
1011
1012# if __WORDSIZE == 64
1013static void
1014_truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1015{
1016 jit_int32_t reg;
1017 reg = jit_get_reg(CLASS_SNG);
1018# if __WORDSIZE == 64
1019 if (!single_precision_p(r1)) {
1020 movr_d(rn(reg), r1);
1021 FSTOX(rn(reg), rn(reg));
1022 }
1023 else
1024# endif
1025 FSTOX(r1, rn(reg));
1026 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1027 ldxi_l(r0, _FP_REGNO, BIAS(-8));
1028 jit_unget_reg(reg);
1029}
1030# endif
1031
1032static void
1033_fcr(jit_state_t *_jit, jit_int32_t cc,
1034 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1035{
1036# if __WORDSIZE == 64
1037 jit_int32_t x0, t0, x1, t1, mask = 0;
1038 if (!single_precision_p(r1)) {
1039 mask |= 1;
1040 t0 = jit_get_reg(CLASS_SNG);
1041 x0 = rn(t0);
1042 movr_d(x0, r1);
1043 }
1044 else
1045 x0 = r1;
1046 if (r1 == r2)
1047 x1 = x0;
1048 else if (!single_precision_p(r2)) {
1049 mask |= 2;
1050 t1 = jit_get_reg(CLASS_SNG);
1051 x1 = rn(t1);
1052 movr_d(x1, r2);
1053 }
1054 else
1055 x1 = r2;
1056 FCMPS(x0, x1);
1057 if (mask & 1)
1058 jit_unget_reg(t0);
1059 if (mask & 2)
1060 jit_unget_reg(t1);
1061# else
1062 FCMPS(r1, r2);
1063# endif
1064 FBa(cc, 3);
1065 movi(r0, 1);
1066 movi(r0, 0);
1067}
1068
1069static void
1070_fcw(jit_state_t *_jit, jit_int32_t cc,
1071 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
1072{
1073 jit_int32_t reg;
1074# if __WORDSIZE == 64
1075 jit_int32_t x0, t0, mask = 0;
1076 if (!single_precision_p(r1)) {
1077 mask |= 1;
1078 t0 = jit_get_reg(CLASS_SNG);
1079 x0 = rn(t0);
1080 movr_d(x0, r1);
1081 }
1082 else
1083 x0 = r1;
1084# endif
1085 reg = jit_get_reg(CLASS_SNG);
1086 movi_f(rn(reg), i0);
1087# if __WORDSIZE == 64
1088 FCMPS(x0, rn(reg));
1089 if (mask & 1)
1090 jit_unget_reg(t0);
1091# else
1092 FCMPS(r1, rn(reg));
1093# endif
1094 jit_unget_reg(reg);
1095 FBa(cc, 3);
1096 movi(r0, 1);
1097 movi(r0, 0);
1098}
1099
1100static void
1101_dcr(jit_state_t *_jit, jit_int32_t cc,
1102 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1103{
1104 FCMPD(r1, r2);
1105 FBa(cc, 3);
1106 movi(r0, 1);
1107 movi(r0, 0);
1108}
1109
1110static void
1111_dcw(jit_state_t *_jit, jit_int32_t cc,
1112 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
1113{
1114 jit_int32_t reg;
1115 reg = jit_get_reg(CLASS_DBL);
1116 movi_d(rn(reg), i0);
1117 FCMPD(r1, rn(reg));
1118 jit_unget_reg(reg);
1119 FBa(cc, 3);
1120 movi(r0, 1);
1121 movi(r0, 0);
1122}
1123
1124# if __WORDSIZE == 64
1125static void
1126_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1127{
1128 jit_int32_t reg;
1129 if (!single_precision_p(r0)) {
1130 reg = jit_get_reg(CLASS_SNG);
1131 LDF(r1, 0, rn(reg));
1132 movr_d(r0, rn(reg));
1133 jit_unget_reg(reg);
1134 }
1135 else
1136 LDF(r1, 0, r0);
1137}
1138# endif
1139
1140static void
1141_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1142{
1143 jit_int32_t reg;
1144 if (s13_p(i0)) {
1145# if __WORDSIZE == 64
1146 if (!single_precision_p(r0)) {
1147 reg = jit_get_reg(CLASS_SNG);
1148 LDFI(0, i0, rn(reg));
1149 movr_d(r0, rn(reg));
1150 jit_unget_reg(reg);
1151 }
1152 else
1153# endif
1154 LDFI(0, i0, r0);
1155 }
1156 else {
1157 reg = jit_get_reg(jit_class_gpr);
1158 movi(rn(reg), i0);
1159 ldr_f(r0, rn(reg));
1160 jit_unget_reg(reg);
1161 }
1162}
1163
1164# if __WORDSIZE == 64
1165static void
1166_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1167{
1168 jit_int32_t reg;
1169 if (!single_precision_p(r0)) {
1170 reg = jit_get_reg(CLASS_SNG);
1171 LDF(r1, r2, rn(reg));
1172 movr_d(r0, rn(reg));
1173 jit_unget_reg(reg);
1174 }
1175 else
1176 LDF(r1, r2, r0);
1177}
1178# endif
1179
1180static void
1181_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1182{
1183 jit_int32_t reg;
1184 if (s13_p(i0)) {
1185# if __WORDSIZE == 64
1186 if (!single_precision_p(r0)) {
1187 reg = jit_get_reg(CLASS_SNG);
1188 LDFI(r1, i0, rn(reg));
1189 movr_d(r0, rn(reg));
1190 jit_unget_reg(reg);
1191 }
1192 else
1193# endif
1194 LDFI(r1, i0, r0);
1195 }
1196 else {
1197 reg = jit_get_reg(jit_class_gpr);
1198 movi(rn(reg), i0);
1199 ldxr_f(r0, r1, rn(reg));
1200 jit_unget_reg(reg);
1201 }
1202}
1203
1204# if __WORDSIZE == 64
1205static void
1206_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1207{
1208 jit_int32_t reg;
1209 if (!single_precision_p(r1)) {
1210 reg = jit_get_reg(CLASS_SNG);
1211 movr_d(rn(reg), r1);
1212 STF(rn(reg), r0, 0);
1213 jit_unget_reg(reg);
1214 }
1215 else
1216 STF(r1, r0, 0);
1217}
1218# endif
1219
1220static void
1221_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1222{
1223 jit_int32_t reg;
1224 if (s13_p(i0)) {
1225# if __WORDSIZE == 64
1226 if (!single_precision_p(r0)) {
1227 reg = jit_get_reg(CLASS_SNG);
1228 movr_d(rn(reg), r0);
1229 STFI(rn(reg), 0, i0);
1230 jit_unget_reg(reg);
1231 }
1232 else
1233# endif
1234 STFI(r0, 0, i0);
1235 }
1236 else {
1237 reg = jit_get_reg(jit_class_gpr);
1238 movi(rn(reg), i0);
1239 str_f(rn(reg), r0);
1240 jit_unget_reg(reg);
1241 }
1242}
1243
1244# if __WORDSIZE == 64
1245static void
1246_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1247{
1248 jit_int32_t reg;
1249 if (!single_precision_p(r2)) {
1250 reg = jit_get_reg(CLASS_SNG);
1251 movr_d(rn(reg), r2);
1252 STF(rn(reg), r1, r0);
1253 jit_unget_reg(reg);
1254 }
1255 else
1256 STF(r2, r1, r0);
1257}
1258# endif
1259
1260static void
1261_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1262{
1263 jit_int32_t reg;
1264 if (s13_p(i0)) {
1265# if __WORDSIZE == 64
1266 if (!single_precision_p(r1)) {
1267 reg = jit_get_reg(CLASS_SNG);
1268 movr_d(rn(reg), r1);
1269 STFI(rn(reg), r0, i0);
1270 jit_unget_reg(reg);
1271 }
1272 else
1273# endif
1274 STFI(r1, r0, i0);
1275 }
1276 else {
1277 reg = jit_get_reg(jit_class_gpr);
1278 movi(rn(reg), i0);
1279 stxr_f(rn(reg), r0, r1);
1280 jit_unget_reg(reg);
1281 }
1282}
1283
1284static void
1285_extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1286{
1287 stxi(BIAS(-8), _FP_REGNO, r1);
1288# if __WORDSIZE == 32
1289 stxi(BIAS(-4), _FP_REGNO, 0);
1290# endif
1291 ldxi_d(r0, _FP_REGNO, BIAS(-8));
1292# if __WORDSIZE == 32
1293 FITOD(r0, r0);
1294# else
1295 FXTOD(r0, r0);
1296# endif
1297}
1298
1299static void
1300_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1301{
1302 jit_int32_t reg;
1303 reg = jit_get_reg(CLASS_SNG);
1304# if __WORDSIZE == 64
1305 if (!single_precision_p(r1)) {
1306 movr_d(rn(reg), r1);
1307 FDTOI(rn(reg), rn(reg));
1308 }
1309 else
1310# endif
1311 FDTOI(r1, rn(reg));
1312 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1313 ldxi_i(r0, _FP_REGNO, BIAS(-8));
1314 jit_unget_reg(reg);
1315}
1316
1317# if __WORDSIZE == 64
1318static void
1319_truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1320{
1321 jit_int32_t reg;
1322 reg = jit_get_reg(CLASS_DBL);
1323 FDTOX(r1, rn(reg));
1324 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1325 ldxi_l(r0, _FP_REGNO, BIAS(-8));
1326 jit_unget_reg(reg);
1327}
1328# endif
1329
1330static void
1331_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1332{
1333 jit_int32_t reg;
1334 if (s13_p(i0))
1335 LDDFI(0, i0, r0);
1336 else {
1337 reg = jit_get_reg(jit_class_gpr);
1338 movi(rn(reg), i0);
1339 ldr_d(r0, rn(reg));
1340 jit_unget_reg(reg);
1341 }
1342}
1343
1344static void
1345_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t i0)
1346{
1347 jit_int32_t reg;
1348 if (s13_p(i0))
1349 LDDFI(r1, i0, r0);
1350 else {
1351 reg = jit_get_reg(jit_class_gpr);
1352 movi(rn(reg), i0);
1353 ldxr_d(r0, r1, rn(reg));
1354 jit_unget_reg(reg);
1355 }
1356}
1357
1358static void
1359_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1360{
1361 jit_int32_t reg;
1362 if (s13_p(i0))
1363 STDFI(r0, 0, i0);
1364 else {
1365 reg = jit_get_reg(jit_class_gpr);
1366 movi(rn(reg), i0);
1367 str_d(rn(reg), r0);
1368 jit_unget_reg(reg);
1369 }
1370}
1371
1372static void
1373_stxi_d(jit_state_t *_jit, jit_int32_t i0, jit_int32_t r0, jit_int32_t r1)
1374{
1375 jit_int32_t reg;
1376 if (s13_p(i0))
1377 STDFI(r1, r0, i0);
1378 else {
1379 reg = jit_get_reg(jit_class_gpr);
1380 movi(rn(reg), i0);
1381 stxr_d(rn(reg), r0, r1);
1382 jit_unget_reg(reg);
1383 }
1384}
1385
1386static jit_word_t
1387_fbr(jit_state_t *_jit, jit_int32_t cc,
1388 jit_word_t i0, jit_int32_t r0,jit_int32_t r1)
1389{
1390# if __WORDSIZE == 64
1391 jit_int32_t x0, t0, x1, t1, mask = 0;
1392# endif
1393 jit_word_t w;
1394# if __WORDSIZE == 64
1395 if (!single_precision_p(r0)) {
1396 mask |= 1;
1397 t0 = jit_get_reg(CLASS_SNG);
1398 x0 = rn(t0);
1399 movr_d(x0, r0);
1400 }
1401 else
1402 x0 = r0;
1403 if (r0 == r1)
1404 x1 = x0;
1405 else if (!single_precision_p(r1)) {
1406 mask |= 2;
1407 t1 = jit_get_reg(CLASS_SNG);
1408 x1 = rn(t1);
1409 movr_d(x1, r1);
1410 }
1411 else
1412 x1 = r1;
1413 FCMPS(x0, x1);
1414 if (mask & 1)
1415 jit_unget_reg(t0);
1416 if (mask & 2)
1417 jit_unget_reg(t1);
1418# else
1419 FCMPS(r0, r1);
1420# endif
1421 w = _jit->pc.w;
1422 FB(cc, (i0 - w) >> 2);
1423 NOP();
1424 return (w);
1425}
1426
1427static jit_word_t
1428_fbw(jit_state_t *_jit, jit_int32_t cc,
1429 jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
1430{
1431 jit_word_t w;
1432 jit_int32_t reg;
1433# if __WORDSIZE == 64
1434 jit_int32_t x0, t0, mask = 0;
1435 if (!single_precision_p(r0)) {
1436 mask |= 1;
1437 t0 = jit_get_reg(CLASS_SNG);
1438 x0 = rn(t0);
1439 movr_d(x0, r0);
1440 }
1441 else
1442 x0 = r0;
1443# endif
1444 reg = jit_get_reg(CLASS_SNG);
1445 movi_f(rn(reg), i1);
1446# if __WORDSIZE == 64
1447 FCMPS(x0, rn(reg));
1448 if (mask & 1)
1449 jit_unget_reg(t0);
1450# else
1451 FCMPS(r0, rn(reg));
1452# endif
1453 jit_unget_reg(reg);
1454 w = _jit->pc.w;
1455 FB(cc, (i0 - w) >> 2);
1456 NOP();
1457 return (w);
1458}
1459
1460static jit_word_t
1461_dbr(jit_state_t *_jit, jit_int32_t cc,
1462 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1463{
1464 jit_word_t w;
1465 FCMPD(r0, r1);
1466 w = _jit->pc.w;
1467 FB(cc, (i0 - w) >> 2);
1468 NOP();
1469 return (w);
1470}
1471
1472static jit_word_t
1473_dbw(jit_state_t *_jit, jit_int32_t cc,
1474 jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
1475{
1476 jit_word_t w;
1477 jit_int32_t reg;
1478 reg = jit_get_reg(CLASS_DBL);
1479 movi_d(rn(reg), i1);
1480 FCMPD(r0, rn(reg));
1481 jit_unget_reg(reg);
1482 w = _jit->pc.w;
1483 FB(cc, (i0 - w) >> 2);
1484 NOP();
1485 return (w);
1486}
1487
1488static void
1489_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1490{
1491 assert(_jitc->function->self.call & jit_call_varargs);
1492
1493 /* Load argument. */
1494 ldr_d(r0, r1);
1495
1496 /* Update vararg stack pointer. */
1497 addi(r1, r1, 8);
1498}
1499#endif
ARM optimized PCSX fork