2 * Copyright (C) 2013-2023 Free Software Foundation, Inc.
4 * This file is part of GNU lightning.
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)
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.
17 * Paulo Cesar Pereira de Andrade
23 # define CLASS_SNG jit_class_fpr
24 # define CLASS_DBL jit_class_fpr
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)
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)
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)
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)
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)
171 static 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)
176 # define truncr_f(r0, r1) truncr_f_l(r0, r1)
177 # define truncr_d(r0, r1) truncr_d_l(r0, r1)
179 # define truncr_f_i(r0, r1) _truncr_f_i(_jit, r0, r1)
180 static 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)
183 static void _truncr_f_l(jit_state_t*, jit_int32_t, jit_int32_t);
185 # if __WORDSIZE == 32
186 # define extr_d_f(r0, r1) FDTOS(r1, r0)
188 # define extr_d_f(r0, r1) _extr_d_f(_jit, r0, r1)
189 static void _extr_d_f(jit_state_t*, jit_int32_t, jit_int32_t);
191 # define movi_f(r0, i0) _movi_f(_jit, r0, i0)
192 # if __WORDSIZE == 32
193 # define movr_f(r0, r1) FMOVS(r1, r0)
195 # define movr_f(r0, r1) _movr_f(_jit, r0, r1)
196 static void _movr_f(jit_state_t*, jit_int32_t, jit_int32_t);
198 static 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)
204 # define negr_f(r0, r1) _negr_f(_jit, r0, r1)
205 static void _negr_f(jit_state_t*, jit_int32_t, jit_int32_t);
206 # define absr_f(r0, r1) _absr_f(_jit, r0, r1)
207 static void _absr_f(jit_state_t*, jit_int32_t, jit_int32_t);
208 # define sqrtr_f(r0, r1) _sqrtr_f(_jit, r0, r1)
209 static void _sqrtr_f(jit_state_t*, jit_int32_t, jit_int32_t);
211 # define extr_d(r0, r1) _extr_d(_jit, r0, r1)
212 static 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)
214 static 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)
217 static void _truncr_d_l(jit_state_t*, jit_int32_t, jit_int32_t);
219 # if __WORDSIZE == 32
220 # define extr_f_d(r0, r1) FSTOD(r1, r0)
222 # define extr_f_d(r0, r1) _extr_f_d(_jit, r0, r1)
223 static void _extr_f_d(jit_state_t*, jit_int32_t, jit_int32_t);
225 # define movi_d(r0, i0) _movi_d(_jit, r0, i0)
226 static 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)
229 static void _movr_d(jit_state_t*, jit_int32_t, jit_int32_t);
230 # define negr_d(r0, r1) _negr_d(_jit, r0, r1)
231 static void _negr_d(jit_state_t*, jit_int32_t, jit_int32_t);
232 # define absr_d(r0, r1) _absr_d(_jit, r0, r1)
233 static void _absr_d(jit_state_t*, jit_int32_t, jit_int32_t);
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)
239 # define sqrtr_d(r0, r1) FSQRTD(r1, r0)
240 # define fop1f(op, r0, r1, i0) _fop1f(_jit, op, r0, r1, i0)
241 static 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)
244 static 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)
247 static 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)
250 static 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)
258 # define fop2f(op, r0, r1, r2) _fop2f(_jit, op, r0, r1, r2)
259 static 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)
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)
285 static 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)
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)
318 static 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)
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)
353 # define ldr_f(r0, r1) _ldr_f(_jit, r0, r1)
354 static void _ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
356 # define ldi_f(r0, i0) _ldi_f(_jit, r0, i0)
357 static 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)
361 # define ldxr_f(r0, r1, r2) _ldxr_f(_jit, r0, r1, r2)
362 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
364 # define ldxi_f(r0, r1, i0) _ldxi_f(_jit, r0, r1, i0)
365 static 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)
369 # define str_f(r0, r1) _str_f(_jit, r0, r1)
370 static void _str_f(jit_state_t*,jit_int32_t,jit_int32_t);
372 # define sti_f(r0, i0) _sti_f(_jit, r0, i0)
373 static 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)
377 # define stxr_f(r0, r1, r2) _stxr_f(_jit, r0, r1, r2)
378 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
380 # define stxi_f(r0, r1, i0) _stxi_f(_jit, r0, r1, i0)
381 static 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)
384 static 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)
387 static 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)
390 static 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)
393 static 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)
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)
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)
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)
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)
463 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
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)
472 # if __WORDSIZE == 64
474 assert(rd <= 63 && (rd & 1) == 0);
478 assert(rs1 <= 63 && (rs1 & 1) == 0);
482 assert(rs2 <= 63 && (rs2 & 1) == 0);
486 assert(!(rd & 0xffffffe0));
487 assert(!(op3 & 0xffffffc0));
488 assert(!(rs1 & 0xffffffe0));
489 assert(!(opf & 0xfffffe00));
490 assert(!(rs2 & 0xffffffe0));
500 # if __WORDSIZE == 64
501 /* Handle the special case of using all float registers, as exercised
504 * putargr_f JIT_F0 $ARG
505 * where JIT_F0 is %f32 and $ARG is %f31 and if %f30 (the mapping for %f31)
506 * is live, the jit_get_reg() call might return %f30, but, because it is
507 * live, will spill/reload it, generating assembly:
509 * std %f30, [ %fp + OFFS ]
512 * ldd [ %fp + OFFS ], %f30
514 * what basically becomes a noop as it restores the old value.
516 #define get_sng_reg(u) _get_sng_reg(_jit, u)
518 _get_sng_reg(jit_state_t *_jit, jit_int32_t r0)
520 jit_int32_t reg, tmp;
521 /* Attempt to get a nospill register */
522 reg = jit_get_reg(CLASS_SNG | jit_class_nospill | jit_class_chk);
523 if (reg == JIT_NOREG) {
524 /* Will need to spill, so allow spilling it. */
525 reg = jit_get_reg(CLASS_SNG);
526 /* If the special condition happens, allocate another one.
527 * This will generate uglier machine code (code for floats
528 * is already ugly), but will work, but doing a double
529 * spill/reload; the first one being a noop. */
530 if (rn(reg) == r0 - 1) {
532 reg = jit_get_reg(CLASS_SNG);
540 _movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
544 if (single_precision_p(r0)) {
545 if (single_precision_p(r1))
548 t1 = get_sng_reg(r0);
555 if (single_precision_p(r1)) {
556 t0 = get_sng_reg(r0);
562 t1 = get_sng_reg(r0);
564 FMOVS(rn(t1), rn(t1));
573 _negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
576 if (single_precision_p(r0)) {
577 if (single_precision_p(r1))
580 t1 = jit_get_reg(CLASS_SNG);
587 if (single_precision_p(r1)) {
588 t0 = jit_get_reg(CLASS_SNG);
594 t1 = jit_get_reg(CLASS_SNG);
596 FNEGS(rn(t1), rn(t1));
604 _absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
607 if (single_precision_p(r0)) {
608 if (single_precision_p(r1))
611 t1 = jit_get_reg(CLASS_SNG);
618 if (single_precision_p(r1)) {
619 t0 = jit_get_reg(CLASS_SNG);
625 t1 = jit_get_reg(CLASS_SNG);
627 FABSS(rn(t1), rn(t1));
635 _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
638 if (single_precision_p(r0)) {
639 if (single_precision_p(r1))
642 t1 = jit_get_reg(CLASS_SNG);
649 if (single_precision_p(r1)) {
650 t0 = jit_get_reg(CLASS_SNG);
656 t1 = jit_get_reg(CLASS_SNG);
658 FSQRTS(rn(t1), rn(t1));
666 # if __WORDSIZE == 64
668 _extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
671 if (!single_precision_p(r0)) {
672 reg = jit_get_reg(CLASS_SNG);
684 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
692 if (_jitc->no_data) {
694 reg = jit_get_reg(jit_class_gpr);
695 movi(rn(reg), data.i & 0xffffffff);
696 stxi_i(BIAS(-8), _FP_REGNO, rn(reg));
698 ldxi_f(r0, _FP_REGNO, BIAS(-8));
701 ldi_f(r0, (jit_word_t)i0);
704 # if __WORDSIZE == 64
706 _extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
709 if (!single_precision_p(r1)) {
710 reg = jit_get_reg(CLASS_SNG);
721 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
724 # if __WORDSIZE == 32
733 if (_jitc->no_data) {
735 reg = jit_get_reg(jit_class_gpr);
736 # if __WORDSIZE == 32
737 movi(rn(reg), data.i[0]);
739 movi(rn(reg), data.w);
741 stxi(BIAS(-8), _FP_REGNO, rn(reg));
742 # if __WORDSIZE == 32
743 movi(rn(reg), data.i[1]);
744 stxi_i(BIAS(-4), _FP_REGNO, rn(reg));
747 ldxi_d(r0, _FP_REGNO, BIAS(-8));
750 ldi_d(r0, (jit_word_t)i0);
753 # if __WORDSIZE == 32
755 _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
761 FMOVS(r1 + 1, r0 + 1);
766 _negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
772 FMOVS(r1 + 1, r0 + 1);
776 _absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
782 FMOVS(r1 + 1, r0 + 1);
786 # if __WORDSIZE == 64
787 # define single_rrr(NAME, CODE) \
789 NAME(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) \
791 jit_int32_t x0, t0, x1, t1, x2, t2, mask = 0; \
792 if (!single_precision_p(r0)) { \
794 t0 = jit_get_reg(CLASS_SNG); \
802 else if (r0 == r2) { \
809 if (!single_precision_p(r1)) { \
812 t1 = jit_get_reg(CLASS_SNG); \
821 if (!single_precision_p(r2)) { \
822 if (r0 != r2 && r1 != r2) { \
824 t2 = jit_get_reg(CLASS_SNG); \
843 _fop2f(jit_state_t *_jit, jit_int32_t op,
844 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
846 jit_int32_t x0, t0, x1, t1, x2, t2, mask = 0;
847 if (!single_precision_p(r0)) {
849 t0 = jit_get_reg(CLASS_SNG);
864 if (!single_precision_p(r1)) {
867 t1 = jit_get_reg(CLASS_SNG);
876 if (!single_precision_p(r2)) {
877 if (r0 != r2 && r1 != r2) {
879 t2 = jit_get_reg(CLASS_SNG);
886 FPop1(x0, x1, op, x2);
899 _fop1f(jit_state_t *_jit, jit_int32_t op,
900 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
903 # if __WORDSIZE == 64
904 jit_int32_t x0, t0, x1, t1, mask = 0;
906 reg = jit_get_reg(CLASS_SNG);
908 # if __WORDSIZE == 64
909 if (!single_precision_p(r0)) {
911 t0 = jit_get_reg(CLASS_SNG);
920 if (!single_precision_p(r1)) {
923 t1 = jit_get_reg(CLASS_SNG);
930 FPop1(x0, x1, op, rn(reg));
938 FPop1(r0, r1, op, rn(reg));
944 _rfop1f(jit_state_t *_jit, jit_int32_t op,
945 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
948 # if __WORDSIZE == 64
949 jit_int32_t x0, t0, x1, t1, mask = 0;
951 reg = jit_get_reg(CLASS_SNG);
953 # if __WORDSIZE == 64
954 if (!single_precision_p(r0)) {
956 t0 = jit_get_reg(CLASS_SNG);
965 if (!single_precision_p(r1)) {
968 t1 = jit_get_reg(CLASS_SNG);
975 FPop1(x0, rn(reg), op, x1);
983 FPop1(r0, rn(reg), op, r1);
989 _fop1d(jit_state_t *_jit, jit_int32_t op,
990 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
993 reg = jit_get_reg(CLASS_DBL);
995 FPop1(r0, r1, op, rn(reg));
1000 _rfop1d(jit_state_t *_jit, jit_int32_t op,
1001 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
1004 reg = jit_get_reg(CLASS_DBL);
1005 movi_d(rn(reg), i0);
1006 FPop1(r0, rn(reg), op, r1);
1011 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1013 stxi(BIAS(-8), _FP_REGNO, r1);
1014 # if __WORDSIZE == 32
1015 ldxi_f(r0, _FP_REGNO, BIAS(-8));
1018 ldxi_d(r0, _FP_REGNO, BIAS(-8));
1019 if (!single_precision_p(r0)) {
1021 reg = jit_get_reg(CLASS_SNG);
1022 movr_d(rn(reg), r0);
1023 FXTOS(rn(reg), rn(reg));
1024 movr_d(r0, rn(reg));
1033 _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1036 reg = jit_get_reg(CLASS_SNG);
1037 # if __WORDSIZE == 64
1038 if (!single_precision_p(r1)) {
1039 movr_d(rn(reg), r1);
1040 FSTOI(rn(reg), rn(reg));
1045 stxi_f(BIAS(-8), _FP_REGNO, rn(reg));
1046 ldxi_i(r0, _FP_REGNO, BIAS(-8));
1050 # if __WORDSIZE == 64
1052 _truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1055 reg = jit_get_reg(CLASS_SNG);
1056 # if __WORDSIZE == 64
1057 if (!single_precision_p(r1)) {
1058 movr_d(rn(reg), r1);
1059 FSTOX(rn(reg), rn(reg));
1064 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1065 ldxi_l(r0, _FP_REGNO, BIAS(-8));
1071 _fcr(jit_state_t *_jit, jit_int32_t cc,
1072 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1074 # if __WORDSIZE == 64
1075 jit_int32_t x0, t0, x1, t1, mask = 0;
1076 if (!single_precision_p(r1)) {
1078 t0 = jit_get_reg(CLASS_SNG);
1086 else if (!single_precision_p(r2)) {
1088 t1 = jit_get_reg(CLASS_SNG);
1108 _fcw(jit_state_t *_jit, jit_int32_t cc,
1109 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
1112 # if __WORDSIZE == 64
1113 jit_int32_t x0, t0, mask = 0;
1114 if (!single_precision_p(r1)) {
1116 t0 = jit_get_reg(CLASS_SNG);
1123 reg = jit_get_reg(CLASS_SNG);
1124 movi_f(rn(reg), i0);
1125 # if __WORDSIZE == 64
1139 _dcr(jit_state_t *_jit, jit_int32_t cc,
1140 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1149 _dcw(jit_state_t *_jit, jit_int32_t cc,
1150 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
1153 reg = jit_get_reg(CLASS_DBL);
1154 movi_d(rn(reg), i0);
1162 # if __WORDSIZE == 64
1164 _ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1167 if (!single_precision_p(r0)) {
1168 reg = jit_get_reg(CLASS_SNG);
1169 LDF(r1, 0, rn(reg));
1170 movr_d(r0, rn(reg));
1179 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1183 # if __WORDSIZE == 64
1184 if (!single_precision_p(r0)) {
1185 reg = jit_get_reg(CLASS_SNG);
1186 LDFI(0, i0, rn(reg));
1187 movr_d(r0, rn(reg));
1195 reg = jit_get_reg(jit_class_gpr);
1202 # if __WORDSIZE == 64
1204 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1207 if (!single_precision_p(r0)) {
1208 reg = jit_get_reg(CLASS_SNG);
1209 LDF(r1, r2, rn(reg));
1210 movr_d(r0, rn(reg));
1219 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1223 # if __WORDSIZE == 64
1224 if (!single_precision_p(r0)) {
1225 reg = jit_get_reg(CLASS_SNG);
1226 LDFI(r1, i0, rn(reg));
1227 movr_d(r0, rn(reg));
1235 reg = jit_get_reg(jit_class_gpr);
1237 ldxr_f(r0, r1, rn(reg));
1242 # if __WORDSIZE == 64
1244 _str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1247 if (!single_precision_p(r1)) {
1248 reg = jit_get_reg(CLASS_SNG);
1249 movr_d(rn(reg), r1);
1250 STF(rn(reg), r0, 0);
1259 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1263 # if __WORDSIZE == 64
1264 if (!single_precision_p(r0)) {
1265 reg = jit_get_reg(CLASS_SNG);
1266 movr_d(rn(reg), r0);
1267 STFI(rn(reg), 0, i0);
1275 reg = jit_get_reg(jit_class_gpr);
1282 # if __WORDSIZE == 64
1284 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1287 if (!single_precision_p(r2)) {
1288 reg = jit_get_reg(CLASS_SNG);
1289 movr_d(rn(reg), r2);
1290 STF(rn(reg), r1, r0);
1299 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1303 # if __WORDSIZE == 64
1304 if (!single_precision_p(r1)) {
1305 reg = jit_get_reg(CLASS_SNG);
1306 movr_d(rn(reg), r1);
1307 STFI(rn(reg), r0, i0);
1315 reg = jit_get_reg(jit_class_gpr);
1317 stxr_f(rn(reg), r0, r1);
1323 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1325 stxi(BIAS(-8), _FP_REGNO, r1);
1326 # if __WORDSIZE == 32
1327 stxi(BIAS(-4), _FP_REGNO, 0);
1329 ldxi_d(r0, _FP_REGNO, BIAS(-8));
1330 # if __WORDSIZE == 32
1338 _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1341 reg = jit_get_reg(CLASS_SNG);
1342 # if __WORDSIZE == 64
1343 if (!single_precision_p(r1)) {
1344 movr_d(rn(reg), r1);
1345 FDTOI(rn(reg), rn(reg));
1350 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1351 ldxi_i(r0, _FP_REGNO, BIAS(-8));
1355 # if __WORDSIZE == 64
1357 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1360 reg = jit_get_reg(CLASS_DBL);
1362 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1363 ldxi_l(r0, _FP_REGNO, BIAS(-8));
1369 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1375 reg = jit_get_reg(jit_class_gpr);
1383 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t i0)
1389 reg = jit_get_reg(jit_class_gpr);
1391 ldxr_d(r0, r1, rn(reg));
1397 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1403 reg = jit_get_reg(jit_class_gpr);
1411 _stxi_d(jit_state_t *_jit, jit_int32_t i0, jit_int32_t r0, jit_int32_t r1)
1417 reg = jit_get_reg(jit_class_gpr);
1419 stxr_d(rn(reg), r0, r1);
1425 _fbr(jit_state_t *_jit, jit_int32_t cc,
1426 jit_word_t i0, jit_int32_t r0,jit_int32_t r1)
1428 # if __WORDSIZE == 64
1429 jit_int32_t x0, t0, x1, t1, mask = 0;
1432 # if __WORDSIZE == 64
1433 if (!single_precision_p(r0)) {
1435 t0 = jit_get_reg(CLASS_SNG);
1443 else if (!single_precision_p(r1)) {
1445 t1 = jit_get_reg(CLASS_SNG);
1460 FB(cc, (i0 - w) >> 2);
1466 _fbw(jit_state_t *_jit, jit_int32_t cc,
1467 jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
1471 # if __WORDSIZE == 64
1472 jit_int32_t x0, t0, mask = 0;
1473 if (!single_precision_p(r0)) {
1475 t0 = jit_get_reg(CLASS_SNG);
1482 reg = jit_get_reg(CLASS_SNG);
1483 movi_f(rn(reg), i1);
1484 # if __WORDSIZE == 64
1493 FB(cc, (i0 - w) >> 2);
1499 _dbr(jit_state_t *_jit, jit_int32_t cc,
1500 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1505 FB(cc, (i0 - w) >> 2);
1511 _dbw(jit_state_t *_jit, jit_int32_t cc,
1512 jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
1516 reg = jit_get_reg(CLASS_DBL);
1517 movi_d(rn(reg), i1);
1521 FB(cc, (i0 - w) >> 2);
1527 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1529 assert(_jitc->function->self.call & jit_call_varargs);
1531 /* Load argument. */
1532 #if __WORDSIZE == 64
1536 ldxi_f(r0 + 1, r1, 4);
1539 /* Update vararg stack pointer. */