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 FPop3(rd, rs1, rs3, op5, rs2) f4f(rd, 55, rs1, rs3, op5, rs2)
97 # define f4f(rd,op3,rs1,rs3,op5,rs2) _f4f(_jit, rd,op3,rs1,rs3,op5,rs2)
99 _f4f(jit_state_t*,jit_int32_t,jit_int32_t,
100 jit_int32_t, jit_int32_t,jit_int32_t,jit_int32_t);
101 # define FITOS(rs2, rd) FPop1(rd, 0, 196, rs2)
102 # define FITOD(rs2, rd) FPop1(rd, 0, 200, rs2)
103 # define FITOQ(rs2, rd) FPop1(rd, 0, 204, rs2)
104 # if __WORDSIZE == 64
105 # define FXTOS(rs2, rd) FPop1(rd, 0, 132, rs2)
106 # define FXTOD(rs2, rd) FPop1(rd, 0, 136, rs2)
107 # define FxTOQ(rs2, rd) FPop1(rd, 0, 140, rs2)
109 # define FSTOI(rs2, rd) FPop1(rd, 0, 209, rs2)
110 # define FDTOI(rs2, rd) FPop1(rd, 0, 210, rs2)
111 # define FQTOI(rs2, rd) FPop1(rd, 0, 211, rs2)
112 # define FSTOX(rs2, rd) FPop1(rd, 0, 129, rs2)
113 # define FDTOX(rs2, rd) FPop1(rd, 0, 130, rs2)
114 # define FQTOX(rs2, rd) FPop1(rd, 0, 131, rs2)
115 # define FSTOD(rs2, rd) FPop1(rd, 0, 201, rs2)
116 # define FSTOQ(rs2, rd) FPop1(rd, 0, 205, rs2)
117 # define FDTOS(rs2, rd) FPop1(rd, 0, 198, rs2)
118 # define FDTOQ(rs2, rd) FPop1(rd, 0, 206, rs2)
119 # define FQTOS(rs2, rd) FPop1(rd, 0, 199, rs2)
120 # define FQTOD(rs2, rd) FPop1(rd, 0, 203, rs2)
121 # define FMOVS(rs2, rd) FPop1(rd, 0, 1, rs2)
122 # define FMOVD(rs2, rd) FPop1(rd, 0, 2, rs2)
123 # define FMOVQ(rs2, rd) FPop1(rd, 0, 3, rs2)
124 # define FNEGS(rs2, rd) FPop1(rd, 0, 5, rs2)
125 # define FNEGD(rs2, rd) FPop1(rd, 0, 6, rs2)
126 # define FNEGQ(rs2, rd) FPop1(rd, 0, 7, rs2)
127 # define FABSS(rs2, rd) FPop1(rd, 0, 9, rs2)
128 # define FABSD(rs2, rd) FPop1(rd, 0, 10, rs2)
129 # define FABSQ(rs2, rd) FPop1(rd, 0, 11, rs2)
130 # define FSQRTS(rs2, rd) FPop1(rd, 0, 41, rs2)
131 # define FSQRTD(rs2, rd) FPop1(rd, 0, 42, rs2)
132 # define FSQRTQ(rs2, rd) FPop1(rd, 0, 43, rs2)
133 # define SPARC_FADDS 65
134 # define SPARC_FADDD 66
135 # define SPARC_FADDQ 67
136 # define SPARC_FSUBS 69
137 # define SPARC_FSUBD 70
138 # define SPARC_FSUBQ 71
139 # define SPARC_FMULS 73
140 # define SPARC_FMULD 74
141 # define SPARC_FMULQ 75
142 # define SPARC_FSMULD 105
143 # define SPARC_FDMULQ 110
144 # define SPARC_FDIVS 77
145 # define SPARC_FDIVD 78
146 # define SPARC_FDIVQ 79
147 # define SPARC_FMADDS 1
148 # define SPARC_FMADDD 2
149 # define SPARC_FMSUBS 5
150 # define SPARC_FMSUBD 6
151 # define SPARC_FNMSUBS 9
152 # define SPARC_FNMSUBD 10
153 # define SPARC_FNMADDS 13
154 # define SPARC_FNMADDD 14
155 # define FMADDS(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMADDS, rs2)
156 # define FMADDD(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMADDD, rs2)
157 # define FMSUBS(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMSUBS, rs2)
158 # define FMSUBD(rs1, rs2, rs3, rd) f4f(rd, 55, rs1, rs3, SPARC_FMSUBD, rs2)
159 # define FNMSUBS(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMSUBS,rs2)
160 # define FNMSUBD(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMSUBD,rs2)
161 # define FNMADDS(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMADDS,rs2)
162 # define FNMADDD(rs1, rs2, rs3,rd) f4f(rd, 55, rs1, rs3, SPARC_FNMADDD,rs2)
163 # define FADDS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDS, rs2)
164 # define FADDD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDD, rs2)
165 # define FADDQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FADDQ, rs2)
166 # define FSUBS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBS, rs2)
167 # define FSUBD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBD, rs2)
168 # define FSUBQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSUBQ, rs2)
169 # define FMULS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULS, rs2)
170 # define FMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULD, rs2)
171 # define FMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FMULQ, rs2)
172 # define FSMULD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FSMULD, rs2)
173 # define FDMULQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDMULQ, rs2)
174 # define FDIVS(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVS, rs2)
175 # define FDIVD(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVD, rs2)
176 # define FDIVQ(rs1, rs2, rd) FPop1(rd, rs1, SPARC_FDIVQ, rs2)
177 # define SPARC_FCMPS 81
178 # define SPARC_FCMPD 82
179 # define SPARC_FCMPQ 83
180 # define SPARC_FCMPES 85
181 # define SPARC_FCMPED 86
182 # define SPARC_FCMPEQ 87
183 # define FCMPS(rs1, rs2) FPop2(0, rs1, SPARC_FCMPS, rs2)
184 # define FCMPD(rs1, rs2) FPop2(0, rs1, SPARC_FCMPD, rs2)
185 # define FCMPQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPQ, rs2)
186 # define FCMPES(rs1, rs2) FPop2(0, rs1, SPARC_FCMPES, rs2)
187 # define FCMPED(rs1, rs2) FPop2(0, rs1, SPARC_FCMPED, rs2)
188 # define FCMPEQ(rs1, rs2) FPop2(0, rs1, SPARC_FCMPEQ, rs2)
189 # define CPop1(rd, rs1, opc, rs2) f3f(rd, 54, rs1, opf, rs2)
190 # define CPop2(rd, rs1, opc, rs2) f3f(rd, 55, rs1, opf, rs2)
191 # define extr_f(r0, r1) _extr_f(_jit, r0, r1)
192 static void _extr_f(jit_state_t*, jit_int32_t, jit_int32_t);
193 # if __WORDSIZSE == 32
194 # define truncr_f(r0, r1) truncr_f_i(r0, r1)
195 # define truncr_d(r0, r1) truncr_d_i(r0, r1)
197 # define truncr_f(r0, r1) truncr_f_l(r0, r1)
198 # define truncr_d(r0, r1) truncr_d_l(r0, r1)
200 # define truncr_f_i(r0, r1) _truncr_f_i(_jit, r0, r1)
201 static void _truncr_f_i(jit_state_t*, jit_int32_t, jit_int32_t);
202 # if __WORDSIZE == 64
203 # define truncr_f_l(r0, r1) _truncr_f_l(_jit, r0, r1)
204 static void _truncr_f_l(jit_state_t*, jit_int32_t, jit_int32_t);
206 # if __WORDSIZE == 32
207 # define extr_d_f(r0, r1) FDTOS(r1, r0)
209 # define extr_d_f(r0, r1) _extr_d_f(_jit, r0, r1)
210 static void _extr_d_f(jit_state_t*, jit_int32_t, jit_int32_t);
212 # define movi_f(r0, i0) _movi_f(_jit, r0, i0)
213 # if __WORDSIZE == 32
214 # define movr_f(r0, r1) FMOVS(r1, r0)
216 # define movr_f(r0, r1) _movr_f(_jit, r0, r1)
217 static void _movr_f(jit_state_t*, jit_int32_t, jit_int32_t);
219 static void _movi_f(jit_state_t*, jit_int32_t, jit_float32_t*);
220 # define movi_w_f(r0, i0) _movi_w_f(_jit, r0, i0)
221 static void _movi_w_f(jit_state_t*, jit_int32_t, jit_word_t);
222 # if __WORDSIZE == 32
223 # define negr_f(r0, r1) FNEGS(r1, r0)
224 # define absr_f(r0, r1) FABSS(r1, r0)
225 # define sqrtr_f(r0, r1) FSQRTS(r1, r0)
227 # define negr_f(r0, r1) _negr_f(_jit, r0, r1)
228 static void _negr_f(jit_state_t*, jit_int32_t, jit_int32_t);
229 # define absr_f(r0, r1) _absr_f(_jit, r0, r1)
230 static void _absr_f(jit_state_t*, jit_int32_t, jit_int32_t);
231 # define sqrtr_f(r0, r1) _sqrtr_f(_jit, r0, r1)
232 static void _sqrtr_f(jit_state_t*, jit_int32_t, jit_int32_t);
234 # if __WORDSIZE == 32
235 # define fmar_f(r0, r1, r2, r3) FMADDS(r1, r2, r3, r0)
236 # define fmsr_f(r0, r1, r2, r3) FMSUBS(r1, r2, r3, r0)
237 # define fmar_d(r0, r1, r2, r3) FMADDD(r1, r2, r3, r0)
238 # define fmsr_d(r0, r1, r2, r3) FMSUBD(r1, r2, r3, r0)
239 # define fnmar_f(r0, r1, r2, r3) FNMADDS(r1, r2, r3, r0)
240 # define fnmsr_f(r0, r1, r2, r3) FNMSUBS(r1, r2, r3, r0)
241 # define fnmar_d(r0, r1, r2, r3) FNMADDD(r1, r2, r3, r0)
242 # define fnmsr_d(r0, r1, r2, r3) FNMSUBD(r1, r2, r3, r0)
244 # define fop3f(op, r0, r1, r2, r3) _fop3f(_jit, op, r0, r1, r2, r3)
245 static void _fop3f(jit_state_t*, jit_int32_t, jit_int32_t,
246 jit_int32_t, jit_int32_t, jit_int32_t);
247 # define fmar_f(r0, r1, r2, r3) fop3f(SPARC_FMADDS, r0, r1, r2, r3)
248 # define fmsr_f(r0, r1, r2, r3) fop3f(SPARC_FMSUBS, r0, r1, r2, r3)
249 # define fmar_d(r0, r1, r2, r3) fop3f(SPARC_FMADDD, r0, r1, r2, r3)
250 # define fmsr_d(r0, r1, r2, r3) fop3f(SPARC_FMSUBD, r0, r1, r2, r3)
251 # define fnmar_f(r0, r1, r2, r3) fop3f(SPARC_FNMADDS, r0, r1, r2, r3)
252 # define fnmsr_f(r0, r1, r2, r3) fop3f(SPARC_FNMSUBS, r0, r1, r2, r3)
253 # define fnmar_d(r0, r1, r2, r3) fop3f(SPARC_FNMADDD, r0, r1, r2, r3)
254 # define fnmsr_d(r0, r1, r2, r3) fop3f(SPARC_FNMSUBD, r0, r1, r2, r3)
256 # define extr_d(r0, r1) _extr_d(_jit, r0, r1)
257 static void _extr_d(jit_state_t*, jit_int32_t, jit_int32_t);
258 # define truncr_d_i(r0, r1) _truncr_d_i(_jit, r0, r1)
259 static void _truncr_d_i(jit_state_t*, jit_int32_t, jit_int32_t);
260 # if __WORDSIZE == 64
261 # define truncr_d_l(r0, r1) _truncr_d_l(_jit, r0, r1)
262 static void _truncr_d_l(jit_state_t*, jit_int32_t, jit_int32_t);
264 # if __WORDSIZE == 32
265 # define extr_f_d(r0, r1) FSTOD(r1, r0)
267 # define extr_f_d(r0, r1) _extr_f_d(_jit, r0, r1)
268 static void _extr_f_d(jit_state_t*, jit_int32_t, jit_int32_t);
270 # define movi_d(r0, i0) _movi_d(_jit, r0, i0)
271 static void _movi_d(jit_state_t*, jit_int32_t, jit_float64_t*);
272 # if __WORDSIZE == 32
273 # define movi_ww_d(r0, i0, i1) _movi_ww_d(_jit, r0, i0, i1)
274 static void _movi_ww_d(jit_state_t*, jit_int32_t, jit_word_t, jit_word_t);
275 # define movr_d(r0, r1) _movr_d(_jit, r0, r1)
276 static void _movr_d(jit_state_t*, jit_int32_t, jit_int32_t);
277 # define negr_d(r0, r1) _negr_d(_jit, r0, r1)
278 static void _negr_d(jit_state_t*, jit_int32_t, jit_int32_t);
279 # define absr_d(r0, r1) _absr_d(_jit, r0, r1)
280 static void _absr_d(jit_state_t*, jit_int32_t, jit_int32_t);
282 # define movr_d(r0, r1) FMOVD(r1, r0)
283 # define movi_w_d(r0, i0) _movi_w_d(_jit, r0, i0)
284 static void _movi_w_d(jit_state_t*, jit_int32_t, jit_word_t);
285 # define negr_d(r0, r1) FNEGD(r1, r0)
286 # define absr_d(r0, r1) FABSD(r1, r0)
288 # define sqrtr_d(r0, r1) FSQRTD(r1, r0)
289 # define fop1f(op, r0, r1, i0) _fop1f(_jit, op, r0, r1, i0)
290 static void _fop1f(jit_state_t*,jit_int32_t,
291 jit_int32_t,jit_int32_t,jit_float32_t*);
292 # define rfop1f(op, r0, r1, i0) _rfop1f(_jit, op, r0, r1, i0)
293 static void _rfop1f(jit_state_t*,jit_int32_t,
294 jit_int32_t,jit_int32_t,jit_float32_t*);
295 # define fop1d(op, r0, r1, i0) _fop1d(_jit, op, r0, r1, i0)
296 static void _fop1d(jit_state_t*,jit_int32_t,
297 jit_int32_t,jit_int32_t,jit_float64_t*);
298 # define rfop1d(op, r0, r1, i0) _rfop1d(_jit, op, r0, r1, i0)
299 static void _rfop1d(jit_state_t*,jit_int32_t,
300 jit_int32_t,jit_int32_t,jit_float64_t*);
301 # if __WORDSIZE == 32
302 # define addr_f(r0, r1, r2) FADDS(r1, r2, r0)
303 # define subr_f(r0, r1, r2) FSUBS(r1, r2, r0)
304 # define mulr_f(r0, r1, r2) FMULS(r1, r2, r0)
305 # define divr_f(r0, r1, r2) FDIVS(r1, r2, r0)
307 # define fop2f(op, r0, r1, r2) _fop2f(_jit, op, r0, r1, r2)
308 static void _fop2f(jit_state_t*, jit_int32_t,
309 jit_int32_t, jit_int32_t, jit_int32_t);
310 # define addr_f(r0, r1, r2) fop2f(SPARC_FADDS, r0, r1, r2)
311 # define subr_f(r0, r1, r2) fop2f(SPARC_FSUBS, r0, r1, r2)
312 # define mulr_f(r0, r1, r2) fop2f(SPARC_FMULS, r0, r1, r2)
313 # define divr_f(r0, r1, r2) fop2f(SPARC_FDIVS, r0, r1, r2)
315 # define addi_f(r0, r1, i0) fop1f(SPARC_FADDS, r0, r1, i0)
316 # define subi_f(r0, r1, i0) fop1f(SPARC_FSUBS, r0, r1, i0)
317 # define rsbr_f(r0, r1, r2) subr_f(r0, r2, r1)
318 # define rsbi_f(r0, r1, i0) rfop1f(SPARC_FSUBS, r0, r1, i0)
319 # define rsbr_d(r0, r1, r2) subr_d(r0, r2, r1)
320 # define rsbi_d(r0, r1, i0) rfop1d(SPARC_FSUBD, r0, r1, i0)
321 # define muli_f(r0, r1, i0) fop1f(SPARC_FMULS, r0, r1, i0)
322 # define divi_f(r0, r1, i0) fop1f(SPARC_FDIVS, r0, r1, i0)
323 # define addr_d(r0, r1, r2) FADDD(r1, r2, r0)
324 # define addi_d(r0, r1, i0) fop1d(SPARC_FADDD, r0, r1, i0)
325 # define subr_d(r0, r1, r2) FSUBD(r1, r2, r0)
326 # define subi_d(r0, r1, i0) fop1d(SPARC_FSUBD, r0, r1, i0)
327 # define rsbr_d(r0, r1, r2) subr_d(r0, r2, r1)
328 # define rsbi_d(r0, r1, i0) rfop1d(SPARC_FSUBD, r0, r1, i0)
329 # define mulr_d(r0, r1, r2) FMULD(r1, r2, r0)
330 # define muli_d(r0, r1, i0) fop1d(SPARC_FMULD, r0, r1, i0)
331 # define divr_d(r0, r1, r2) FDIVD(r1, r2, r0)
332 # define divi_d(r0, r1, i0) fop1d(SPARC_FDIVD, r0, r1, i0)
333 #define fcr(cc, r0, r1, r2) _fcr(_jit, cc, r0, r1, r2)
334 static void _fcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
335 #define fcw(cc, r0, r1, i0) _fcw(_jit, cc, r0, r1, i0)
337 _fcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float32_t*);
338 # define ltr_f(r0, r1, r2) fcr(SPARC_FBL, r0, r1, r2)
339 # define lti_f(r0, r1, i0) fcw(SPARC_FBL, r0, r1, i0)
340 # define ler_f(r0, r1, r2) fcr(SPARC_FBLE, r0, r1, r2)
341 # define lei_f(r0, r1, i0) fcw(SPARC_FBLE, r0, r1, i0)
342 # define eqr_f(r0, r1, r2) fcr(SPARC_FBE, r0, r1, r2)
343 # define eqi_f(r0, r1, i0) fcw(SPARC_FBE, r0, r1, i0)
344 # define ger_f(r0, r1, r2) fcr(SPARC_FBGE, r0, r1, r2)
345 # define gei_f(r0, r1, i0) fcw(SPARC_FBGE, r0, r1, i0)
346 # define gtr_f(r0, r1, r2) fcr(SPARC_FBG, r0, r1, r2)
347 # define gti_f(r0, r1, i0) fcw(SPARC_FBG, r0, r1, i0)
348 # define ner_f(r0, r1, r2) fcr(SPARC_FBNE, r0, r1, r2)
349 # define nei_f(r0, r1, i0) fcw(SPARC_FBNE, r0, r1, i0)
350 # define unltr_f(r0, r1, r2) fcr(SPARC_FBUL, r0, r1, r2)
351 # define unlti_f(r0, r1, i0) fcw(SPARC_FBUL, r0, r1, i0)
352 # define unler_f(r0, r1, r2) fcr(SPARC_FBULE, r0, r1, r2)
353 # define unlei_f(r0, r1, i0) fcw(SPARC_FBULE, r0, r1, i0)
354 # define uneqr_f(r0, r1, r2) fcr(SPARC_FBUE, r0, r1, r2)
355 # define uneqi_f(r0, r1, i0) fcw(SPARC_FBUE, r0, r1, i0)
356 # define unger_f(r0, r1, r2) fcr(SPARC_FBUGE, r0, r1, r2)
357 # define ungei_f(r0, r1, i0) fcw(SPARC_FBUGE, r0, r1, i0)
358 # define ungtr_f(r0, r1, r2) fcr(SPARC_FBUG, r0, r1, r2)
359 # define ungti_f(r0, r1, i0) fcw(SPARC_FBUG, r0, r1, i0)
360 # define ltgtr_f(r0, r1, r2) fcr(SPARC_FBLG, r0, r1, r2)
361 # define ltgti_f(r0, r1, i0) fcw(SPARC_FBLG, r0, r1, i0)
362 # define ordr_f(r0, r1, r2) fcr(SPARC_FBO, r0, r1, r2)
363 # define ordi_f(r0, r1, i0) fcw(SPARC_FBO, r0, r1, i0)
364 # define unordr_f(r0, r1, r2) fcr(SPARC_FBU, r0, r1, r2)
365 # define unordi_f(r0, r1, i0) fcw(SPARC_FBU, r0, r1, i0)
366 #define dcr(cc, r0, r1, r2) _dcr(_jit, cc, r0, r1, r2)
367 static void _dcr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
368 #define dcw(cc, r0, r1, i0) _dcw(_jit, cc, r0, r1, i0)
370 _dcw(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_float64_t*);
371 # define ltr_d(r0, r1, r2) dcr(SPARC_FBL, r0, r1, r2)
372 # define lti_d(r0, r1, i0) dcw(SPARC_FBL, r0, r1, i0)
373 # define ler_d(r0, r1, r2) dcr(SPARC_FBLE, r0, r1, r2)
374 # define lei_d(r0, r1, i0) dcw(SPARC_FBLE, r0, r1, i0)
375 # define eqr_d(r0, r1, r2) dcr(SPARC_FBE, r0, r1, r2)
376 # define eqi_d(r0, r1, i0) dcw(SPARC_FBE, r0, r1, i0)
377 # define ger_d(r0, r1, r2) dcr(SPARC_FBGE, r0, r1, r2)
378 # define gei_d(r0, r1, i0) dcw(SPARC_FBGE, r0, r1, i0)
379 # define gtr_d(r0, r1, r2) dcr(SPARC_FBG, r0, r1, r2)
380 # define gti_d(r0, r1, i0) dcw(SPARC_FBG, r0, r1, i0)
381 # define ner_d(r0, r1, r2) dcr(SPARC_FBNE, r0, r1, r2)
382 # define nei_d(r0, r1, i0) dcw(SPARC_FBNE, r0, r1, i0)
383 # define unltr_d(r0, r1, r2) dcr(SPARC_FBUL, r0, r1, r2)
384 # define unlti_d(r0, r1, i0) dcw(SPARC_FBUL, r0, r1, i0)
385 # define unler_d(r0, r1, r2) dcr(SPARC_FBULE, r0, r1, r2)
386 # define unlei_d(r0, r1, i0) dcw(SPARC_FBULE, r0, r1, i0)
387 # define uneqr_d(r0, r1, r2) dcr(SPARC_FBUE, r0, r1, r2)
388 # define uneqi_d(r0, r1, i0) dcw(SPARC_FBUE, r0, r1, i0)
389 # define unger_d(r0, r1, r2) dcr(SPARC_FBUGE, r0, r1, r2)
390 # define ungei_d(r0, r1, i0) dcw(SPARC_FBUGE, r0, r1, i0)
391 # define ungtr_d(r0, r1, r2) dcr(SPARC_FBUG, r0, r1, r2)
392 # define ungti_d(r0, r1, i0) dcw(SPARC_FBUG, r0, r1, i0)
393 # define ltgtr_d(r0, r1, r2) dcr(SPARC_FBLG, r0, r1, r2)
394 # define ltgti_d(r0, r1, i0) dcw(SPARC_FBLG, r0, r1, i0)
395 # define ordr_d(r0, r1, r2) dcr(SPARC_FBO, r0, r1, r2)
396 # define ordi_d(r0, r1, i0) dcw(SPARC_FBO, r0, r1, i0)
397 # define unordr_d(r0, r1, r2) dcr(SPARC_FBU, r0, r1, r2)
398 # define unordi_d(r0, r1, i0) dcw(SPARC_FBU, r0, r1, i0)
399 # if __WORDSIZE == 32
400 # define ldr_f(r0, r1) LDF(r1, 0, r0)
402 # define ldr_f(r0, r1) _ldr_f(_jit, r0, r1)
403 static void _ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
405 # define ldi_f(r0, i0) _ldi_f(_jit, r0, i0)
406 static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
407 # if __WORDSIZE == 32
408 # define ldxr_f(r0, r1, r2) LDF(r1, r2, r0)
410 # define ldxr_f(r0, r1, r2) _ldxr_f(_jit, r0, r1, r2)
411 static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
413 # define ldxi_f(r0, r1, i0) _ldxi_f(_jit, r0, r1, i0)
414 static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
415 # if __WORDSIZE == 32
416 # define str_f(r0, r1) STF(r1, r0, 0)
418 # define str_f(r0, r1) _str_f(_jit, r0, r1)
419 static void _str_f(jit_state_t*,jit_int32_t,jit_int32_t);
421 # define sti_f(r0, i0) _sti_f(_jit, r0, i0)
422 static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
423 # if __WORDSIZE == 32
424 # define stxr_f(r0, r1, r2) STF(r2, r1, r0)
426 # define stxr_f(r0, r1, r2) _stxr_f(_jit, r0, r1, r2)
427 static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
429 # define stxi_f(r0, r1, i0) _stxi_f(_jit, r0, r1, i0)
430 static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
431 # define ldr_d(r0, r1) LDDF(r1, 0, r0)
432 # define ldi_d(r0, i0) _ldi_d(_jit, r0, i0)
433 static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
434 # define ldxr_d(r0, r1, r2) LDDF(r1, r2, r0)
435 # define ldxi_d(r0, r1, i0) _ldxi_d(_jit, r0, r1, i0)
436 static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
437 # define str_d(r0, r1) STDF(r1, r0, 0)
438 # define sti_d(r0, i0) _sti_d(_jit, r0, i0)
439 static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
440 # define stxr_d(r0, r1, r2) STDF(r2, r1, r0)
441 # define stxi_d(r0, r1, i0) _stxi_d(_jit, r0, r1, i0)
442 static void _stxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
443 # define fbr(cc, i0, r0, r1) _fbr(_jit, cc, i0, r0, r1)
445 _fbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
446 # define fbw(cc, i0, r0, i1) _fbw(_jit, cc, i0, r0, i1)
448 _fbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t*);
449 # define bltr_f(i0, r0, r1) fbr(SPARC_FBL, i0, r0, r1)
450 # define blti_f(i0, r0, i1) fbw(SPARC_FBL, i0, r0, i1)
451 # define bler_f(i0, r0, r1) fbr(SPARC_FBLE, i0, r0, r1)
452 # define blei_f(i0, r0, i1) fbw(SPARC_FBLE, i0, r0, i1)
453 # define beqr_f(i0, r0, r1) fbr(SPARC_FBE, i0, r0, r1)
454 # define beqi_f(i0, r0, i1) fbw(SPARC_FBE, i0, r0, i1)
455 # define bger_f(i0, r0, r1) fbr(SPARC_FBGE, i0, r0, r1)
456 # define bgei_f(i0, r0, i1) fbw(SPARC_FBGE, i0, r0, i1)
457 # define bgtr_f(i0, r0, r1) fbr(SPARC_FBG, i0, r0, r1)
458 # define bgti_f(i0, r0, i1) fbw(SPARC_FBG, i0, r0, i1)
459 # define bner_f(i0, r0, r1) fbr(SPARC_FBNE, i0, r0, r1)
460 # define bnei_f(i0, r0, i1) fbw(SPARC_FBNE, i0, r0, i1)
461 # define bunltr_f(i0, r0, r1) fbr(SPARC_FBUL, i0, r0, r1)
462 # define bunlti_f(i0, r0, i1) fbw(SPARC_FBUL, i0, r0, i1)
463 # define bunler_f(i0, r0, r1) fbr(SPARC_FBULE, i0, r0, r1)
464 # define bunlei_f(i0, r0, i1) fbw(SPARC_FBULE, i0, r0, i1)
465 # define buneqr_f(i0, r0, r1) fbr(SPARC_FBUE, i0, r0, r1)
466 # define buneqi_f(i0, r0, i1) fbw(SPARC_FBUE, i0, r0, i1)
467 # define bunger_f(i0, r0, r1) fbr(SPARC_FBUGE, i0, r0, r1)
468 # define bungei_f(i0, r0, i1) fbw(SPARC_FBUGE, i0, r0, i1)
469 # define bungtr_f(i0, r0, r1) fbr(SPARC_FBUG, i0, r0, r1)
470 # define bungti_f(i0, r0, i1) fbw(SPARC_FBUG, i0, r0, i1)
471 # define bltgtr_f(i0, r0, r1) fbr(SPARC_FBLG, i0, r0, r1)
472 # define bltgti_f(i0, r0, i1) fbw(SPARC_FBLG, i0, r0, i1)
473 # define bordr_f(i0, r0, r1) fbr(SPARC_FBO, i0, r0, r1)
474 # define bordi_f(i0, r0, i1) fbw(SPARC_FBO, i0, r0, i1)
475 # define bunordr_f(i0, r0, r1) fbr(SPARC_FBU, i0, r0, r1)
476 # define bunordi_f(i0, r0, i1) fbw(SPARC_FBU, i0, r0, i1)
477 # define dbr(cc, i0, r0, r1) _dbr(_jit, cc, i0, r0, r1)
479 _dbr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
480 # define dbw(cc, i0, r0, i1) _dbw(_jit, cc, i0, r0, i1)
482 _dbw(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t*);
483 # define bltr_d(i0, r0, r1) dbr(SPARC_FBL, i0, r0, r1)
484 # define blti_d(i0, r0, i1) dbw(SPARC_FBL, i0, r0, i1)
485 # define bler_d(i0, r0, r1) dbr(SPARC_FBLE, i0, r0, r1)
486 # define blei_d(i0, r0, i1) dbw(SPARC_FBLE, i0, r0, i1)
487 # define beqr_d(i0, r0, r1) dbr(SPARC_FBE, i0, r0, r1)
488 # define beqi_d(i0, r0, i1) dbw(SPARC_FBE, i0, r0, i1)
489 # define bger_d(i0, r0, r1) dbr(SPARC_FBGE, i0, r0, r1)
490 # define bgei_d(i0, r0, i1) dbw(SPARC_FBGE, i0, r0, i1)
491 # define bgtr_d(i0, r0, r1) dbr(SPARC_FBG, i0, r0, r1)
492 # define bgti_d(i0, r0, i1) dbw(SPARC_FBG, i0, r0, i1)
493 # define bner_d(i0, r0, r1) dbr(SPARC_FBNE, i0, r0, r1)
494 # define bnei_d(i0, r0, i1) dbw(SPARC_FBNE, i0, r0, i1)
495 # define bunltr_d(i0, r0, r1) dbr(SPARC_FBUL, i0, r0, r1)
496 # define bunlti_d(i0, r0, i1) dbw(SPARC_FBUL, i0, r0, i1)
497 # define bunler_d(i0, r0, r1) dbr(SPARC_FBULE, i0, r0, r1)
498 # define bunlei_d(i0, r0, i1) dbw(SPARC_FBULE, i0, r0, i1)
499 # define buneqr_d(i0, r0, r1) dbr(SPARC_FBUE, i0, r0, r1)
500 # define buneqi_d(i0, r0, i1) dbw(SPARC_FBUE, i0, r0, i1)
501 # define bunger_d(i0, r0, r1) dbr(SPARC_FBUGE, i0, r0, r1)
502 # define bungei_d(i0, r0, i1) dbw(SPARC_FBUGE, i0, r0, i1)
503 # define bungtr_d(i0, r0, r1) dbr(SPARC_FBUG, i0, r0, r1)
504 # define bungti_d(i0, r0, i1) dbw(SPARC_FBUG, i0, r0, i1)
505 # define bltgtr_d(i0, r0, r1) dbr(SPARC_FBLG, i0, r0, r1)
506 # define bltgti_d(i0, r0, i1) dbw(SPARC_FBLG, i0, r0, i1)
507 # define bordr_d(i0, r0, r1) dbr(SPARC_FBO, i0, r0, r1)
508 # define bordi_d(i0, r0, i1) dbw(SPARC_FBO, i0, r0, i1)
509 # define bunordr_d(i0, r0, r1) dbr(SPARC_FBU, i0, r0, r1)
510 # define bunordi_d(i0, r0, i1) dbw(SPARC_FBU, i0, r0, i1)
511 # define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
512 static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
517 _f3f(jit_state_t *_jit, jit_int32_t rd,
518 jit_int32_t op3, jit_int32_t rs1, jit_int32_t opf, jit_int32_t rs2)
521 # if __WORDSIZE == 64
523 assert(rd <= 63 && (rd & 1) == 0);
527 assert(rs1 <= 63 && (rs1 & 1) == 0);
531 assert(rs2 <= 63 && (rs2 & 1) == 0);
535 assert(!(rd & 0xffffffe0));
536 assert(!(op3 & 0xffffffc0));
537 assert(!(rs1 & 0xffffffe0));
538 assert(!(opf & 0xfffffe00));
539 assert(!(rs2 & 0xffffffe0));
550 _f4f(jit_state_t *_jit, jit_int32_t rd, jit_int32_t op3,
551 jit_int32_t rs1, jit_int32_t rs3, jit_int32_t op5, jit_int32_t rs2)
554 # if __WORDSIZE == 64
556 assert(rd <= 63 && (rd & 1) == 0);
560 assert(rs1 <= 63 && (rs1 & 1) == 0);
564 assert(rs2 <= 63 && (rs2 & 1) == 0);
568 assert(rs3 <= 63 && (rs3 & 1) == 0);
572 assert(!(rd & 0xffffffe0));
573 assert(!(op3 & 0xffffffc0));
574 assert(!(rs1 & 0xffffffe0));
575 assert(!(rs3 & 0xffffffe0));
576 assert(!(op5 & 0xfffffff0));
577 assert(!(rs2 & 0xffffffe0));
588 # if __WORDSIZE == 64
589 /* Handle the special case of using all float registers, as exercised
592 * putargr_f JIT_F0 $ARG
593 * where JIT_F0 is %f32 and $ARG is %f31 and if %f30 (the mapping for %f31)
594 * is live, the jit_get_reg() call might return %f30, but, because it is
595 * live, will spill/reload it, generating assembly:
597 * std %f30, [ %fp + OFFS ]
600 * ldd [ %fp + OFFS ], %f30
602 * what basically becomes a noop as it restores the old value.
604 #define get_sng_reg(u) _get_sng_reg(_jit, u)
606 _get_sng_reg(jit_state_t *_jit, jit_int32_t r0)
608 jit_int32_t reg, tmp;
609 /* Attempt to get a nospill register */
610 reg = jit_get_reg(CLASS_SNG | jit_class_nospill | jit_class_chk);
611 if (reg == JIT_NOREG) {
612 /* Will need to spill, so allow spilling it. */
613 reg = jit_get_reg(CLASS_SNG);
614 /* If the special condition happens, allocate another one.
615 * This will generate uglier machine code (code for floats
616 * is already ugly), but will work, but doing a double
617 * spill/reload; the first one being a noop. */
618 if (rn(reg) == r0 - 1) {
620 reg = jit_get_reg(CLASS_SNG);
628 _movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
632 if (single_precision_p(r0)) {
633 if (single_precision_p(r1))
636 t1 = get_sng_reg(r0);
643 if (single_precision_p(r1)) {
644 t0 = get_sng_reg(r0);
650 t1 = get_sng_reg(r0);
652 FMOVS(rn(t1), rn(t1));
661 _negr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
664 if (single_precision_p(r0)) {
665 if (single_precision_p(r1))
668 t1 = jit_get_reg(CLASS_SNG);
675 if (single_precision_p(r1)) {
676 t0 = jit_get_reg(CLASS_SNG);
682 t1 = jit_get_reg(CLASS_SNG);
684 FNEGS(rn(t1), rn(t1));
692 _absr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
695 if (single_precision_p(r0)) {
696 if (single_precision_p(r1))
699 t1 = jit_get_reg(CLASS_SNG);
706 if (single_precision_p(r1)) {
707 t0 = jit_get_reg(CLASS_SNG);
713 t1 = jit_get_reg(CLASS_SNG);
715 FABSS(rn(t1), rn(t1));
723 _sqrtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
726 if (single_precision_p(r0)) {
727 if (single_precision_p(r1))
730 t1 = jit_get_reg(CLASS_SNG);
737 if (single_precision_p(r1)) {
738 t0 = jit_get_reg(CLASS_SNG);
744 t1 = jit_get_reg(CLASS_SNG);
746 FSQRTS(rn(t1), rn(t1));
754 # if __WORDSIZE == 64
756 _extr_d_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
759 if (!single_precision_p(r0)) {
760 reg = jit_get_reg(CLASS_SNG);
772 _movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t *i0)
780 if (_jitc->no_data) {
782 reg = jit_get_reg(jit_class_gpr);
783 movi(rn(reg), data.i & 0xffffffff);
784 stxi_i(BIAS(-8), _FP_REGNO, rn(reg));
786 ldxi_f(r0, _FP_REGNO, BIAS(-8));
789 ldi_f(r0, (jit_word_t)i0);
793 _movi_w_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
796 reg = jit_get_reg(jit_class_gpr);
798 movr_w_f(r0, rn(reg));
802 # if __WORDSIZE == 64
804 _extr_f_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
807 if (!single_precision_p(r1)) {
808 reg = jit_get_reg(CLASS_SNG);
819 _movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t *i0)
822 # if __WORDSIZE == 32
831 if (_jitc->no_data) {
833 reg = jit_get_reg(jit_class_gpr);
834 # if __WORDSIZE == 32
835 movi(rn(reg), data.i[0]);
837 movi(rn(reg), data.w);
839 stxi(BIAS(-8), _FP_REGNO, rn(reg));
840 # if __WORDSIZE == 32
841 movi(rn(reg), data.i[1]);
842 stxi_i(BIAS(-4), _FP_REGNO, rn(reg));
845 ldxi_d(r0, _FP_REGNO, BIAS(-8));
848 ldi_d(r0, (jit_word_t)i0);
851 # if __WORDSIZE == 32
853 _movi_ww_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0, jit_word_t i1)
856 t0 = jit_get_reg(jit_class_gpr);
857 t1 = jit_get_reg(jit_class_gpr);
860 movr_ww_d(r0, rn(t0), rn(t1));
866 _movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
872 FMOVS(r1 + 1, r0 + 1);
877 _negr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
883 FMOVS(r1 + 1, r0 + 1);
887 _absr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
893 FMOVS(r1 + 1, r0 + 1);
897 _movi_w_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
900 reg = jit_get_reg(jit_class_gpr);
902 movr_w_d(r0, rn(reg));
907 # if __WORDSIZE == 64
908 # define single_rrr(NAME, CODE) \
910 NAME(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2) \
912 jit_int32_t x0, t0, x1, t1, x2, t2, mask = 0; \
913 if (!single_precision_p(r0)) { \
915 t0 = jit_get_reg(CLASS_SNG); \
923 else if (r0 == r2) { \
930 if (!single_precision_p(r1)) { \
933 t1 = jit_get_reg(CLASS_SNG); \
942 if (!single_precision_p(r2)) { \
943 if (r0 != r2 && r1 != r2) { \
945 t2 = jit_get_reg(CLASS_SNG); \
964 _fop2f(jit_state_t *_jit, jit_int32_t op,
965 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
967 jit_int32_t x0, t0, x1, t1, x2, t2, mask = 0;
968 if (!single_precision_p(r0)) {
970 t0 = jit_get_reg(CLASS_SNG);
985 if (!single_precision_p(r1)) {
988 t1 = jit_get_reg(CLASS_SNG);
997 if (!single_precision_p(r2)) {
998 if (r0 != r2 && r1 != r2) {
1000 t2 = jit_get_reg(CLASS_SNG);
1007 FPop1(x0, x1, op, x2);
1019 _fop3f(jit_state_t *_jit, jit_int32_t op,
1020 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2, jit_int32_t r3)
1022 jit_int32_t x0, t0, x1, t1, x2, t2, x3, t3, mask = 0;
1023 if (!single_precision_p(r0)) {
1025 t0 = jit_get_reg(CLASS_SNG);
1035 else if (r0 == r2) {
1039 else if (r0 == r3) {
1046 if (!single_precision_p(r1)) {
1049 t1 = jit_get_reg(CLASS_SNG);
1060 if (!single_precision_p(r2)) {
1061 if (r0 != r2 && r1 != r2) {
1063 t2 = jit_get_reg(CLASS_SNG);
1072 if (!single_precision_p(r3)) {
1073 if (r0 != r3 && r1 != r3 && r2 != r3) {
1075 t3 = jit_get_reg(CLASS_SNG);
1082 FPop3(x0, x1, x3, op, x2);
1097 _fop1f(jit_state_t *_jit, jit_int32_t op,
1098 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
1101 # if __WORDSIZE == 64
1102 jit_int32_t x0, t0, x1, t1, mask = 0;
1104 reg = jit_get_reg(CLASS_SNG);
1105 movi_f(rn(reg), i0);
1106 # if __WORDSIZE == 64
1107 if (!single_precision_p(r0)) {
1109 t0 = jit_get_reg(CLASS_SNG);
1118 if (!single_precision_p(r1)) {
1121 t1 = jit_get_reg(CLASS_SNG);
1128 FPop1(x0, x1, op, rn(reg));
1136 FPop1(r0, r1, op, rn(reg));
1142 _rfop1f(jit_state_t *_jit, jit_int32_t op,
1143 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
1146 # if __WORDSIZE == 64
1147 jit_int32_t x0, t0, x1, t1, mask = 0;
1149 reg = jit_get_reg(CLASS_SNG);
1150 movi_f(rn(reg), i0);
1151 # if __WORDSIZE == 64
1152 if (!single_precision_p(r0)) {
1154 t0 = jit_get_reg(CLASS_SNG);
1163 if (!single_precision_p(r1)) {
1166 t1 = jit_get_reg(CLASS_SNG);
1173 FPop1(x0, rn(reg), op, x1);
1181 FPop1(r0, rn(reg), op, r1);
1187 _fop1d(jit_state_t *_jit, jit_int32_t op,
1188 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
1191 reg = jit_get_reg(CLASS_DBL);
1192 movi_d(rn(reg), i0);
1193 FPop1(r0, r1, op, rn(reg));
1198 _rfop1d(jit_state_t *_jit, jit_int32_t op,
1199 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
1202 reg = jit_get_reg(CLASS_DBL);
1203 movi_d(rn(reg), i0);
1204 FPop1(r0, rn(reg), op, r1);
1209 _extr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1211 stxi(BIAS(-8), _FP_REGNO, r1);
1212 # if __WORDSIZE == 32
1213 ldxi_f(r0, _FP_REGNO, BIAS(-8));
1216 ldxi_d(r0, _FP_REGNO, BIAS(-8));
1217 if (!single_precision_p(r0)) {
1219 reg = jit_get_reg(CLASS_SNG);
1220 movr_d(rn(reg), r0);
1221 FXTOS(rn(reg), rn(reg));
1222 movr_d(r0, rn(reg));
1231 _truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1234 reg = jit_get_reg(CLASS_SNG);
1235 # if __WORDSIZE == 64
1236 if (!single_precision_p(r1)) {
1237 movr_d(rn(reg), r1);
1238 FSTOI(rn(reg), rn(reg));
1243 stxi_f(BIAS(-8), _FP_REGNO, rn(reg));
1244 ldxi_i(r0, _FP_REGNO, BIAS(-8));
1248 # if __WORDSIZE == 64
1250 _truncr_f_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1253 reg = jit_get_reg(CLASS_SNG);
1254 # if __WORDSIZE == 64
1255 if (!single_precision_p(r1)) {
1256 movr_d(rn(reg), r1);
1257 FSTOX(rn(reg), rn(reg));
1262 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1263 ldxi_l(r0, _FP_REGNO, BIAS(-8));
1269 _fcr(jit_state_t *_jit, jit_int32_t cc,
1270 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1272 # if __WORDSIZE == 64
1273 jit_int32_t x0, t0, x1, t1, mask = 0;
1274 if (!single_precision_p(r1)) {
1276 t0 = jit_get_reg(CLASS_SNG);
1284 else if (!single_precision_p(r2)) {
1286 t1 = jit_get_reg(CLASS_SNG);
1306 _fcw(jit_state_t *_jit, jit_int32_t cc,
1307 jit_int32_t r0, jit_int32_t r1, jit_float32_t *i0)
1310 # if __WORDSIZE == 64
1311 jit_int32_t x0, t0, mask = 0;
1312 if (!single_precision_p(r1)) {
1314 t0 = jit_get_reg(CLASS_SNG);
1321 reg = jit_get_reg(CLASS_SNG);
1322 movi_f(rn(reg), i0);
1323 # if __WORDSIZE == 64
1337 _dcr(jit_state_t *_jit, jit_int32_t cc,
1338 jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1347 _dcw(jit_state_t *_jit, jit_int32_t cc,
1348 jit_int32_t r0, jit_int32_t r1, jit_float64_t *i0)
1351 reg = jit_get_reg(CLASS_DBL);
1352 movi_d(rn(reg), i0);
1360 # if __WORDSIZE == 64
1362 _ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1365 if (!single_precision_p(r0)) {
1366 reg = jit_get_reg(CLASS_SNG);
1367 LDF(r1, 0, rn(reg));
1368 movr_d(r0, rn(reg));
1377 _ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1381 # if __WORDSIZE == 64
1382 if (!single_precision_p(r0)) {
1383 reg = jit_get_reg(CLASS_SNG);
1384 LDFI(0, i0, rn(reg));
1385 movr_d(r0, rn(reg));
1393 reg = jit_get_reg(jit_class_gpr);
1400 # if __WORDSIZE == 64
1402 _ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1405 if (!single_precision_p(r0)) {
1406 reg = jit_get_reg(CLASS_SNG);
1407 LDF(r1, r2, rn(reg));
1408 movr_d(r0, rn(reg));
1417 _ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
1421 # if __WORDSIZE == 64
1422 if (!single_precision_p(r0)) {
1423 reg = jit_get_reg(CLASS_SNG);
1424 LDFI(r1, i0, rn(reg));
1425 movr_d(r0, rn(reg));
1433 reg = jit_get_reg(jit_class_gpr);
1435 ldxr_f(r0, r1, rn(reg));
1440 # if __WORDSIZE == 64
1442 _str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1445 if (!single_precision_p(r1)) {
1446 reg = jit_get_reg(CLASS_SNG);
1447 movr_d(rn(reg), r1);
1448 STF(rn(reg), r0, 0);
1457 _sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1461 # if __WORDSIZE == 64
1462 if (!single_precision_p(r0)) {
1463 reg = jit_get_reg(CLASS_SNG);
1464 movr_d(rn(reg), r0);
1465 STFI(rn(reg), 0, i0);
1473 reg = jit_get_reg(jit_class_gpr);
1480 # if __WORDSIZE == 64
1482 _stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
1485 if (!single_precision_p(r2)) {
1486 reg = jit_get_reg(CLASS_SNG);
1487 movr_d(rn(reg), r2);
1488 STF(rn(reg), r1, r0);
1497 _stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1501 # if __WORDSIZE == 64
1502 if (!single_precision_p(r1)) {
1503 reg = jit_get_reg(CLASS_SNG);
1504 movr_d(rn(reg), r1);
1505 STFI(rn(reg), r0, i0);
1513 reg = jit_get_reg(jit_class_gpr);
1515 stxr_f(rn(reg), r0, r1);
1521 _extr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1523 stxi(BIAS(-8), _FP_REGNO, r1);
1524 # if __WORDSIZE == 32
1525 stxi(BIAS(-4), _FP_REGNO, 0);
1527 ldxi_d(r0, _FP_REGNO, BIAS(-8));
1528 # if __WORDSIZE == 32
1536 _truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1539 reg = jit_get_reg(CLASS_SNG);
1540 # if __WORDSIZE == 64
1541 if (!single_precision_p(r1)) {
1542 movr_d(rn(reg), r1);
1543 FDTOI(rn(reg), rn(reg));
1548 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1549 ldxi_i(r0, _FP_REGNO, BIAS(-8));
1553 # if __WORDSIZE == 64
1555 _truncr_d_l(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1558 reg = jit_get_reg(CLASS_DBL);
1560 stxi_d(BIAS(-8), _FP_REGNO, rn(reg));
1561 ldxi_l(r0, _FP_REGNO, BIAS(-8));
1567 _ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
1573 reg = jit_get_reg(jit_class_gpr);
1581 _ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t i0)
1587 reg = jit_get_reg(jit_class_gpr);
1589 ldxr_d(r0, r1, rn(reg));
1595 _sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
1601 reg = jit_get_reg(jit_class_gpr);
1609 _stxi_d(jit_state_t *_jit, jit_int32_t i0, jit_int32_t r0, jit_int32_t r1)
1615 reg = jit_get_reg(jit_class_gpr);
1617 stxr_d(rn(reg), r0, r1);
1623 _fbr(jit_state_t *_jit, jit_int32_t cc,
1624 jit_word_t i0, jit_int32_t r0,jit_int32_t r1)
1626 # if __WORDSIZE == 64
1627 jit_int32_t x0, t0, x1, t1, mask = 0;
1630 # if __WORDSIZE == 64
1631 if (!single_precision_p(r0)) {
1633 t0 = jit_get_reg(CLASS_SNG);
1641 else if (!single_precision_p(r1)) {
1643 t1 = jit_get_reg(CLASS_SNG);
1658 FB(cc, (i0 - w) >> 2);
1664 _fbw(jit_state_t *_jit, jit_int32_t cc,
1665 jit_word_t i0, jit_int32_t r0, jit_float32_t *i1)
1669 # if __WORDSIZE == 64
1670 jit_int32_t x0, t0, mask = 0;
1671 if (!single_precision_p(r0)) {
1673 t0 = jit_get_reg(CLASS_SNG);
1680 reg = jit_get_reg(CLASS_SNG);
1681 movi_f(rn(reg), i1);
1682 # if __WORDSIZE == 64
1691 FB(cc, (i0 - w) >> 2);
1697 _dbr(jit_state_t *_jit, jit_int32_t cc,
1698 jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
1703 FB(cc, (i0 - w) >> 2);
1709 _dbw(jit_state_t *_jit, jit_int32_t cc,
1710 jit_word_t i0, jit_int32_t r0, jit_float64_t *i1)
1714 reg = jit_get_reg(CLASS_DBL);
1715 movi_d(rn(reg), i1);
1719 FB(cc, (i0 - w) >> 2);
1725 _vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
1727 assert(_jitc->function->self.call & jit_call_varargs);
1729 /* Load argument. */
1730 #if __WORDSIZE == 64
1734 ldxi_f(r0 + 1, r1, 4);
1737 /* Update vararg stack pointer. */