1 /*
2 * FPU op helpers
3 *
4 * Copyright (c) 2003-2005 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "qemu/osdep.h"
21 #include "cpu.h"
22 #include "exec/exec-all.h"
23 #include "exec/helper-proto.h"
24 #include "fpu/softfloat.h"
25
f128_in(Int128 i)26 static inline float128 f128_in(Int128 i)
27 {
28 union {
29 Int128 i;
30 float128 f;
31 } u;
32
33 u.i = i;
34 return u.f;
35 }
36
f128_ret(float128 f)37 static inline Int128 f128_ret(float128 f)
38 {
39 union {
40 Int128 i;
41 float128 f;
42 } u;
43
44 u.f = f;
45 return u.i;
46 }
47
check_ieee_exceptions(CPUSPARCState * env,uintptr_t ra)48 static void check_ieee_exceptions(CPUSPARCState *env, uintptr_t ra)
49 {
50 target_ulong status = get_float_exception_flags(&env->fp_status);
51 uint32_t cexc = 0;
52
53 if (unlikely(status)) {
54 /* Keep exception flags clear for next time. */
55 set_float_exception_flags(0, &env->fp_status);
56
57 /* Copy IEEE 754 flags into FSR */
58 if (status & float_flag_invalid) {
59 cexc |= FSR_NVC;
60 }
61 if (status & float_flag_overflow) {
62 cexc |= FSR_OFC;
63 }
64 if (status & float_flag_underflow) {
65 cexc |= FSR_UFC;
66 }
67 if (status & float_flag_divbyzero) {
68 cexc |= FSR_DZC;
69 }
70 if (status & float_flag_inexact) {
71 cexc |= FSR_NXC;
72 }
73
74 if (cexc & (env->fsr >> FSR_TEM_SHIFT)) {
75 /* Unmasked exception, generate an IEEE trap. */
76 env->fsr_cexc_ftt = cexc | FSR_FTT_IEEE_EXCP;
77 cpu_raise_exception_ra(env, TT_FP_EXCP, ra);
78 }
79
80 /* Accumulate exceptions */
81 env->fsr |= cexc << FSR_AEXC_SHIFT;
82 }
83
84 /* No trap, so FTT is cleared. */
85 env->fsr_cexc_ftt = cexc;
86 }
87
helper_fadds(CPUSPARCState * env,float32 src1,float32 src2)88 float32 helper_fadds(CPUSPARCState *env, float32 src1, float32 src2)
89 {
90 float32 ret = float32_add(src1, src2, &env->fp_status);
91 check_ieee_exceptions(env, GETPC());
92 return ret;
93 }
94
helper_fsubs(CPUSPARCState * env,float32 src1,float32 src2)95 float32 helper_fsubs(CPUSPARCState *env, float32 src1, float32 src2)
96 {
97 float32 ret = float32_sub(src1, src2, &env->fp_status);
98 check_ieee_exceptions(env, GETPC());
99 return ret;
100 }
101
helper_fmuls(CPUSPARCState * env,float32 src1,float32 src2)102 float32 helper_fmuls(CPUSPARCState *env, float32 src1, float32 src2)
103 {
104 float32 ret = float32_mul(src1, src2, &env->fp_status);
105 check_ieee_exceptions(env, GETPC());
106 return ret;
107 }
108
helper_fdivs(CPUSPARCState * env,float32 src1,float32 src2)109 float32 helper_fdivs(CPUSPARCState *env, float32 src1, float32 src2)
110 {
111 float32 ret = float32_div(src1, src2, &env->fp_status);
112 check_ieee_exceptions(env, GETPC());
113 return ret;
114 }
115
helper_faddd(CPUSPARCState * env,float64 src1,float64 src2)116 float64 helper_faddd(CPUSPARCState *env, float64 src1, float64 src2)
117 {
118 float64 ret = float64_add(src1, src2, &env->fp_status);
119 check_ieee_exceptions(env, GETPC());
120 return ret;
121 }
122
helper_fsubd(CPUSPARCState * env,float64 src1,float64 src2)123 float64 helper_fsubd(CPUSPARCState *env, float64 src1, float64 src2)
124 {
125 float64 ret = float64_sub(src1, src2, &env->fp_status);
126 check_ieee_exceptions(env, GETPC());
127 return ret;
128 }
129
helper_fmuld(CPUSPARCState * env,float64 src1,float64 src2)130 float64 helper_fmuld(CPUSPARCState *env, float64 src1, float64 src2)
131 {
132 float64 ret = float64_mul(src1, src2, &env->fp_status);
133 check_ieee_exceptions(env, GETPC());
134 return ret;
135 }
136
helper_fdivd(CPUSPARCState * env,float64 src1,float64 src2)137 float64 helper_fdivd(CPUSPARCState *env, float64 src1, float64 src2)
138 {
139 float64 ret = float64_div(src1, src2, &env->fp_status);
140 check_ieee_exceptions(env, GETPC());
141 return ret;
142 }
143
helper_faddq(CPUSPARCState * env,Int128 src1,Int128 src2)144 Int128 helper_faddq(CPUSPARCState *env, Int128 src1, Int128 src2)
145 {
146 float128 ret = float128_add(f128_in(src1), f128_in(src2), &env->fp_status);
147 check_ieee_exceptions(env, GETPC());
148 return f128_ret(ret);
149 }
150
helper_fsubq(CPUSPARCState * env,Int128 src1,Int128 src2)151 Int128 helper_fsubq(CPUSPARCState *env, Int128 src1, Int128 src2)
152 {
153 float128 ret = float128_sub(f128_in(src1), f128_in(src2), &env->fp_status);
154 check_ieee_exceptions(env, GETPC());
155 return f128_ret(ret);
156 }
157
helper_fmulq(CPUSPARCState * env,Int128 src1,Int128 src2)158 Int128 helper_fmulq(CPUSPARCState *env, Int128 src1, Int128 src2)
159 {
160 float128 ret = float128_mul(f128_in(src1), f128_in(src2), &env->fp_status);
161 check_ieee_exceptions(env, GETPC());
162 return f128_ret(ret);
163 }
164
helper_fdivq(CPUSPARCState * env,Int128 src1,Int128 src2)165 Int128 helper_fdivq(CPUSPARCState *env, Int128 src1, Int128 src2)
166 {
167 float128 ret = float128_div(f128_in(src1), f128_in(src2), &env->fp_status);
168 check_ieee_exceptions(env, GETPC());
169 return f128_ret(ret);
170 }
171
helper_fsmuld(CPUSPARCState * env,float32 src1,float32 src2)172 float64 helper_fsmuld(CPUSPARCState *env, float32 src1, float32 src2)
173 {
174 float64 ret = float64_mul(float32_to_float64(src1, &env->fp_status),
175 float32_to_float64(src2, &env->fp_status),
176 &env->fp_status);
177 check_ieee_exceptions(env, GETPC());
178 return ret;
179 }
180
helper_fdmulq(CPUSPARCState * env,float64 src1,float64 src2)181 Int128 helper_fdmulq(CPUSPARCState *env, float64 src1, float64 src2)
182 {
183 float128 ret = float128_mul(float64_to_float128(src1, &env->fp_status),
184 float64_to_float128(src2, &env->fp_status),
185 &env->fp_status);
186 check_ieee_exceptions(env, GETPC());
187 return f128_ret(ret);
188 }
189
190 /* Integer to float conversion. */
helper_fitos(CPUSPARCState * env,int32_t src)191 float32 helper_fitos(CPUSPARCState *env, int32_t src)
192 {
193 float32 ret = int32_to_float32(src, &env->fp_status);
194 check_ieee_exceptions(env, GETPC());
195 return ret;
196 }
197
helper_fitod(CPUSPARCState * env,int32_t src)198 float64 helper_fitod(CPUSPARCState *env, int32_t src)
199 {
200 float64 ret = int32_to_float64(src, &env->fp_status);
201 check_ieee_exceptions(env, GETPC());
202 return ret;
203 }
204
helper_fitoq(CPUSPARCState * env,int32_t src)205 Int128 helper_fitoq(CPUSPARCState *env, int32_t src)
206 {
207 float128 ret = int32_to_float128(src, &env->fp_status);
208 check_ieee_exceptions(env, GETPC());
209 return f128_ret(ret);
210 }
211
212 #ifdef TARGET_SPARC64
helper_fxtos(CPUSPARCState * env,int64_t src)213 float32 helper_fxtos(CPUSPARCState *env, int64_t src)
214 {
215 float32 ret = int64_to_float32(src, &env->fp_status);
216 check_ieee_exceptions(env, GETPC());
217 return ret;
218 }
219
helper_fxtod(CPUSPARCState * env,int64_t src)220 float64 helper_fxtod(CPUSPARCState *env, int64_t src)
221 {
222 float64 ret = int64_to_float64(src, &env->fp_status);
223 check_ieee_exceptions(env, GETPC());
224 return ret;
225 }
226
helper_fxtoq(CPUSPARCState * env,int64_t src)227 Int128 helper_fxtoq(CPUSPARCState *env, int64_t src)
228 {
229 float128 ret = int64_to_float128(src, &env->fp_status);
230 check_ieee_exceptions(env, GETPC());
231 return f128_ret(ret);
232 }
233 #endif
234
235 /* floating point conversion */
helper_fdtos(CPUSPARCState * env,float64 src)236 float32 helper_fdtos(CPUSPARCState *env, float64 src)
237 {
238 float32 ret = float64_to_float32(src, &env->fp_status);
239 check_ieee_exceptions(env, GETPC());
240 return ret;
241 }
242
helper_fstod(CPUSPARCState * env,float32 src)243 float64 helper_fstod(CPUSPARCState *env, float32 src)
244 {
245 float64 ret = float32_to_float64(src, &env->fp_status);
246 check_ieee_exceptions(env, GETPC());
247 return ret;
248 }
249
helper_fqtos(CPUSPARCState * env,Int128 src)250 float32 helper_fqtos(CPUSPARCState *env, Int128 src)
251 {
252 float32 ret = float128_to_float32(f128_in(src), &env->fp_status);
253 check_ieee_exceptions(env, GETPC());
254 return ret;
255 }
256
helper_fstoq(CPUSPARCState * env,float32 src)257 Int128 helper_fstoq(CPUSPARCState *env, float32 src)
258 {
259 float128 ret = float32_to_float128(src, &env->fp_status);
260 check_ieee_exceptions(env, GETPC());
261 return f128_ret(ret);
262 }
263
helper_fqtod(CPUSPARCState * env,Int128 src)264 float64 helper_fqtod(CPUSPARCState *env, Int128 src)
265 {
266 float64 ret = float128_to_float64(f128_in(src), &env->fp_status);
267 check_ieee_exceptions(env, GETPC());
268 return ret;
269 }
270
helper_fdtoq(CPUSPARCState * env,float64 src)271 Int128 helper_fdtoq(CPUSPARCState *env, float64 src)
272 {
273 float128 ret = float64_to_float128(src, &env->fp_status);
274 check_ieee_exceptions(env, GETPC());
275 return f128_ret(ret);
276 }
277
278 /* Float to integer conversion. */
helper_fstoi(CPUSPARCState * env,float32 src)279 int32_t helper_fstoi(CPUSPARCState *env, float32 src)
280 {
281 int32_t ret = float32_to_int32_round_to_zero(src, &env->fp_status);
282 check_ieee_exceptions(env, GETPC());
283 return ret;
284 }
285
helper_fdtoi(CPUSPARCState * env,float64 src)286 int32_t helper_fdtoi(CPUSPARCState *env, float64 src)
287 {
288 int32_t ret = float64_to_int32_round_to_zero(src, &env->fp_status);
289 check_ieee_exceptions(env, GETPC());
290 return ret;
291 }
292
helper_fqtoi(CPUSPARCState * env,Int128 src)293 int32_t helper_fqtoi(CPUSPARCState *env, Int128 src)
294 {
295 int32_t ret = float128_to_int32_round_to_zero(f128_in(src),
296 &env->fp_status);
297 check_ieee_exceptions(env, GETPC());
298 return ret;
299 }
300
301 #ifdef TARGET_SPARC64
helper_fstox(CPUSPARCState * env,float32 src)302 int64_t helper_fstox(CPUSPARCState *env, float32 src)
303 {
304 int64_t ret = float32_to_int64_round_to_zero(src, &env->fp_status);
305 check_ieee_exceptions(env, GETPC());
306 return ret;
307 }
308
helper_fdtox(CPUSPARCState * env,float64 src)309 int64_t helper_fdtox(CPUSPARCState *env, float64 src)
310 {
311 int64_t ret = float64_to_int64_round_to_zero(src, &env->fp_status);
312 check_ieee_exceptions(env, GETPC());
313 return ret;
314 }
315
helper_fqtox(CPUSPARCState * env,Int128 src)316 int64_t helper_fqtox(CPUSPARCState *env, Int128 src)
317 {
318 int64_t ret = float128_to_int64_round_to_zero(f128_in(src),
319 &env->fp_status);
320 check_ieee_exceptions(env, GETPC());
321 return ret;
322 }
323 #endif
324
helper_fsqrts(CPUSPARCState * env,float32 src)325 float32 helper_fsqrts(CPUSPARCState *env, float32 src)
326 {
327 float32 ret = float32_sqrt(src, &env->fp_status);
328 check_ieee_exceptions(env, GETPC());
329 return ret;
330 }
331
helper_fsqrtd(CPUSPARCState * env,float64 src)332 float64 helper_fsqrtd(CPUSPARCState *env, float64 src)
333 {
334 float64 ret = float64_sqrt(src, &env->fp_status);
335 check_ieee_exceptions(env, GETPC());
336 return ret;
337 }
338
helper_fsqrtq(CPUSPARCState * env,Int128 src)339 Int128 helper_fsqrtq(CPUSPARCState *env, Int128 src)
340 {
341 float128 ret = float128_sqrt(f128_in(src), &env->fp_status);
342 check_ieee_exceptions(env, GETPC());
343 return f128_ret(ret);
344 }
345
helper_fmadds(CPUSPARCState * env,float32 s1,float32 s2,float32 s3,uint32_t op)346 float32 helper_fmadds(CPUSPARCState *env, float32 s1,
347 float32 s2, float32 s3, uint32_t op)
348 {
349 float32 ret = float32_muladd(s1, s2, s3, op, &env->fp_status);
350 check_ieee_exceptions(env, GETPC());
351 return ret;
352 }
353
helper_fmaddd(CPUSPARCState * env,float64 s1,float64 s2,float64 s3,uint32_t op)354 float64 helper_fmaddd(CPUSPARCState *env, float64 s1,
355 float64 s2, float64 s3, uint32_t op)
356 {
357 float64 ret = float64_muladd(s1, s2, s3, op, &env->fp_status);
358 check_ieee_exceptions(env, GETPC());
359 return ret;
360 }
361
helper_fnadds(CPUSPARCState * env,float32 src1,float32 src2)362 float32 helper_fnadds(CPUSPARCState *env, float32 src1, float32 src2)
363 {
364 float32 ret = float32_add(src1, src2, &env->fp_status);
365
366 /*
367 * NaN inputs or result do not get a sign change.
368 * Nor, apparently, does zero: on hardware, -(x + -x) yields +0.
369 */
370 if (!float32_is_any_nan(ret) && !float32_is_zero(ret)) {
371 ret = float32_chs(ret);
372 }
373 check_ieee_exceptions(env, GETPC());
374 return ret;
375 }
376
helper_fnmuls(CPUSPARCState * env,float32 src1,float32 src2)377 float32 helper_fnmuls(CPUSPARCState *env, float32 src1, float32 src2)
378 {
379 float32 ret = float32_mul(src1, src2, &env->fp_status);
380
381 /* NaN inputs or result do not get a sign change. */
382 if (!float32_is_any_nan(ret)) {
383 ret = float32_chs(ret);
384 }
385 check_ieee_exceptions(env, GETPC());
386 return ret;
387 }
388
helper_fnaddd(CPUSPARCState * env,float64 src1,float64 src2)389 float64 helper_fnaddd(CPUSPARCState *env, float64 src1, float64 src2)
390 {
391 float64 ret = float64_add(src1, src2, &env->fp_status);
392
393 /*
394 * NaN inputs or result do not get a sign change.
395 * Nor, apparently, does zero: on hardware, -(x + -x) yields +0.
396 */
397 if (!float64_is_any_nan(ret) && !float64_is_zero(ret)) {
398 ret = float64_chs(ret);
399 }
400 check_ieee_exceptions(env, GETPC());
401 return ret;
402 }
403
helper_fnmuld(CPUSPARCState * env,float64 src1,float64 src2)404 float64 helper_fnmuld(CPUSPARCState *env, float64 src1, float64 src2)
405 {
406 float64 ret = float64_mul(src1, src2, &env->fp_status);
407
408 /* NaN inputs or result do not get a sign change. */
409 if (!float64_is_any_nan(ret)) {
410 ret = float64_chs(ret);
411 }
412 check_ieee_exceptions(env, GETPC());
413 return ret;
414 }
415
helper_fnsmuld(CPUSPARCState * env,float32 src1,float32 src2)416 float64 helper_fnsmuld(CPUSPARCState *env, float32 src1, float32 src2)
417 {
418 float64 ret = float64_mul(float32_to_float64(src1, &env->fp_status),
419 float32_to_float64(src2, &env->fp_status),
420 &env->fp_status);
421
422 /* NaN inputs or result do not get a sign change. */
423 if (!float64_is_any_nan(ret)) {
424 ret = float64_chs(ret);
425 }
426 check_ieee_exceptions(env, GETPC());
427 return ret;
428 }
429
finish_fcmp(CPUSPARCState * env,FloatRelation r,uintptr_t ra)430 static uint32_t finish_fcmp(CPUSPARCState *env, FloatRelation r, uintptr_t ra)
431 {
432 check_ieee_exceptions(env, ra);
433
434 /*
435 * FCC values:
436 * 0 =
437 * 1 <
438 * 2 >
439 * 3 unordered
440 */
441 switch (r) {
442 case float_relation_equal:
443 return 0;
444 case float_relation_less:
445 return 1;
446 case float_relation_greater:
447 return 2;
448 case float_relation_unordered:
449 env->fsr |= FSR_NVA;
450 return 3;
451 }
452 g_assert_not_reached();
453 }
454
helper_fcmps(CPUSPARCState * env,float32 src1,float32 src2)455 uint32_t helper_fcmps(CPUSPARCState *env, float32 src1, float32 src2)
456 {
457 FloatRelation r = float32_compare_quiet(src1, src2, &env->fp_status);
458 return finish_fcmp(env, r, GETPC());
459 }
460
helper_fcmpes(CPUSPARCState * env,float32 src1,float32 src2)461 uint32_t helper_fcmpes(CPUSPARCState *env, float32 src1, float32 src2)
462 {
463 FloatRelation r = float32_compare(src1, src2, &env->fp_status);
464 return finish_fcmp(env, r, GETPC());
465 }
466
helper_fcmpd(CPUSPARCState * env,float64 src1,float64 src2)467 uint32_t helper_fcmpd(CPUSPARCState *env, float64 src1, float64 src2)
468 {
469 FloatRelation r = float64_compare_quiet(src1, src2, &env->fp_status);
470 return finish_fcmp(env, r, GETPC());
471 }
472
helper_fcmped(CPUSPARCState * env,float64 src1,float64 src2)473 uint32_t helper_fcmped(CPUSPARCState *env, float64 src1, float64 src2)
474 {
475 FloatRelation r = float64_compare(src1, src2, &env->fp_status);
476 return finish_fcmp(env, r, GETPC());
477 }
478
helper_fcmpq(CPUSPARCState * env,Int128 src1,Int128 src2)479 uint32_t helper_fcmpq(CPUSPARCState *env, Int128 src1, Int128 src2)
480 {
481 FloatRelation r = float128_compare_quiet(f128_in(src1), f128_in(src2),
482 &env->fp_status);
483 return finish_fcmp(env, r, GETPC());
484 }
485
helper_fcmpeq(CPUSPARCState * env,Int128 src1,Int128 src2)486 uint32_t helper_fcmpeq(CPUSPARCState *env, Int128 src1, Int128 src2)
487 {
488 FloatRelation r = float128_compare(f128_in(src1), f128_in(src2),
489 &env->fp_status);
490 return finish_fcmp(env, r, GETPC());
491 }
492
helper_flcmps(float32 src1,float32 src2)493 uint32_t helper_flcmps(float32 src1, float32 src2)
494 {
495 /*
496 * FLCMP never raises an exception nor modifies any FSR fields.
497 * Perform the comparison with a dummy fp environment.
498 */
499 float_status discard = { };
500 FloatRelation r = float32_compare_quiet(src1, src2, &discard);
501
502 switch (r) {
503 case float_relation_equal:
504 if (src2 == float32_zero && src1 != float32_zero) {
505 return 1; /* -0.0 < +0.0 */
506 }
507 return 0;
508 case float_relation_less:
509 return 1;
510 case float_relation_greater:
511 return 0;
512 case float_relation_unordered:
513 return float32_is_any_nan(src2) ? 3 : 2;
514 }
515 g_assert_not_reached();
516 }
517
helper_flcmpd(float64 src1,float64 src2)518 uint32_t helper_flcmpd(float64 src1, float64 src2)
519 {
520 float_status discard = { };
521 FloatRelation r = float64_compare_quiet(src1, src2, &discard);
522
523 switch (r) {
524 case float_relation_equal:
525 if (src2 == float64_zero && src1 != float64_zero) {
526 return 1; /* -0.0 < +0.0 */
527 }
528 return 0;
529 case float_relation_less:
530 return 1;
531 case float_relation_greater:
532 return 0;
533 case float_relation_unordered:
534 return float64_is_any_nan(src2) ? 3 : 2;
535 }
536 g_assert_not_reached();
537 }
538
cpu_get_fsr(CPUSPARCState * env)539 target_ulong cpu_get_fsr(CPUSPARCState *env)
540 {
541 target_ulong fsr = env->fsr | env->fsr_cexc_ftt;
542
543 fsr |= env->fcc[0] << FSR_FCC0_SHIFT;
544 #ifdef TARGET_SPARC64
545 fsr |= (uint64_t)env->fcc[1] << FSR_FCC1_SHIFT;
546 fsr |= (uint64_t)env->fcc[2] << FSR_FCC2_SHIFT;
547 fsr |= (uint64_t)env->fcc[3] << FSR_FCC3_SHIFT;
548 #endif
549
550 /* VER is kept completely separate until re-assembly. */
551 fsr |= env->def.fpu_version;
552
553 return fsr;
554 }
555
helper_get_fsr(CPUSPARCState * env)556 target_ulong helper_get_fsr(CPUSPARCState *env)
557 {
558 return cpu_get_fsr(env);
559 }
560
set_fsr_nonsplit(CPUSPARCState * env,target_ulong fsr)561 static void set_fsr_nonsplit(CPUSPARCState *env, target_ulong fsr)
562 {
563 int rnd_mode;
564
565 env->fsr = fsr & (FSR_RD_MASK | FSR_TEM_MASK | FSR_AEXC_MASK);
566
567 switch (fsr & FSR_RD_MASK) {
568 case FSR_RD_NEAREST:
569 rnd_mode = float_round_nearest_even;
570 break;
571 default:
572 case FSR_RD_ZERO:
573 rnd_mode = float_round_to_zero;
574 break;
575 case FSR_RD_POS:
576 rnd_mode = float_round_up;
577 break;
578 case FSR_RD_NEG:
579 rnd_mode = float_round_down;
580 break;
581 }
582 set_float_rounding_mode(rnd_mode, &env->fp_status);
583 }
584
cpu_put_fsr(CPUSPARCState * env,target_ulong fsr)585 void cpu_put_fsr(CPUSPARCState *env, target_ulong fsr)
586 {
587 env->fsr_cexc_ftt = fsr & (FSR_CEXC_MASK | FSR_FTT_MASK);
588
589 env->fcc[0] = extract32(fsr, FSR_FCC0_SHIFT, 2);
590 #ifdef TARGET_SPARC64
591 env->fcc[1] = extract64(fsr, FSR_FCC1_SHIFT, 2);
592 env->fcc[2] = extract64(fsr, FSR_FCC2_SHIFT, 2);
593 env->fcc[3] = extract64(fsr, FSR_FCC3_SHIFT, 2);
594 #endif
595
596 set_fsr_nonsplit(env, fsr);
597 }
598
helper_set_fsr_nofcc_noftt(CPUSPARCState * env,uint32_t fsr)599 void helper_set_fsr_nofcc_noftt(CPUSPARCState *env, uint32_t fsr)
600 {
601 env->fsr_cexc_ftt &= FSR_FTT_MASK;
602 env->fsr_cexc_ftt |= fsr & FSR_CEXC_MASK;
603 set_fsr_nonsplit(env, fsr);
604 }
605
helper_set_fsr_nofcc(CPUSPARCState * env,uint32_t fsr)606 void helper_set_fsr_nofcc(CPUSPARCState *env, uint32_t fsr)
607 {
608 env->fsr_cexc_ftt = fsr & (FSR_CEXC_MASK | FSR_FTT_MASK);
609 set_fsr_nonsplit(env, fsr);
610 }
611