]>
git.proxmox.com Git - qemu.git/blob - target-ppc/fpu_helper.c
2 * PowerPC floating point and SPE emulation helpers for QEMU.
4 * Copyright (c) 2003-2007 Jocelyn Mayer
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 of the License, or (at your option) any later version.
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.
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/>.
22 /*****************************************************************************/
23 /* Floating point operations helpers */
24 uint64_t helper_float32_to_float64(CPUPPCState
*env
, uint32_t arg
)
30 d
.d
= float32_to_float64(f
.f
, &env
->fp_status
);
34 uint32_t helper_float64_to_float32(CPUPPCState
*env
, uint64_t arg
)
40 f
.f
= float64_to_float32(d
.d
, &env
->fp_status
);
44 static inline int isden(float64 d
)
50 return ((u
.ll
>> 52) & 0x7FF) == 0;
53 uint32_t helper_compute_fprf(CPUPPCState
*env
, uint64_t arg
, uint32_t set_fprf
)
60 isneg
= float64_is_neg(farg
.d
);
61 if (unlikely(float64_is_any_nan(farg
.d
))) {
62 if (float64_is_signaling_nan(farg
.d
)) {
63 /* Signaling NaN: flags are undefined */
69 } else if (unlikely(float64_is_infinity(farg
.d
))) {
77 if (float64_is_zero(farg
.d
)) {
86 /* Denormalized numbers */
89 /* Normalized numbers */
100 /* We update FPSCR_FPRF */
101 env
->fpscr
&= ~(0x1F << FPSCR_FPRF
);
102 env
->fpscr
|= ret
<< FPSCR_FPRF
;
104 /* We just need fpcc to update Rc1 */
108 /* Floating-point invalid operations exception */
109 static inline uint64_t fload_invalid_op_excp(CPUPPCState
*env
, int op
)
116 case POWERPC_EXCP_FP_VXSNAN
:
117 env
->fpscr
|= 1 << FPSCR_VXSNAN
;
119 case POWERPC_EXCP_FP_VXSOFT
:
120 env
->fpscr
|= 1 << FPSCR_VXSOFT
;
122 case POWERPC_EXCP_FP_VXISI
:
123 /* Magnitude subtraction of infinities */
124 env
->fpscr
|= 1 << FPSCR_VXISI
;
126 case POWERPC_EXCP_FP_VXIDI
:
127 /* Division of infinity by infinity */
128 env
->fpscr
|= 1 << FPSCR_VXIDI
;
130 case POWERPC_EXCP_FP_VXZDZ
:
131 /* Division of zero by zero */
132 env
->fpscr
|= 1 << FPSCR_VXZDZ
;
134 case POWERPC_EXCP_FP_VXIMZ
:
135 /* Multiplication of zero by infinity */
136 env
->fpscr
|= 1 << FPSCR_VXIMZ
;
138 case POWERPC_EXCP_FP_VXVC
:
139 /* Ordered comparison of NaN */
140 env
->fpscr
|= 1 << FPSCR_VXVC
;
141 env
->fpscr
&= ~(0xF << FPSCR_FPCC
);
142 env
->fpscr
|= 0x11 << FPSCR_FPCC
;
143 /* We must update the target FPR before raising the exception */
145 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
146 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_VXVC
;
147 /* Update the floating-point enabled exception summary */
148 env
->fpscr
|= 1 << FPSCR_FEX
;
149 /* Exception is differed */
153 case POWERPC_EXCP_FP_VXSQRT
:
154 /* Square root of a negative number */
155 env
->fpscr
|= 1 << FPSCR_VXSQRT
;
157 env
->fpscr
&= ~((1 << FPSCR_FR
) | (1 << FPSCR_FI
));
159 /* Set the result to quiet NaN */
160 ret
= 0x7FF8000000000000ULL
;
161 env
->fpscr
&= ~(0xF << FPSCR_FPCC
);
162 env
->fpscr
|= 0x11 << FPSCR_FPCC
;
165 case POWERPC_EXCP_FP_VXCVI
:
166 /* Invalid conversion */
167 env
->fpscr
|= 1 << FPSCR_VXCVI
;
168 env
->fpscr
&= ~((1 << FPSCR_FR
) | (1 << FPSCR_FI
));
170 /* Set the result to quiet NaN */
171 ret
= 0x7FF8000000000000ULL
;
172 env
->fpscr
&= ~(0xF << FPSCR_FPCC
);
173 env
->fpscr
|= 0x11 << FPSCR_FPCC
;
177 /* Update the floating-point invalid operation summary */
178 env
->fpscr
|= 1 << FPSCR_VX
;
179 /* Update the floating-point exception summary */
180 env
->fpscr
|= 1 << FPSCR_FX
;
182 /* Update the floating-point enabled exception summary */
183 env
->fpscr
|= 1 << FPSCR_FEX
;
184 if (msr_fe0
!= 0 || msr_fe1
!= 0) {
185 helper_raise_exception_err(env
, POWERPC_EXCP_PROGRAM
,
186 POWERPC_EXCP_FP
| op
);
192 static inline void float_zero_divide_excp(CPUPPCState
*env
)
194 env
->fpscr
|= 1 << FPSCR_ZX
;
195 env
->fpscr
&= ~((1 << FPSCR_FR
) | (1 << FPSCR_FI
));
196 /* Update the floating-point exception summary */
197 env
->fpscr
|= 1 << FPSCR_FX
;
199 /* Update the floating-point enabled exception summary */
200 env
->fpscr
|= 1 << FPSCR_FEX
;
201 if (msr_fe0
!= 0 || msr_fe1
!= 0) {
202 helper_raise_exception_err(env
, POWERPC_EXCP_PROGRAM
,
203 POWERPC_EXCP_FP
| POWERPC_EXCP_FP_ZX
);
208 static inline void float_overflow_excp(CPUPPCState
*env
)
210 env
->fpscr
|= 1 << FPSCR_OX
;
211 /* Update the floating-point exception summary */
212 env
->fpscr
|= 1 << FPSCR_FX
;
214 /* XXX: should adjust the result */
215 /* Update the floating-point enabled exception summary */
216 env
->fpscr
|= 1 << FPSCR_FEX
;
217 /* We must update the target FPR before raising the exception */
218 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
219 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_OX
;
221 env
->fpscr
|= 1 << FPSCR_XX
;
222 env
->fpscr
|= 1 << FPSCR_FI
;
226 static inline void float_underflow_excp(CPUPPCState
*env
)
228 env
->fpscr
|= 1 << FPSCR_UX
;
229 /* Update the floating-point exception summary */
230 env
->fpscr
|= 1 << FPSCR_FX
;
232 /* XXX: should adjust the result */
233 /* Update the floating-point enabled exception summary */
234 env
->fpscr
|= 1 << FPSCR_FEX
;
235 /* We must update the target FPR before raising the exception */
236 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
237 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_UX
;
241 static inline void float_inexact_excp(CPUPPCState
*env
)
243 env
->fpscr
|= 1 << FPSCR_XX
;
244 /* Update the floating-point exception summary */
245 env
->fpscr
|= 1 << FPSCR_FX
;
247 /* Update the floating-point enabled exception summary */
248 env
->fpscr
|= 1 << FPSCR_FEX
;
249 /* We must update the target FPR before raising the exception */
250 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
251 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_XX
;
255 static inline void fpscr_set_rounding_mode(CPUPPCState
*env
)
259 /* Set rounding mode */
262 /* Best approximation (round to nearest) */
263 rnd_type
= float_round_nearest_even
;
266 /* Smaller magnitude (round toward zero) */
267 rnd_type
= float_round_to_zero
;
270 /* Round toward +infinite */
271 rnd_type
= float_round_up
;
275 /* Round toward -infinite */
276 rnd_type
= float_round_down
;
279 set_float_rounding_mode(rnd_type
, &env
->fp_status
);
282 void helper_fpscr_clrbit(CPUPPCState
*env
, uint32_t bit
)
286 prev
= (env
->fpscr
>> bit
) & 1;
287 env
->fpscr
&= ~(1 << bit
);
292 fpscr_set_rounding_mode(env
);
300 void helper_fpscr_setbit(CPUPPCState
*env
, uint32_t bit
)
304 prev
= (env
->fpscr
>> bit
) & 1;
305 env
->fpscr
|= 1 << bit
;
309 env
->fpscr
|= 1 << FPSCR_FX
;
314 env
->fpscr
|= 1 << FPSCR_FX
;
320 env
->fpscr
|= 1 << FPSCR_FX
;
326 env
->fpscr
|= 1 << FPSCR_FX
;
332 env
->fpscr
|= 1 << FPSCR_FX
;
346 env
->fpscr
|= 1 << FPSCR_VX
;
347 env
->fpscr
|= 1 << FPSCR_FX
;
355 env
->error_code
= POWERPC_EXCP_FP
;
357 env
->error_code
|= POWERPC_EXCP_FP_VXSNAN
;
360 env
->error_code
|= POWERPC_EXCP_FP_VXISI
;
363 env
->error_code
|= POWERPC_EXCP_FP_VXIDI
;
366 env
->error_code
|= POWERPC_EXCP_FP_VXZDZ
;
369 env
->error_code
|= POWERPC_EXCP_FP_VXIMZ
;
372 env
->error_code
|= POWERPC_EXCP_FP_VXVC
;
375 env
->error_code
|= POWERPC_EXCP_FP_VXSOFT
;
378 env
->error_code
|= POWERPC_EXCP_FP_VXSQRT
;
381 env
->error_code
|= POWERPC_EXCP_FP_VXCVI
;
389 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_OX
;
396 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_UX
;
403 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_ZX
;
410 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_XX
;
416 fpscr_set_rounding_mode(env
);
421 /* Update the floating-point enabled exception summary */
422 env
->fpscr
|= 1 << FPSCR_FEX
;
423 /* We have to update Rc1 before raising the exception */
424 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
430 void helper_store_fpscr(CPUPPCState
*env
, uint64_t arg
, uint32_t mask
)
433 * We use only the 32 LSB of the incoming fpr
441 new |= prev
& 0x60000000;
442 for (i
= 0; i
< 8; i
++) {
443 if (mask
& (1 << i
)) {
444 env
->fpscr
&= ~(0xF << (4 * i
));
445 env
->fpscr
|= new & (0xF << (4 * i
));
448 /* Update VX and FEX */
450 env
->fpscr
|= 1 << FPSCR_VX
;
452 env
->fpscr
&= ~(1 << FPSCR_VX
);
454 if ((fpscr_ex
& fpscr_eex
) != 0) {
455 env
->fpscr
|= 1 << FPSCR_FEX
;
456 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
457 /* XXX: we should compute it properly */
458 env
->error_code
= POWERPC_EXCP_FP
;
460 env
->fpscr
&= ~(1 << FPSCR_FEX
);
462 fpscr_set_rounding_mode(env
);
465 void helper_float_check_status(CPUPPCState
*env
)
467 if (env
->exception_index
== POWERPC_EXCP_PROGRAM
&&
468 (env
->error_code
& POWERPC_EXCP_FP
)) {
469 /* Differred floating-point exception after target FPR update */
470 if (msr_fe0
!= 0 || msr_fe1
!= 0) {
471 helper_raise_exception_err(env
, env
->exception_index
,
475 int status
= get_float_exception_flags(&env
->fp_status
);
476 if (status
& float_flag_divbyzero
) {
477 float_zero_divide_excp(env
);
478 } else if (status
& float_flag_overflow
) {
479 float_overflow_excp(env
);
480 } else if (status
& float_flag_underflow
) {
481 float_underflow_excp(env
);
482 } else if (status
& float_flag_inexact
) {
483 float_inexact_excp(env
);
488 void helper_reset_fpstatus(CPUPPCState
*env
)
490 set_float_exception_flags(0, &env
->fp_status
);
494 uint64_t helper_fadd(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
496 CPU_DoubleU farg1
, farg2
;
501 if (unlikely(float64_is_infinity(farg1
.d
) && float64_is_infinity(farg2
.d
) &&
502 float64_is_neg(farg1
.d
) != float64_is_neg(farg2
.d
))) {
503 /* Magnitude subtraction of infinities */
504 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
506 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
507 float64_is_signaling_nan(farg2
.d
))) {
509 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
511 farg1
.d
= float64_add(farg1
.d
, farg2
.d
, &env
->fp_status
);
518 uint64_t helper_fsub(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
520 CPU_DoubleU farg1
, farg2
;
525 if (unlikely(float64_is_infinity(farg1
.d
) && float64_is_infinity(farg2
.d
) &&
526 float64_is_neg(farg1
.d
) == float64_is_neg(farg2
.d
))) {
527 /* Magnitude subtraction of infinities */
528 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
530 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
531 float64_is_signaling_nan(farg2
.d
))) {
532 /* sNaN subtraction */
533 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
535 farg1
.d
= float64_sub(farg1
.d
, farg2
.d
, &env
->fp_status
);
542 uint64_t helper_fmul(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
544 CPU_DoubleU farg1
, farg2
;
549 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
550 (float64_is_zero(farg1
.d
) && float64_is_infinity(farg2
.d
)))) {
551 /* Multiplication of zero by infinity */
552 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
554 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
555 float64_is_signaling_nan(farg2
.d
))) {
556 /* sNaN multiplication */
557 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
559 farg1
.d
= float64_mul(farg1
.d
, farg2
.d
, &env
->fp_status
);
566 uint64_t helper_fdiv(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
568 CPU_DoubleU farg1
, farg2
;
573 if (unlikely(float64_is_infinity(farg1
.d
) &&
574 float64_is_infinity(farg2
.d
))) {
575 /* Division of infinity by infinity */
576 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIDI
);
577 } else if (unlikely(float64_is_zero(farg1
.d
) && float64_is_zero(farg2
.d
))) {
578 /* Division of zero by zero */
579 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXZDZ
);
581 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
582 float64_is_signaling_nan(farg2
.d
))) {
584 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
586 farg1
.d
= float64_div(farg1
.d
, farg2
.d
, &env
->fp_status
);
593 uint64_t helper_fabs(CPUPPCState
*env
, uint64_t arg
)
598 farg
.d
= float64_abs(farg
.d
);
603 uint64_t helper_fnabs(CPUPPCState
*env
, uint64_t arg
)
608 farg
.d
= float64_abs(farg
.d
);
609 farg
.d
= float64_chs(farg
.d
);
614 uint64_t helper_fneg(CPUPPCState
*env
, uint64_t arg
)
619 farg
.d
= float64_chs(farg
.d
);
624 uint64_t helper_fctiw(CPUPPCState
*env
, uint64_t arg
)
630 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
631 /* sNaN conversion */
632 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
633 POWERPC_EXCP_FP_VXCVI
);
634 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
635 float64_is_infinity(farg
.d
))) {
636 /* qNan / infinity conversion */
637 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
639 farg
.ll
= float64_to_int32(farg
.d
, &env
->fp_status
);
640 /* XXX: higher bits are not supposed to be significant.
641 * to make tests easier, return the same as a real PowerPC 750
643 farg
.ll
|= 0xFFF80000ULL
<< 32;
648 /* fctiwz - fctiwz. */
649 uint64_t helper_fctiwz(CPUPPCState
*env
, uint64_t arg
)
655 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
656 /* sNaN conversion */
657 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
658 POWERPC_EXCP_FP_VXCVI
);
659 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
660 float64_is_infinity(farg
.d
))) {
661 /* qNan / infinity conversion */
662 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
664 farg
.ll
= float64_to_int32_round_to_zero(farg
.d
, &env
->fp_status
);
665 /* XXX: higher bits are not supposed to be significant.
666 * to make tests easier, return the same as a real PowerPC 750
668 farg
.ll
|= 0xFFF80000ULL
<< 32;
673 #if defined(TARGET_PPC64)
675 uint64_t helper_fcfid(CPUPPCState
*env
, uint64_t arg
)
679 farg
.d
= int64_to_float64(arg
, &env
->fp_status
);
684 uint64_t helper_fctid(CPUPPCState
*env
, uint64_t arg
)
690 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
691 /* sNaN conversion */
692 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
693 POWERPC_EXCP_FP_VXCVI
);
694 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
695 float64_is_infinity(farg
.d
))) {
696 /* qNan / infinity conversion */
697 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
699 farg
.ll
= float64_to_int64(farg
.d
, &env
->fp_status
);
704 /* fctidz - fctidz. */
705 uint64_t helper_fctidz(CPUPPCState
*env
, uint64_t arg
)
711 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
712 /* sNaN conversion */
713 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
714 POWERPC_EXCP_FP_VXCVI
);
715 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
716 float64_is_infinity(farg
.d
))) {
717 /* qNan / infinity conversion */
718 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
720 farg
.ll
= float64_to_int64_round_to_zero(farg
.d
, &env
->fp_status
);
727 static inline uint64_t do_fri(CPUPPCState
*env
, uint64_t arg
,
734 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
736 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
737 POWERPC_EXCP_FP_VXCVI
);
738 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
739 float64_is_infinity(farg
.d
))) {
740 /* qNan / infinity round */
741 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
743 set_float_rounding_mode(rounding_mode
, &env
->fp_status
);
744 farg
.ll
= float64_round_to_int(farg
.d
, &env
->fp_status
);
745 /* Restore rounding mode from FPSCR */
746 fpscr_set_rounding_mode(env
);
751 uint64_t helper_frin(CPUPPCState
*env
, uint64_t arg
)
753 return do_fri(env
, arg
, float_round_nearest_even
);
756 uint64_t helper_friz(CPUPPCState
*env
, uint64_t arg
)
758 return do_fri(env
, arg
, float_round_to_zero
);
761 uint64_t helper_frip(CPUPPCState
*env
, uint64_t arg
)
763 return do_fri(env
, arg
, float_round_up
);
766 uint64_t helper_frim(CPUPPCState
*env
, uint64_t arg
)
768 return do_fri(env
, arg
, float_round_down
);
772 uint64_t helper_fmadd(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
775 CPU_DoubleU farg1
, farg2
, farg3
;
781 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
782 (float64_is_zero(farg1
.d
) && float64_is_infinity(farg2
.d
)))) {
783 /* Multiplication of zero by infinity */
784 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
786 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
787 float64_is_signaling_nan(farg2
.d
) ||
788 float64_is_signaling_nan(farg3
.d
))) {
790 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
792 /* This is the way the PowerPC specification defines it */
793 float128 ft0_128
, ft1_128
;
795 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
796 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
797 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
798 if (unlikely(float128_is_infinity(ft0_128
) &&
799 float64_is_infinity(farg3
.d
) &&
800 float128_is_neg(ft0_128
) != float64_is_neg(farg3
.d
))) {
801 /* Magnitude subtraction of infinities */
802 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
804 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
805 ft0_128
= float128_add(ft0_128
, ft1_128
, &env
->fp_status
);
806 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
814 uint64_t helper_fmsub(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
817 CPU_DoubleU farg1
, farg2
, farg3
;
823 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
824 (float64_is_zero(farg1
.d
) &&
825 float64_is_infinity(farg2
.d
)))) {
826 /* Multiplication of zero by infinity */
827 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
829 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
830 float64_is_signaling_nan(farg2
.d
) ||
831 float64_is_signaling_nan(farg3
.d
))) {
833 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
835 /* This is the way the PowerPC specification defines it */
836 float128 ft0_128
, ft1_128
;
838 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
839 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
840 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
841 if (unlikely(float128_is_infinity(ft0_128
) &&
842 float64_is_infinity(farg3
.d
) &&
843 float128_is_neg(ft0_128
) == float64_is_neg(farg3
.d
))) {
844 /* Magnitude subtraction of infinities */
845 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
847 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
848 ft0_128
= float128_sub(ft0_128
, ft1_128
, &env
->fp_status
);
849 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
855 /* fnmadd - fnmadd. */
856 uint64_t helper_fnmadd(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
859 CPU_DoubleU farg1
, farg2
, farg3
;
865 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
866 (float64_is_zero(farg1
.d
) && float64_is_infinity(farg2
.d
)))) {
867 /* Multiplication of zero by infinity */
868 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
870 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
871 float64_is_signaling_nan(farg2
.d
) ||
872 float64_is_signaling_nan(farg3
.d
))) {
874 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
876 /* This is the way the PowerPC specification defines it */
877 float128 ft0_128
, ft1_128
;
879 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
880 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
881 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
882 if (unlikely(float128_is_infinity(ft0_128
) &&
883 float64_is_infinity(farg3
.d
) &&
884 float128_is_neg(ft0_128
) != float64_is_neg(farg3
.d
))) {
885 /* Magnitude subtraction of infinities */
886 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
888 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
889 ft0_128
= float128_add(ft0_128
, ft1_128
, &env
->fp_status
);
890 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
892 if (likely(!float64_is_any_nan(farg1
.d
))) {
893 farg1
.d
= float64_chs(farg1
.d
);
899 /* fnmsub - fnmsub. */
900 uint64_t helper_fnmsub(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
903 CPU_DoubleU farg1
, farg2
, farg3
;
909 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
910 (float64_is_zero(farg1
.d
) &&
911 float64_is_infinity(farg2
.d
)))) {
912 /* Multiplication of zero by infinity */
913 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
915 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
916 float64_is_signaling_nan(farg2
.d
) ||
917 float64_is_signaling_nan(farg3
.d
))) {
919 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
921 /* This is the way the PowerPC specification defines it */
922 float128 ft0_128
, ft1_128
;
924 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
925 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
926 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
927 if (unlikely(float128_is_infinity(ft0_128
) &&
928 float64_is_infinity(farg3
.d
) &&
929 float128_is_neg(ft0_128
) == float64_is_neg(farg3
.d
))) {
930 /* Magnitude subtraction of infinities */
931 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
933 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
934 ft0_128
= float128_sub(ft0_128
, ft1_128
, &env
->fp_status
);
935 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
937 if (likely(!float64_is_any_nan(farg1
.d
))) {
938 farg1
.d
= float64_chs(farg1
.d
);
945 uint64_t helper_frsp(CPUPPCState
*env
, uint64_t arg
)
952 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
953 /* sNaN square root */
954 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
956 f32
= float64_to_float32(farg
.d
, &env
->fp_status
);
957 farg
.d
= float32_to_float64(f32
, &env
->fp_status
);
963 uint64_t helper_fsqrt(CPUPPCState
*env
, uint64_t arg
)
969 if (unlikely(float64_is_neg(farg
.d
) && !float64_is_zero(farg
.d
))) {
970 /* Square root of a negative nonzero number */
971 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSQRT
);
973 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
974 /* sNaN square root */
975 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
977 farg
.d
= float64_sqrt(farg
.d
, &env
->fp_status
);
983 uint64_t helper_fre(CPUPPCState
*env
, uint64_t arg
)
989 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
990 /* sNaN reciprocal */
991 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
993 farg
.d
= float64_div(float64_one
, farg
.d
, &env
->fp_status
);
998 uint64_t helper_fres(CPUPPCState
*env
, uint64_t arg
)
1005 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
1006 /* sNaN reciprocal */
1007 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
1009 farg
.d
= float64_div(float64_one
, farg
.d
, &env
->fp_status
);
1010 f32
= float64_to_float32(farg
.d
, &env
->fp_status
);
1011 farg
.d
= float32_to_float64(f32
, &env
->fp_status
);
1016 /* frsqrte - frsqrte. */
1017 uint64_t helper_frsqrte(CPUPPCState
*env
, uint64_t arg
)
1024 if (unlikely(float64_is_neg(farg
.d
) && !float64_is_zero(farg
.d
))) {
1025 /* Reciprocal square root of a negative nonzero number */
1026 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSQRT
);
1028 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
1029 /* sNaN reciprocal square root */
1030 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
1032 farg
.d
= float64_sqrt(farg
.d
, &env
->fp_status
);
1033 farg
.d
= float64_div(float64_one
, farg
.d
, &env
->fp_status
);
1034 f32
= float64_to_float32(farg
.d
, &env
->fp_status
);
1035 farg
.d
= float32_to_float64(f32
, &env
->fp_status
);
1041 uint64_t helper_fsel(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
1048 if ((!float64_is_neg(farg1
.d
) || float64_is_zero(farg1
.d
)) &&
1049 !float64_is_any_nan(farg1
.d
)) {
1056 void helper_fcmpu(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
1059 CPU_DoubleU farg1
, farg2
;
1065 if (unlikely(float64_is_any_nan(farg1
.d
) ||
1066 float64_is_any_nan(farg2
.d
))) {
1068 } else if (float64_lt(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1070 } else if (!float64_le(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1076 env
->fpscr
&= ~(0x0F << FPSCR_FPRF
);
1077 env
->fpscr
|= ret
<< FPSCR_FPRF
;
1078 env
->crf
[crfD
] = ret
;
1079 if (unlikely(ret
== 0x01UL
1080 && (float64_is_signaling_nan(farg1
.d
) ||
1081 float64_is_signaling_nan(farg2
.d
)))) {
1082 /* sNaN comparison */
1083 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
1087 void helper_fcmpo(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
1090 CPU_DoubleU farg1
, farg2
;
1096 if (unlikely(float64_is_any_nan(farg1
.d
) ||
1097 float64_is_any_nan(farg2
.d
))) {
1099 } else if (float64_lt(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1101 } else if (!float64_le(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1107 env
->fpscr
&= ~(0x0F << FPSCR_FPRF
);
1108 env
->fpscr
|= ret
<< FPSCR_FPRF
;
1109 env
->crf
[crfD
] = ret
;
1110 if (unlikely(ret
== 0x01UL
)) {
1111 if (float64_is_signaling_nan(farg1
.d
) ||
1112 float64_is_signaling_nan(farg2
.d
)) {
1113 /* sNaN comparison */
1114 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
1115 POWERPC_EXCP_FP_VXVC
);
1117 /* qNaN comparison */
1118 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXVC
);
1123 /* Single-precision floating-point conversions */
1124 static inline uint32_t efscfsi(CPUPPCState
*env
, uint32_t val
)
1128 u
.f
= int32_to_float32(val
, &env
->vec_status
);
1133 static inline uint32_t efscfui(CPUPPCState
*env
, uint32_t val
)
1137 u
.f
= uint32_to_float32(val
, &env
->vec_status
);
1142 static inline int32_t efsctsi(CPUPPCState
*env
, uint32_t val
)
1147 /* NaN are not treated the same way IEEE 754 does */
1148 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1152 return float32_to_int32(u
.f
, &env
->vec_status
);
1155 static inline uint32_t efsctui(CPUPPCState
*env
, uint32_t val
)
1160 /* NaN are not treated the same way IEEE 754 does */
1161 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1165 return float32_to_uint32(u
.f
, &env
->vec_status
);
1168 static inline uint32_t efsctsiz(CPUPPCState
*env
, uint32_t val
)
1173 /* NaN are not treated the same way IEEE 754 does */
1174 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1178 return float32_to_int32_round_to_zero(u
.f
, &env
->vec_status
);
1181 static inline uint32_t efsctuiz(CPUPPCState
*env
, uint32_t val
)
1186 /* NaN are not treated the same way IEEE 754 does */
1187 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1191 return float32_to_uint32_round_to_zero(u
.f
, &env
->vec_status
);
1194 static inline uint32_t efscfsf(CPUPPCState
*env
, uint32_t val
)
1199 u
.f
= int32_to_float32(val
, &env
->vec_status
);
1200 tmp
= int64_to_float32(1ULL << 32, &env
->vec_status
);
1201 u
.f
= float32_div(u
.f
, tmp
, &env
->vec_status
);
1206 static inline uint32_t efscfuf(CPUPPCState
*env
, uint32_t val
)
1211 u
.f
= uint32_to_float32(val
, &env
->vec_status
);
1212 tmp
= uint64_to_float32(1ULL << 32, &env
->vec_status
);
1213 u
.f
= float32_div(u
.f
, tmp
, &env
->vec_status
);
1218 static inline uint32_t efsctsf(CPUPPCState
*env
, uint32_t val
)
1224 /* NaN are not treated the same way IEEE 754 does */
1225 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1228 tmp
= uint64_to_float32(1ULL << 32, &env
->vec_status
);
1229 u
.f
= float32_mul(u
.f
, tmp
, &env
->vec_status
);
1231 return float32_to_int32(u
.f
, &env
->vec_status
);
1234 static inline uint32_t efsctuf(CPUPPCState
*env
, uint32_t val
)
1240 /* NaN are not treated the same way IEEE 754 does */
1241 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1244 tmp
= uint64_to_float32(1ULL << 32, &env
->vec_status
);
1245 u
.f
= float32_mul(u
.f
, tmp
, &env
->vec_status
);
1247 return float32_to_uint32(u
.f
, &env
->vec_status
);
1250 #define HELPER_SPE_SINGLE_CONV(name) \
1251 uint32_t helper_e##name(CPUPPCState *env, uint32_t val) \
1253 return e##name(env, val); \
1256 HELPER_SPE_SINGLE_CONV(fscfsi
);
1258 HELPER_SPE_SINGLE_CONV(fscfui
);
1260 HELPER_SPE_SINGLE_CONV(fscfuf
);
1262 HELPER_SPE_SINGLE_CONV(fscfsf
);
1264 HELPER_SPE_SINGLE_CONV(fsctsi
);
1266 HELPER_SPE_SINGLE_CONV(fsctui
);
1268 HELPER_SPE_SINGLE_CONV(fsctsiz
);
1270 HELPER_SPE_SINGLE_CONV(fsctuiz
);
1272 HELPER_SPE_SINGLE_CONV(fsctsf
);
1274 HELPER_SPE_SINGLE_CONV(fsctuf
);
1276 #define HELPER_SPE_VECTOR_CONV(name) \
1277 uint64_t helper_ev##name(CPUPPCState *env, uint64_t val) \
1279 return ((uint64_t)e##name(env, val >> 32) << 32) | \
1280 (uint64_t)e##name(env, val); \
1283 HELPER_SPE_VECTOR_CONV(fscfsi
);
1285 HELPER_SPE_VECTOR_CONV(fscfui
);
1287 HELPER_SPE_VECTOR_CONV(fscfuf
);
1289 HELPER_SPE_VECTOR_CONV(fscfsf
);
1291 HELPER_SPE_VECTOR_CONV(fsctsi
);
1293 HELPER_SPE_VECTOR_CONV(fsctui
);
1295 HELPER_SPE_VECTOR_CONV(fsctsiz
);
1297 HELPER_SPE_VECTOR_CONV(fsctuiz
);
1299 HELPER_SPE_VECTOR_CONV(fsctsf
);
1301 HELPER_SPE_VECTOR_CONV(fsctuf
);
1303 /* Single-precision floating-point arithmetic */
1304 static inline uint32_t efsadd(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1310 u1
.f
= float32_add(u1
.f
, u2
.f
, &env
->vec_status
);
1314 static inline uint32_t efssub(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1320 u1
.f
= float32_sub(u1
.f
, u2
.f
, &env
->vec_status
);
1324 static inline uint32_t efsmul(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1330 u1
.f
= float32_mul(u1
.f
, u2
.f
, &env
->vec_status
);
1334 static inline uint32_t efsdiv(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1340 u1
.f
= float32_div(u1
.f
, u2
.f
, &env
->vec_status
);
1344 #define HELPER_SPE_SINGLE_ARITH(name) \
1345 uint32_t helper_e##name(CPUPPCState *env, uint32_t op1, uint32_t op2) \
1347 return e##name(env, op1, op2); \
1350 HELPER_SPE_SINGLE_ARITH(fsadd
);
1352 HELPER_SPE_SINGLE_ARITH(fssub
);
1354 HELPER_SPE_SINGLE_ARITH(fsmul
);
1356 HELPER_SPE_SINGLE_ARITH(fsdiv
);
1358 #define HELPER_SPE_VECTOR_ARITH(name) \
1359 uint64_t helper_ev##name(CPUPPCState *env, uint64_t op1, uint64_t op2) \
1361 return ((uint64_t)e##name(env, op1 >> 32, op2 >> 32) << 32) | \
1362 (uint64_t)e##name(env, op1, op2); \
1365 HELPER_SPE_VECTOR_ARITH(fsadd
);
1367 HELPER_SPE_VECTOR_ARITH(fssub
);
1369 HELPER_SPE_VECTOR_ARITH(fsmul
);
1371 HELPER_SPE_VECTOR_ARITH(fsdiv
);
1373 /* Single-precision floating-point comparisons */
1374 static inline uint32_t efscmplt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1380 return float32_lt(u1
.f
, u2
.f
, &env
->vec_status
) ? 4 : 0;
1383 static inline uint32_t efscmpgt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1389 return float32_le(u1
.f
, u2
.f
, &env
->vec_status
) ? 0 : 4;
1392 static inline uint32_t efscmpeq(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1398 return float32_eq(u1
.f
, u2
.f
, &env
->vec_status
) ? 4 : 0;
1401 static inline uint32_t efststlt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1403 /* XXX: TODO: ignore special values (NaN, infinites, ...) */
1404 return efscmplt(env
, op1
, op2
);
1407 static inline uint32_t efststgt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1409 /* XXX: TODO: ignore special values (NaN, infinites, ...) */
1410 return efscmpgt(env
, op1
, op2
);
1413 static inline uint32_t efststeq(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1415 /* XXX: TODO: ignore special values (NaN, infinites, ...) */
1416 return efscmpeq(env
, op1
, op2
);
1419 #define HELPER_SINGLE_SPE_CMP(name) \
1420 uint32_t helper_e##name(CPUPPCState *env, uint32_t op1, uint32_t op2) \
1422 return e##name(env, op1, op2) << 2; \
1425 HELPER_SINGLE_SPE_CMP(fststlt
);
1427 HELPER_SINGLE_SPE_CMP(fststgt
);
1429 HELPER_SINGLE_SPE_CMP(fststeq
);
1431 HELPER_SINGLE_SPE_CMP(fscmplt
);
1433 HELPER_SINGLE_SPE_CMP(fscmpgt
);
1435 HELPER_SINGLE_SPE_CMP(fscmpeq
);
1437 static inline uint32_t evcmp_merge(int t0
, int t1
)
1439 return (t0
<< 3) | (t1
<< 2) | ((t0
| t1
) << 1) | (t0
& t1
);
1442 #define HELPER_VECTOR_SPE_CMP(name) \
1443 uint32_t helper_ev##name(CPUPPCState *env, uint64_t op1, uint64_t op2) \
1445 return evcmp_merge(e##name(env, op1 >> 32, op2 >> 32), \
1446 e##name(env, op1, op2)); \
1449 HELPER_VECTOR_SPE_CMP(fststlt
);
1451 HELPER_VECTOR_SPE_CMP(fststgt
);
1453 HELPER_VECTOR_SPE_CMP(fststeq
);
1455 HELPER_VECTOR_SPE_CMP(fscmplt
);
1457 HELPER_VECTOR_SPE_CMP(fscmpgt
);
1459 HELPER_VECTOR_SPE_CMP(fscmpeq
);
1461 /* Double-precision floating-point conversion */
1462 uint64_t helper_efdcfsi(CPUPPCState
*env
, uint32_t val
)
1466 u
.d
= int32_to_float64(val
, &env
->vec_status
);
1471 uint64_t helper_efdcfsid(CPUPPCState
*env
, uint64_t val
)
1475 u
.d
= int64_to_float64(val
, &env
->vec_status
);
1480 uint64_t helper_efdcfui(CPUPPCState
*env
, uint32_t val
)
1484 u
.d
= uint32_to_float64(val
, &env
->vec_status
);
1489 uint64_t helper_efdcfuid(CPUPPCState
*env
, uint64_t val
)
1493 u
.d
= uint64_to_float64(val
, &env
->vec_status
);
1498 uint32_t helper_efdctsi(CPUPPCState
*env
, uint64_t val
)
1503 /* NaN are not treated the same way IEEE 754 does */
1504 if (unlikely(float64_is_any_nan(u
.d
))) {
1508 return float64_to_int32(u
.d
, &env
->vec_status
);
1511 uint32_t helper_efdctui(CPUPPCState
*env
, uint64_t val
)
1516 /* NaN are not treated the same way IEEE 754 does */
1517 if (unlikely(float64_is_any_nan(u
.d
))) {
1521 return float64_to_uint32(u
.d
, &env
->vec_status
);
1524 uint32_t helper_efdctsiz(CPUPPCState
*env
, uint64_t val
)
1529 /* NaN are not treated the same way IEEE 754 does */
1530 if (unlikely(float64_is_any_nan(u
.d
))) {
1534 return float64_to_int32_round_to_zero(u
.d
, &env
->vec_status
);
1537 uint64_t helper_efdctsidz(CPUPPCState
*env
, uint64_t val
)
1542 /* NaN are not treated the same way IEEE 754 does */
1543 if (unlikely(float64_is_any_nan(u
.d
))) {
1547 return float64_to_int64_round_to_zero(u
.d
, &env
->vec_status
);
1550 uint32_t helper_efdctuiz(CPUPPCState
*env
, uint64_t val
)
1555 /* NaN are not treated the same way IEEE 754 does */
1556 if (unlikely(float64_is_any_nan(u
.d
))) {
1560 return float64_to_uint32_round_to_zero(u
.d
, &env
->vec_status
);
1563 uint64_t helper_efdctuidz(CPUPPCState
*env
, uint64_t val
)
1568 /* NaN are not treated the same way IEEE 754 does */
1569 if (unlikely(float64_is_any_nan(u
.d
))) {
1573 return float64_to_uint64_round_to_zero(u
.d
, &env
->vec_status
);
1576 uint64_t helper_efdcfsf(CPUPPCState
*env
, uint32_t val
)
1581 u
.d
= int32_to_float64(val
, &env
->vec_status
);
1582 tmp
= int64_to_float64(1ULL << 32, &env
->vec_status
);
1583 u
.d
= float64_div(u
.d
, tmp
, &env
->vec_status
);
1588 uint64_t helper_efdcfuf(CPUPPCState
*env
, uint32_t val
)
1593 u
.d
= uint32_to_float64(val
, &env
->vec_status
);
1594 tmp
= int64_to_float64(1ULL << 32, &env
->vec_status
);
1595 u
.d
= float64_div(u
.d
, tmp
, &env
->vec_status
);
1600 uint32_t helper_efdctsf(CPUPPCState
*env
, uint64_t val
)
1606 /* NaN are not treated the same way IEEE 754 does */
1607 if (unlikely(float64_is_any_nan(u
.d
))) {
1610 tmp
= uint64_to_float64(1ULL << 32, &env
->vec_status
);
1611 u
.d
= float64_mul(u
.d
, tmp
, &env
->vec_status
);
1613 return float64_to_int32(u
.d
, &env
->vec_status
);
1616 uint32_t helper_efdctuf(CPUPPCState
*env
, uint64_t val
)
1622 /* NaN are not treated the same way IEEE 754 does */
1623 if (unlikely(float64_is_any_nan(u
.d
))) {
1626 tmp
= uint64_to_float64(1ULL << 32, &env
->vec_status
);
1627 u
.d
= float64_mul(u
.d
, tmp
, &env
->vec_status
);
1629 return float64_to_uint32(u
.d
, &env
->vec_status
);
1632 uint32_t helper_efscfd(CPUPPCState
*env
, uint64_t val
)
1638 u2
.f
= float64_to_float32(u1
.d
, &env
->vec_status
);
1643 uint64_t helper_efdcfs(CPUPPCState
*env
, uint32_t val
)
1649 u2
.d
= float32_to_float64(u1
.f
, &env
->vec_status
);
1654 /* Double precision fixed-point arithmetic */
1655 uint64_t helper_efdadd(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1661 u1
.d
= float64_add(u1
.d
, u2
.d
, &env
->vec_status
);
1665 uint64_t helper_efdsub(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1671 u1
.d
= float64_sub(u1
.d
, u2
.d
, &env
->vec_status
);
1675 uint64_t helper_efdmul(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1681 u1
.d
= float64_mul(u1
.d
, u2
.d
, &env
->vec_status
);
1685 uint64_t helper_efddiv(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1691 u1
.d
= float64_div(u1
.d
, u2
.d
, &env
->vec_status
);
1695 /* Double precision floating point helpers */
1696 uint32_t helper_efdtstlt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1702 return float64_lt(u1
.d
, u2
.d
, &env
->vec_status
) ? 4 : 0;
1705 uint32_t helper_efdtstgt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1711 return float64_le(u1
.d
, u2
.d
, &env
->vec_status
) ? 0 : 4;
1714 uint32_t helper_efdtsteq(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1720 return float64_eq_quiet(u1
.d
, u2
.d
, &env
->vec_status
) ? 4 : 0;
1723 uint32_t helper_efdcmplt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1725 /* XXX: TODO: test special values (NaN, infinites, ...) */
1726 return helper_efdtstlt(env
, op1
, op2
);
1729 uint32_t helper_efdcmpgt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1731 /* XXX: TODO: test special values (NaN, infinites, ...) */
1732 return helper_efdtstgt(env
, op1
, op2
);
1735 uint32_t helper_efdcmpeq(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1737 /* XXX: TODO: test special values (NaN, infinites, ...) */
1738 return helper_efdtsteq(env
, op1
, op2
);