2 * S/390 FPU helper routines
4 * Copyright (c) 2009 Ulrich Hecht
5 * Copyright (c) 2009 Alexander Graf
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21 #include "qemu/osdep.h"
23 #include "s390x-internal.h"
24 #include "tcg_s390x.h"
25 #include "exec/exec-all.h"
26 #include "exec/cpu_ldst.h"
27 #include "exec/helper-proto.h"
28 #include "fpu/softfloat.h"
30 /* #define DEBUG_HELPER */
32 #define HELPER_LOG(x...) qemu_log(x)
34 #define HELPER_LOG(x...)
37 static inline Int128
RET128(float128 f
)
39 return int128_make128(f
.low
, f
.high
);
42 static inline float128
ARG128(Int128 i
)
44 return make_float128(int128_gethi(i
), int128_getlo(i
));
47 uint8_t s390_softfloat_exc_to_ieee(unsigned int exc
)
51 s390_exc
|= (exc
& float_flag_invalid
) ? S390_IEEE_MASK_INVALID
: 0;
52 s390_exc
|= (exc
& float_flag_divbyzero
) ? S390_IEEE_MASK_DIVBYZERO
: 0;
53 s390_exc
|= (exc
& float_flag_overflow
) ? S390_IEEE_MASK_OVERFLOW
: 0;
54 s390_exc
|= (exc
& float_flag_underflow
) ? S390_IEEE_MASK_UNDERFLOW
: 0;
55 s390_exc
|= (exc
& float_flag_inexact
) ? S390_IEEE_MASK_INEXACT
: 0;
60 /* Should be called after any operation that may raise IEEE exceptions. */
61 static void handle_exceptions(CPUS390XState
*env
, bool XxC
, uintptr_t retaddr
)
63 unsigned s390_exc
, qemu_exc
;
65 /* Get the exceptions raised by the current operation. Reset the
66 fpu_status contents so that the next operation has a clean slate. */
67 qemu_exc
= env
->fpu_status
.float_exception_flags
;
71 env
->fpu_status
.float_exception_flags
= 0;
72 s390_exc
= s390_softfloat_exc_to_ieee(qemu_exc
);
75 * IEEE-Underflow exception recognition exists if a tininess condition
76 * (underflow) exists and
77 * - The mask bit in the FPC is zero and the result is inexact
78 * - The mask bit in the FPC is one
79 * So tininess conditions that are not inexact don't trigger any
80 * underflow action in case the mask bit is not one.
82 if (!(s390_exc
& S390_IEEE_MASK_INEXACT
) &&
83 !((env
->fpc
>> 24) & S390_IEEE_MASK_UNDERFLOW
)) {
84 s390_exc
&= ~S390_IEEE_MASK_UNDERFLOW
;
89 * 1. Right now, all inexact conditions are inidicated as
90 * "truncated" (0) and never as "incremented" (1) in the DXC.
91 * 2. Only traps due to invalid/divbyzero are suppressing. Other traps
92 * are completing, meaning the target register has to be written!
93 * This, however will mean that we have to write the register before
94 * triggering the trap - impossible right now.
98 * invalid/divbyzero cannot coexist with other conditions.
99 * overflow/underflow however can coexist with inexact, we have to
100 * handle it separately.
102 if (s390_exc
& ~S390_IEEE_MASK_INEXACT
) {
103 if (s390_exc
& ~S390_IEEE_MASK_INEXACT
& env
->fpc
>> 24) {
104 /* trap condition - inexact reported along */
105 tcg_s390_data_exception(env
, s390_exc
, retaddr
);
107 /* nontrap condition - inexact handled differently */
108 env
->fpc
|= (s390_exc
& ~S390_IEEE_MASK_INEXACT
) << 16;
111 /* inexact handling */
112 if (s390_exc
& S390_IEEE_MASK_INEXACT
&& !XxC
) {
113 /* trap condition - overflow/underflow _not_ reported along */
114 if (s390_exc
& S390_IEEE_MASK_INEXACT
& env
->fpc
>> 24) {
115 tcg_s390_data_exception(env
, s390_exc
& S390_IEEE_MASK_INEXACT
,
118 /* nontrap condition */
119 env
->fpc
|= (s390_exc
& S390_IEEE_MASK_INEXACT
) << 16;
123 int float_comp_to_cc(CPUS390XState
*env
, FloatRelation float_compare
)
125 switch (float_compare
) {
126 case float_relation_equal
:
128 case float_relation_less
:
130 case float_relation_greater
:
132 case float_relation_unordered
:
135 cpu_abort(env_cpu(env
), "unknown return value for float compare\n");
139 /* condition codes for unary FP ops */
140 uint32_t set_cc_nz_f32(float32 v
)
142 if (float32_is_any_nan(v
)) {
144 } else if (float32_is_zero(v
)) {
146 } else if (float32_is_neg(v
)) {
153 uint32_t set_cc_nz_f64(float64 v
)
155 if (float64_is_any_nan(v
)) {
157 } else if (float64_is_zero(v
)) {
159 } else if (float64_is_neg(v
)) {
166 uint32_t set_cc_nz_f128(float128 v
)
168 if (float128_is_any_nan(v
)) {
170 } else if (float128_is_zero(v
)) {
172 } else if (float128_is_neg(v
)) {
179 /* condition codes for FP to integer conversion ops */
180 static uint32_t set_cc_conv_f32(float32 v
, float_status
*stat
)
182 if (stat
->float_exception_flags
& float_flag_invalid
) {
185 return set_cc_nz_f32(v
);
189 static uint32_t set_cc_conv_f64(float64 v
, float_status
*stat
)
191 if (stat
->float_exception_flags
& float_flag_invalid
) {
194 return set_cc_nz_f64(v
);
198 static uint32_t set_cc_conv_f128(float128 v
, float_status
*stat
)
200 if (stat
->float_exception_flags
& float_flag_invalid
) {
203 return set_cc_nz_f128(v
);
207 static inline uint8_t round_from_m34(uint32_t m34
)
209 return extract32(m34
, 0, 4);
212 static inline bool xxc_from_m34(uint32_t m34
)
214 /* XxC is bit 1 of m4 */
215 return extract32(m34
, 4 + 3 - 1, 1);
218 /* 32-bit FP addition */
219 uint64_t HELPER(aeb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
221 float32 ret
= float32_add(f1
, f2
, &env
->fpu_status
);
222 handle_exceptions(env
, false, GETPC());
226 /* 64-bit FP addition */
227 uint64_t HELPER(adb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
229 float64 ret
= float64_add(f1
, f2
, &env
->fpu_status
);
230 handle_exceptions(env
, false, GETPC());
234 /* 128-bit FP addition */
235 Int128
HELPER(axb
)(CPUS390XState
*env
, Int128 a
, Int128 b
)
237 float128 ret
= float128_add(ARG128(a
), ARG128(b
), &env
->fpu_status
);
238 handle_exceptions(env
, false, GETPC());
242 /* 32-bit FP subtraction */
243 uint64_t HELPER(seb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
245 float32 ret
= float32_sub(f1
, f2
, &env
->fpu_status
);
246 handle_exceptions(env
, false, GETPC());
250 /* 64-bit FP subtraction */
251 uint64_t HELPER(sdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
253 float64 ret
= float64_sub(f1
, f2
, &env
->fpu_status
);
254 handle_exceptions(env
, false, GETPC());
258 /* 128-bit FP subtraction */
259 Int128
HELPER(sxb
)(CPUS390XState
*env
, Int128 a
, Int128 b
)
261 float128 ret
= float128_sub(ARG128(a
), ARG128(b
), &env
->fpu_status
);
262 handle_exceptions(env
, false, GETPC());
266 /* 32-bit FP division */
267 uint64_t HELPER(deb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
269 float32 ret
= float32_div(f1
, f2
, &env
->fpu_status
);
270 handle_exceptions(env
, false, GETPC());
274 /* 64-bit FP division */
275 uint64_t HELPER(ddb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
277 float64 ret
= float64_div(f1
, f2
, &env
->fpu_status
);
278 handle_exceptions(env
, false, GETPC());
282 /* 128-bit FP division */
283 Int128
HELPER(dxb
)(CPUS390XState
*env
, Int128 a
, Int128 b
)
285 float128 ret
= float128_div(ARG128(a
), ARG128(b
), &env
->fpu_status
);
286 handle_exceptions(env
, false, GETPC());
290 /* 32-bit FP multiplication */
291 uint64_t HELPER(meeb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
293 float32 ret
= float32_mul(f1
, f2
, &env
->fpu_status
);
294 handle_exceptions(env
, false, GETPC());
298 /* 64-bit FP multiplication */
299 uint64_t HELPER(mdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
301 float64 ret
= float64_mul(f1
, f2
, &env
->fpu_status
);
302 handle_exceptions(env
, false, GETPC());
306 /* 64/32-bit FP multiplication */
307 uint64_t HELPER(mdeb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
309 float64 ret
= float32_to_float64(f2
, &env
->fpu_status
);
310 ret
= float64_mul(f1
, ret
, &env
->fpu_status
);
311 handle_exceptions(env
, false, GETPC());
315 /* 128-bit FP multiplication */
316 Int128
HELPER(mxb
)(CPUS390XState
*env
, Int128 a
, Int128 b
)
318 float128 ret
= float128_mul(ARG128(a
), ARG128(b
), &env
->fpu_status
);
319 handle_exceptions(env
, false, GETPC());
323 /* 128/64-bit FP multiplication */
324 Int128
HELPER(mxdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
326 float128 f1_128
= float64_to_float128(f1
, &env
->fpu_status
);
327 float128 ret
= float64_to_float128(f2
, &env
->fpu_status
);
328 ret
= float128_mul(f1_128
, ret
, &env
->fpu_status
);
329 handle_exceptions(env
, false, GETPC());
333 /* convert 32-bit float to 64-bit float */
334 uint64_t HELPER(ldeb
)(CPUS390XState
*env
, uint64_t f2
)
336 float64 ret
= float32_to_float64(f2
, &env
->fpu_status
);
337 handle_exceptions(env
, false, GETPC());
341 /* convert 128-bit float to 64-bit float */
342 uint64_t HELPER(ldxb
)(CPUS390XState
*env
, Int128 a
, uint32_t m34
)
344 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
345 float64 ret
= float128_to_float64(ARG128(a
), &env
->fpu_status
);
347 s390_restore_bfp_rounding_mode(env
, old_mode
);
348 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
352 /* convert 64-bit float to 128-bit float */
353 Int128
HELPER(lxdb
)(CPUS390XState
*env
, uint64_t f2
)
355 float128 ret
= float64_to_float128(f2
, &env
->fpu_status
);
356 handle_exceptions(env
, false, GETPC());
360 /* convert 32-bit float to 128-bit float */
361 Int128
HELPER(lxeb
)(CPUS390XState
*env
, uint64_t f2
)
363 float128 ret
= float32_to_float128(f2
, &env
->fpu_status
);
364 handle_exceptions(env
, false, GETPC());
368 /* convert 64-bit float to 32-bit float */
369 uint64_t HELPER(ledb
)(CPUS390XState
*env
, uint64_t f2
, uint32_t m34
)
371 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
372 float32 ret
= float64_to_float32(f2
, &env
->fpu_status
);
374 s390_restore_bfp_rounding_mode(env
, old_mode
);
375 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
379 /* convert 128-bit float to 32-bit float */
380 uint64_t HELPER(lexb
)(CPUS390XState
*env
, Int128 a
, uint32_t m34
)
382 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
383 float32 ret
= float128_to_float32(ARG128(a
), &env
->fpu_status
);
385 s390_restore_bfp_rounding_mode(env
, old_mode
);
386 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
390 /* 32-bit FP compare */
391 uint32_t HELPER(ceb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
393 FloatRelation cmp
= float32_compare_quiet(f1
, f2
, &env
->fpu_status
);
394 handle_exceptions(env
, false, GETPC());
395 return float_comp_to_cc(env
, cmp
);
398 /* 64-bit FP compare */
399 uint32_t HELPER(cdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
401 FloatRelation cmp
= float64_compare_quiet(f1
, f2
, &env
->fpu_status
);
402 handle_exceptions(env
, false, GETPC());
403 return float_comp_to_cc(env
, cmp
);
406 /* 128-bit FP compare */
407 uint32_t HELPER(cxb
)(CPUS390XState
*env
, Int128 a
, Int128 b
)
409 FloatRelation cmp
= float128_compare_quiet(ARG128(a
), ARG128(b
),
411 handle_exceptions(env
, false, GETPC());
412 return float_comp_to_cc(env
, cmp
);
415 int s390_swap_bfp_rounding_mode(CPUS390XState
*env
, int m3
)
417 int ret
= env
->fpu_status
.float_rounding_mode
;
424 /* round to nearest with ties away from 0 */
425 set_float_rounding_mode(float_round_ties_away
, &env
->fpu_status
);
428 /* round to prepare for shorter precision */
429 set_float_rounding_mode(float_round_to_odd
, &env
->fpu_status
);
432 /* round to nearest with ties to even */
433 set_float_rounding_mode(float_round_nearest_even
, &env
->fpu_status
);
437 set_float_rounding_mode(float_round_to_zero
, &env
->fpu_status
);
441 set_float_rounding_mode(float_round_up
, &env
->fpu_status
);
445 set_float_rounding_mode(float_round_down
, &env
->fpu_status
);
448 g_assert_not_reached();
453 void s390_restore_bfp_rounding_mode(CPUS390XState
*env
, int old_mode
)
455 set_float_rounding_mode(old_mode
, &env
->fpu_status
);
458 /* convert 64-bit int to 32-bit float */
459 uint64_t HELPER(cegb
)(CPUS390XState
*env
, int64_t v2
, uint32_t m34
)
461 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
462 float32 ret
= int64_to_float32(v2
, &env
->fpu_status
);
464 s390_restore_bfp_rounding_mode(env
, old_mode
);
465 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
469 /* convert 64-bit int to 64-bit float */
470 uint64_t HELPER(cdgb
)(CPUS390XState
*env
, int64_t v2
, uint32_t m34
)
472 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
473 float64 ret
= int64_to_float64(v2
, &env
->fpu_status
);
475 s390_restore_bfp_rounding_mode(env
, old_mode
);
476 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
480 /* convert 64-bit int to 128-bit float */
481 Int128
HELPER(cxgb
)(CPUS390XState
*env
, int64_t v2
, uint32_t m34
)
483 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
484 float128 ret
= int64_to_float128(v2
, &env
->fpu_status
);
486 s390_restore_bfp_rounding_mode(env
, old_mode
);
487 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
491 /* convert 64-bit uint to 32-bit float */
492 uint64_t HELPER(celgb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
494 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
495 float32 ret
= uint64_to_float32(v2
, &env
->fpu_status
);
497 s390_restore_bfp_rounding_mode(env
, old_mode
);
498 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
502 /* convert 64-bit uint to 64-bit float */
503 uint64_t HELPER(cdlgb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
505 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
506 float64 ret
= uint64_to_float64(v2
, &env
->fpu_status
);
508 s390_restore_bfp_rounding_mode(env
, old_mode
);
509 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
513 /* convert 64-bit uint to 128-bit float */
514 Int128
HELPER(cxlgb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
516 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
517 float128 ret
= uint64_to_float128(v2
, &env
->fpu_status
);
519 s390_restore_bfp_rounding_mode(env
, old_mode
);
520 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
524 /* convert 32-bit float to 64-bit int */
525 uint64_t HELPER(cgeb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
527 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
528 int64_t ret
= float32_to_int64(v2
, &env
->fpu_status
);
529 uint32_t cc
= set_cc_conv_f32(v2
, &env
->fpu_status
);
531 s390_restore_bfp_rounding_mode(env
, old_mode
);
532 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
534 if (float32_is_any_nan(v2
)) {
540 /* convert 64-bit float to 64-bit int */
541 uint64_t HELPER(cgdb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
543 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
544 int64_t ret
= float64_to_int64(v2
, &env
->fpu_status
);
545 uint32_t cc
= set_cc_conv_f64(v2
, &env
->fpu_status
);
547 s390_restore_bfp_rounding_mode(env
, old_mode
);
548 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
550 if (float64_is_any_nan(v2
)) {
556 /* convert 128-bit float to 64-bit int */
557 uint64_t HELPER(cgxb
)(CPUS390XState
*env
, Int128 i2
, uint32_t m34
)
559 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
560 float128 v2
= ARG128(i2
);
561 int64_t ret
= float128_to_int64(v2
, &env
->fpu_status
);
562 uint32_t cc
= set_cc_conv_f128(v2
, &env
->fpu_status
);
564 s390_restore_bfp_rounding_mode(env
, old_mode
);
565 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
567 if (float128_is_any_nan(v2
)) {
573 /* convert 32-bit float to 32-bit int */
574 uint64_t HELPER(cfeb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
576 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
577 int32_t ret
= float32_to_int32(v2
, &env
->fpu_status
);
578 uint32_t cc
= set_cc_conv_f32(v2
, &env
->fpu_status
);
580 s390_restore_bfp_rounding_mode(env
, old_mode
);
581 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
583 if (float32_is_any_nan(v2
)) {
589 /* convert 64-bit float to 32-bit int */
590 uint64_t HELPER(cfdb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
592 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
593 int32_t ret
= float64_to_int32(v2
, &env
->fpu_status
);
594 uint32_t cc
= set_cc_conv_f64(v2
, &env
->fpu_status
);
596 s390_restore_bfp_rounding_mode(env
, old_mode
);
597 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
599 if (float64_is_any_nan(v2
)) {
605 /* convert 128-bit float to 32-bit int */
606 uint64_t HELPER(cfxb
)(CPUS390XState
*env
, Int128 i2
, uint32_t m34
)
608 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
609 float128 v2
= ARG128(i2
);
610 int32_t ret
= float128_to_int32(v2
, &env
->fpu_status
);
611 uint32_t cc
= set_cc_conv_f128(v2
, &env
->fpu_status
);
613 s390_restore_bfp_rounding_mode(env
, old_mode
);
614 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
616 if (float128_is_any_nan(v2
)) {
622 /* convert 32-bit float to 64-bit uint */
623 uint64_t HELPER(clgeb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
625 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
626 uint64_t ret
= float32_to_uint64(v2
, &env
->fpu_status
);
627 uint32_t cc
= set_cc_conv_f32(v2
, &env
->fpu_status
);
629 s390_restore_bfp_rounding_mode(env
, old_mode
);
630 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
632 if (float32_is_any_nan(v2
)) {
638 /* convert 64-bit float to 64-bit uint */
639 uint64_t HELPER(clgdb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
641 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
642 uint64_t ret
= float64_to_uint64(v2
, &env
->fpu_status
);
643 uint32_t cc
= set_cc_conv_f64(v2
, &env
->fpu_status
);
645 s390_restore_bfp_rounding_mode(env
, old_mode
);
646 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
648 if (float64_is_any_nan(v2
)) {
654 /* convert 128-bit float to 64-bit uint */
655 uint64_t HELPER(clgxb
)(CPUS390XState
*env
, Int128 i2
, uint32_t m34
)
657 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
658 float128 v2
= ARG128(i2
);
659 uint64_t ret
= float128_to_uint64(v2
, &env
->fpu_status
);
660 uint32_t cc
= set_cc_conv_f128(v2
, &env
->fpu_status
);
662 s390_restore_bfp_rounding_mode(env
, old_mode
);
663 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
665 if (float128_is_any_nan(v2
)) {
671 /* convert 32-bit float to 32-bit uint */
672 uint64_t HELPER(clfeb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
674 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
675 uint32_t ret
= float32_to_uint32(v2
, &env
->fpu_status
);
676 uint32_t cc
= set_cc_conv_f32(v2
, &env
->fpu_status
);
678 s390_restore_bfp_rounding_mode(env
, old_mode
);
679 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
681 if (float32_is_any_nan(v2
)) {
687 /* convert 64-bit float to 32-bit uint */
688 uint64_t HELPER(clfdb
)(CPUS390XState
*env
, uint64_t v2
, uint32_t m34
)
690 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
691 uint32_t ret
= float64_to_uint32(v2
, &env
->fpu_status
);
692 uint32_t cc
= set_cc_conv_f64(v2
, &env
->fpu_status
);
694 s390_restore_bfp_rounding_mode(env
, old_mode
);
695 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
697 if (float64_is_any_nan(v2
)) {
703 /* convert 128-bit float to 32-bit uint */
704 uint64_t HELPER(clfxb
)(CPUS390XState
*env
, Int128 i2
, uint32_t m34
)
706 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
707 float128 v2
= ARG128(i2
);
708 uint32_t ret
= float128_to_uint32(v2
, &env
->fpu_status
);
709 uint32_t cc
= set_cc_conv_f128(v2
, &env
->fpu_status
);
711 s390_restore_bfp_rounding_mode(env
, old_mode
);
712 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
714 if (float128_is_any_nan(v2
)) {
720 /* round to integer 32-bit */
721 uint64_t HELPER(fieb
)(CPUS390XState
*env
, uint64_t f2
, uint32_t m34
)
723 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
724 float32 ret
= float32_round_to_int(f2
, &env
->fpu_status
);
726 s390_restore_bfp_rounding_mode(env
, old_mode
);
727 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
731 /* round to integer 64-bit */
732 uint64_t HELPER(fidb
)(CPUS390XState
*env
, uint64_t f2
, uint32_t m34
)
734 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
735 float64 ret
= float64_round_to_int(f2
, &env
->fpu_status
);
737 s390_restore_bfp_rounding_mode(env
, old_mode
);
738 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
742 /* round to integer 128-bit */
743 Int128
HELPER(fixb
)(CPUS390XState
*env
, Int128 a
, uint32_t m34
)
745 int old_mode
= s390_swap_bfp_rounding_mode(env
, round_from_m34(m34
));
746 float128 ret
= float128_round_to_int(ARG128(a
), &env
->fpu_status
);
748 s390_restore_bfp_rounding_mode(env
, old_mode
);
749 handle_exceptions(env
, xxc_from_m34(m34
), GETPC());
753 /* 32-bit FP compare and signal */
754 uint32_t HELPER(keb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
756 FloatRelation cmp
= float32_compare(f1
, f2
, &env
->fpu_status
);
757 handle_exceptions(env
, false, GETPC());
758 return float_comp_to_cc(env
, cmp
);
761 /* 64-bit FP compare and signal */
762 uint32_t HELPER(kdb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t f2
)
764 FloatRelation cmp
= float64_compare(f1
, f2
, &env
->fpu_status
);
765 handle_exceptions(env
, false, GETPC());
766 return float_comp_to_cc(env
, cmp
);
769 /* 128-bit FP compare and signal */
770 uint32_t HELPER(kxb
)(CPUS390XState
*env
, Int128 a
, Int128 b
)
772 FloatRelation cmp
= float128_compare(ARG128(a
), ARG128(b
),
774 handle_exceptions(env
, false, GETPC());
775 return float_comp_to_cc(env
, cmp
);
778 /* 32-bit FP multiply and add */
779 uint64_t HELPER(maeb
)(CPUS390XState
*env
, uint64_t f1
,
780 uint64_t f2
, uint64_t f3
)
782 float32 ret
= float32_muladd(f2
, f3
, f1
, 0, &env
->fpu_status
);
783 handle_exceptions(env
, false, GETPC());
787 /* 64-bit FP multiply and add */
788 uint64_t HELPER(madb
)(CPUS390XState
*env
, uint64_t f1
,
789 uint64_t f2
, uint64_t f3
)
791 float64 ret
= float64_muladd(f2
, f3
, f1
, 0, &env
->fpu_status
);
792 handle_exceptions(env
, false, GETPC());
796 /* 32-bit FP multiply and subtract */
797 uint64_t HELPER(mseb
)(CPUS390XState
*env
, uint64_t f1
,
798 uint64_t f2
, uint64_t f3
)
800 float32 ret
= float32_muladd(f2
, f3
, f1
, float_muladd_negate_c
,
802 handle_exceptions(env
, false, GETPC());
806 /* 64-bit FP multiply and subtract */
807 uint64_t HELPER(msdb
)(CPUS390XState
*env
, uint64_t f1
,
808 uint64_t f2
, uint64_t f3
)
810 float64 ret
= float64_muladd(f2
, f3
, f1
, float_muladd_negate_c
,
812 handle_exceptions(env
, false, GETPC());
816 /* The rightmost bit has the number 11. */
817 static inline uint16_t dcmask(int bit
, bool neg
)
819 return 1 << (11 - bit
- neg
);
822 #define DEF_FLOAT_DCMASK(_TYPE) \
823 uint16_t _TYPE##_dcmask(CPUS390XState *env, _TYPE f1) \
825 const bool neg = _TYPE##_is_neg(f1); \
827 /* Sorted by most common cases - only one class is possible */ \
828 if (_TYPE##_is_normal(f1)) { \
829 return dcmask(2, neg); \
830 } else if (_TYPE##_is_zero(f1)) { \
831 return dcmask(0, neg); \
832 } else if (_TYPE##_is_denormal(f1)) { \
833 return dcmask(4, neg); \
834 } else if (_TYPE##_is_infinity(f1)) { \
835 return dcmask(6, neg); \
836 } else if (_TYPE##_is_quiet_nan(f1, &env->fpu_status)) { \
837 return dcmask(8, neg); \
839 /* signaling nan, as last remaining case */ \
840 return dcmask(10, neg); \
842 DEF_FLOAT_DCMASK(float32
)
843 DEF_FLOAT_DCMASK(float64
)
844 DEF_FLOAT_DCMASK(float128
)
846 /* test data class 32-bit */
847 uint32_t HELPER(tceb
)(CPUS390XState
*env
, uint64_t f1
, uint64_t m2
)
849 return (m2
& float32_dcmask(env
, f1
)) != 0;
852 /* test data class 64-bit */
853 uint32_t HELPER(tcdb
)(CPUS390XState
*env
, uint64_t v1
, uint64_t m2
)
855 return (m2
& float64_dcmask(env
, v1
)) != 0;
858 /* test data class 128-bit */
859 uint32_t HELPER(tcxb
)(CPUS390XState
*env
, Int128 a
, uint64_t m2
)
861 return (m2
& float128_dcmask(env
, ARG128(a
))) != 0;
864 /* square root 32-bit */
865 uint64_t HELPER(sqeb
)(CPUS390XState
*env
, uint64_t f2
)
867 float32 ret
= float32_sqrt(f2
, &env
->fpu_status
);
868 handle_exceptions(env
, false, GETPC());
872 /* square root 64-bit */
873 uint64_t HELPER(sqdb
)(CPUS390XState
*env
, uint64_t f2
)
875 float64 ret
= float64_sqrt(f2
, &env
->fpu_status
);
876 handle_exceptions(env
, false, GETPC());
880 /* square root 128-bit */
881 Int128
HELPER(sqxb
)(CPUS390XState
*env
, Int128 a
)
883 float128 ret
= float128_sqrt(ARG128(a
), &env
->fpu_status
);
884 handle_exceptions(env
, false, GETPC());
888 static const int fpc_to_rnd
[8] = {
889 float_round_nearest_even
,
900 void HELPER(sfpc
)(CPUS390XState
*env
, uint64_t fpc
)
902 if (fpc_to_rnd
[fpc
& 0x7] == -1 || fpc
& 0x03030088u
||
903 (!s390_has_feat(S390_FEAT_FLOATING_POINT_EXT
) && fpc
& 0x4)) {
904 tcg_s390_program_interrupt(env
, PGM_SPECIFICATION
, GETPC());
907 /* Install everything in the main FPC. */
910 /* Install the rounding mode in the shadow fpu_status. */
911 set_float_rounding_mode(fpc_to_rnd
[fpc
& 0x7], &env
->fpu_status
);
914 /* set fpc and signal */
915 void HELPER(sfas
)(CPUS390XState
*env
, uint64_t fpc
)
917 uint32_t signalling
= env
->fpc
;
920 if (fpc_to_rnd
[fpc
& 0x7] == -1 || fpc
& 0x03030088u
||
921 (!s390_has_feat(S390_FEAT_FLOATING_POINT_EXT
) && fpc
& 0x4)) {
922 tcg_s390_program_interrupt(env
, PGM_SPECIFICATION
, GETPC());
926 * FPC is set to the FPC operand with a bitwise OR of the signalling
929 env
->fpc
= fpc
| (signalling
& 0x00ff0000);
930 set_float_rounding_mode(fpc_to_rnd
[fpc
& 0x7], &env
->fpu_status
);
933 * If any signaling flag is enabled in the new FPC mask, a
934 * simulated-iee-exception exception occurs.
936 s390_exc
= (signalling
>> 16) & (fpc
>> 24);
938 if (s390_exc
& S390_IEEE_MASK_INVALID
) {
939 s390_exc
= S390_IEEE_MASK_INVALID
;
940 } else if (s390_exc
& S390_IEEE_MASK_DIVBYZERO
) {
941 s390_exc
= S390_IEEE_MASK_DIVBYZERO
;
942 } else if (s390_exc
& S390_IEEE_MASK_OVERFLOW
) {
943 s390_exc
&= (S390_IEEE_MASK_OVERFLOW
| S390_IEEE_MASK_INEXACT
);
944 } else if (s390_exc
& S390_IEEE_MASK_UNDERFLOW
) {
945 s390_exc
&= (S390_IEEE_MASK_UNDERFLOW
| S390_IEEE_MASK_INEXACT
);
946 } else if (s390_exc
& S390_IEEE_MASK_INEXACT
) {
947 s390_exc
= S390_IEEE_MASK_INEXACT
;
948 } else if (s390_exc
& S390_IEEE_MASK_QUANTUM
) {
949 s390_exc
= S390_IEEE_MASK_QUANTUM
;
951 tcg_s390_data_exception(env
, s390_exc
| 3, GETPC());
955 /* set bfp rounding mode */
956 void HELPER(srnm
)(CPUS390XState
*env
, uint64_t rnd
)
958 if (rnd
> 0x7 || fpc_to_rnd
[rnd
& 0x7] == -1) {
959 tcg_s390_program_interrupt(env
, PGM_SPECIFICATION
, GETPC());
962 env
->fpc
= deposit32(env
->fpc
, 0, 3, rnd
);
963 set_float_rounding_mode(fpc_to_rnd
[rnd
& 0x7], &env
->fpu_status
);