]>
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
;
315 env
->fpscr
|= 1 << FPSCR_FX
;
321 env
->fpscr
|= 1 << FPSCR_FX
;
327 env
->fpscr
|= 1 << FPSCR_FX
;
333 env
->fpscr
|= 1 << FPSCR_FX
;
347 env
->fpscr
|= 1 << FPSCR_VX
;
348 env
->fpscr
|= 1 << FPSCR_FX
;
356 env
->error_code
= POWERPC_EXCP_FP
;
358 env
->error_code
|= POWERPC_EXCP_FP_VXSNAN
;
361 env
->error_code
|= POWERPC_EXCP_FP_VXISI
;
364 env
->error_code
|= POWERPC_EXCP_FP_VXIDI
;
367 env
->error_code
|= POWERPC_EXCP_FP_VXZDZ
;
370 env
->error_code
|= POWERPC_EXCP_FP_VXIMZ
;
373 env
->error_code
|= POWERPC_EXCP_FP_VXVC
;
376 env
->error_code
|= POWERPC_EXCP_FP_VXSOFT
;
379 env
->error_code
|= POWERPC_EXCP_FP_VXSQRT
;
382 env
->error_code
|= POWERPC_EXCP_FP_VXCVI
;
390 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_OX
;
397 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_UX
;
404 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_ZX
;
411 env
->error_code
= POWERPC_EXCP_FP
| POWERPC_EXCP_FP_XX
;
417 fpscr_set_rounding_mode(env
);
422 /* Update the floating-point enabled exception summary */
423 env
->fpscr
|= 1 << FPSCR_FEX
;
424 /* We have to update Rc1 before raising the exception */
425 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
431 void helper_store_fpscr(CPUPPCState
*env
, uint64_t arg
, uint32_t mask
)
434 * We use only the 32 LSB of the incoming fpr
442 new |= prev
& 0x60000000;
443 for (i
= 0; i
< 8; i
++) {
444 if (mask
& (1 << i
)) {
445 env
->fpscr
&= ~(0xF << (4 * i
));
446 env
->fpscr
|= new & (0xF << (4 * i
));
449 /* Update VX and FEX */
451 env
->fpscr
|= 1 << FPSCR_VX
;
453 env
->fpscr
&= ~(1 << FPSCR_VX
);
455 if ((fpscr_ex
& fpscr_eex
) != 0) {
456 env
->fpscr
|= 1 << FPSCR_FEX
;
457 env
->exception_index
= POWERPC_EXCP_PROGRAM
;
458 /* XXX: we should compute it properly */
459 env
->error_code
= POWERPC_EXCP_FP
;
461 env
->fpscr
&= ~(1 << FPSCR_FEX
);
463 fpscr_set_rounding_mode(env
);
466 void store_fpscr(CPUPPCState
*env
, uint64_t arg
, uint32_t mask
)
468 helper_store_fpscr(env
, arg
, mask
);
471 void helper_float_check_status(CPUPPCState
*env
)
473 int status
= get_float_exception_flags(&env
->fp_status
);
475 if (status
& float_flag_divbyzero
) {
476 float_zero_divide_excp(env
);
477 } else if (status
& float_flag_overflow
) {
478 float_overflow_excp(env
);
479 } else if (status
& float_flag_underflow
) {
480 float_underflow_excp(env
);
481 } else if (status
& float_flag_inexact
) {
482 float_inexact_excp(env
);
485 if (env
->exception_index
== POWERPC_EXCP_PROGRAM
&&
486 (env
->error_code
& POWERPC_EXCP_FP
)) {
487 /* Differred floating-point exception after target FPR update */
488 if (msr_fe0
!= 0 || msr_fe1
!= 0) {
489 helper_raise_exception_err(env
, env
->exception_index
,
495 void helper_reset_fpstatus(CPUPPCState
*env
)
497 set_float_exception_flags(0, &env
->fp_status
);
501 uint64_t helper_fadd(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
503 CPU_DoubleU farg1
, farg2
;
508 if (unlikely(float64_is_infinity(farg1
.d
) && float64_is_infinity(farg2
.d
) &&
509 float64_is_neg(farg1
.d
) != float64_is_neg(farg2
.d
))) {
510 /* Magnitude subtraction of infinities */
511 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
513 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
514 float64_is_signaling_nan(farg2
.d
))) {
516 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
518 farg1
.d
= float64_add(farg1
.d
, farg2
.d
, &env
->fp_status
);
525 uint64_t helper_fsub(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
527 CPU_DoubleU farg1
, farg2
;
532 if (unlikely(float64_is_infinity(farg1
.d
) && float64_is_infinity(farg2
.d
) &&
533 float64_is_neg(farg1
.d
) == float64_is_neg(farg2
.d
))) {
534 /* Magnitude subtraction of infinities */
535 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
537 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
538 float64_is_signaling_nan(farg2
.d
))) {
539 /* sNaN subtraction */
540 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
542 farg1
.d
= float64_sub(farg1
.d
, farg2
.d
, &env
->fp_status
);
549 uint64_t helper_fmul(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
551 CPU_DoubleU farg1
, farg2
;
556 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
557 (float64_is_zero(farg1
.d
) && float64_is_infinity(farg2
.d
)))) {
558 /* Multiplication of zero by infinity */
559 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
561 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
562 float64_is_signaling_nan(farg2
.d
))) {
563 /* sNaN multiplication */
564 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
566 farg1
.d
= float64_mul(farg1
.d
, farg2
.d
, &env
->fp_status
);
573 uint64_t helper_fdiv(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
)
575 CPU_DoubleU farg1
, farg2
;
580 if (unlikely(float64_is_infinity(farg1
.d
) &&
581 float64_is_infinity(farg2
.d
))) {
582 /* Division of infinity by infinity */
583 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIDI
);
584 } else if (unlikely(float64_is_zero(farg1
.d
) && float64_is_zero(farg2
.d
))) {
585 /* Division of zero by zero */
586 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXZDZ
);
588 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
589 float64_is_signaling_nan(farg2
.d
))) {
591 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
593 farg1
.d
= float64_div(farg1
.d
, farg2
.d
, &env
->fp_status
);
600 uint64_t helper_fctiw(CPUPPCState
*env
, uint64_t arg
)
606 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
607 /* sNaN conversion */
608 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
609 POWERPC_EXCP_FP_VXCVI
);
610 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
611 float64_is_infinity(farg
.d
))) {
612 /* qNan / infinity conversion */
613 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
615 farg
.ll
= float64_to_int32(farg
.d
, &env
->fp_status
);
616 /* XXX: higher bits are not supposed to be significant.
617 * to make tests easier, return the same as a real PowerPC 750
619 farg
.ll
|= 0xFFF80000ULL
<< 32;
624 /* fctiwz - fctiwz. */
625 uint64_t helper_fctiwz(CPUPPCState
*env
, uint64_t arg
)
631 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
632 /* sNaN conversion */
633 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
634 POWERPC_EXCP_FP_VXCVI
);
635 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
636 float64_is_infinity(farg
.d
))) {
637 /* qNan / infinity conversion */
638 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
640 farg
.ll
= float64_to_int32_round_to_zero(farg
.d
, &env
->fp_status
);
641 /* XXX: higher bits are not supposed to be significant.
642 * to make tests easier, return the same as a real PowerPC 750
644 farg
.ll
|= 0xFFF80000ULL
<< 32;
649 #if defined(TARGET_PPC64)
651 uint64_t helper_fcfid(CPUPPCState
*env
, uint64_t arg
)
655 farg
.d
= int64_to_float64(arg
, &env
->fp_status
);
660 uint64_t helper_fctid(CPUPPCState
*env
, uint64_t arg
)
666 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
667 /* sNaN conversion */
668 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
669 POWERPC_EXCP_FP_VXCVI
);
670 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
671 float64_is_infinity(farg
.d
))) {
672 /* qNan / infinity conversion */
673 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
675 farg
.ll
= float64_to_int64(farg
.d
, &env
->fp_status
);
680 /* fctidz - fctidz. */
681 uint64_t helper_fctidz(CPUPPCState
*env
, uint64_t arg
)
687 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
688 /* sNaN conversion */
689 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
690 POWERPC_EXCP_FP_VXCVI
);
691 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
692 float64_is_infinity(farg
.d
))) {
693 /* qNan / infinity conversion */
694 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
696 farg
.ll
= float64_to_int64_round_to_zero(farg
.d
, &env
->fp_status
);
703 static inline uint64_t do_fri(CPUPPCState
*env
, uint64_t arg
,
710 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
712 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
713 POWERPC_EXCP_FP_VXCVI
);
714 } else if (unlikely(float64_is_quiet_nan(farg
.d
) ||
715 float64_is_infinity(farg
.d
))) {
716 /* qNan / infinity round */
717 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXCVI
);
719 set_float_rounding_mode(rounding_mode
, &env
->fp_status
);
720 farg
.ll
= float64_round_to_int(farg
.d
, &env
->fp_status
);
721 /* Restore rounding mode from FPSCR */
722 fpscr_set_rounding_mode(env
);
727 uint64_t helper_frin(CPUPPCState
*env
, uint64_t arg
)
729 return do_fri(env
, arg
, float_round_nearest_even
);
732 uint64_t helper_friz(CPUPPCState
*env
, uint64_t arg
)
734 return do_fri(env
, arg
, float_round_to_zero
);
737 uint64_t helper_frip(CPUPPCState
*env
, uint64_t arg
)
739 return do_fri(env
, arg
, float_round_up
);
742 uint64_t helper_frim(CPUPPCState
*env
, uint64_t arg
)
744 return do_fri(env
, arg
, float_round_down
);
748 uint64_t helper_fmadd(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
751 CPU_DoubleU farg1
, farg2
, farg3
;
757 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
758 (float64_is_zero(farg1
.d
) && float64_is_infinity(farg2
.d
)))) {
759 /* Multiplication of zero by infinity */
760 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
762 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
763 float64_is_signaling_nan(farg2
.d
) ||
764 float64_is_signaling_nan(farg3
.d
))) {
766 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
768 /* This is the way the PowerPC specification defines it */
769 float128 ft0_128
, ft1_128
;
771 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
772 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
773 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
774 if (unlikely(float128_is_infinity(ft0_128
) &&
775 float64_is_infinity(farg3
.d
) &&
776 float128_is_neg(ft0_128
) != float64_is_neg(farg3
.d
))) {
777 /* Magnitude subtraction of infinities */
778 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
780 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
781 ft0_128
= float128_add(ft0_128
, ft1_128
, &env
->fp_status
);
782 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
790 uint64_t helper_fmsub(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
793 CPU_DoubleU farg1
, farg2
, farg3
;
799 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
800 (float64_is_zero(farg1
.d
) &&
801 float64_is_infinity(farg2
.d
)))) {
802 /* Multiplication of zero by infinity */
803 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
805 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
806 float64_is_signaling_nan(farg2
.d
) ||
807 float64_is_signaling_nan(farg3
.d
))) {
809 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
811 /* This is the way the PowerPC specification defines it */
812 float128 ft0_128
, ft1_128
;
814 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
815 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
816 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
817 if (unlikely(float128_is_infinity(ft0_128
) &&
818 float64_is_infinity(farg3
.d
) &&
819 float128_is_neg(ft0_128
) == float64_is_neg(farg3
.d
))) {
820 /* Magnitude subtraction of infinities */
821 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
823 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
824 ft0_128
= float128_sub(ft0_128
, ft1_128
, &env
->fp_status
);
825 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
831 /* fnmadd - fnmadd. */
832 uint64_t helper_fnmadd(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
835 CPU_DoubleU farg1
, farg2
, farg3
;
841 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
842 (float64_is_zero(farg1
.d
) && float64_is_infinity(farg2
.d
)))) {
843 /* Multiplication of zero by infinity */
844 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
846 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
847 float64_is_signaling_nan(farg2
.d
) ||
848 float64_is_signaling_nan(farg3
.d
))) {
850 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
852 /* This is the way the PowerPC specification defines it */
853 float128 ft0_128
, ft1_128
;
855 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
856 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
857 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
858 if (unlikely(float128_is_infinity(ft0_128
) &&
859 float64_is_infinity(farg3
.d
) &&
860 float128_is_neg(ft0_128
) != float64_is_neg(farg3
.d
))) {
861 /* Magnitude subtraction of infinities */
862 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
864 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
865 ft0_128
= float128_add(ft0_128
, ft1_128
, &env
->fp_status
);
866 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
868 if (likely(!float64_is_any_nan(farg1
.d
))) {
869 farg1
.d
= float64_chs(farg1
.d
);
875 /* fnmsub - fnmsub. */
876 uint64_t helper_fnmsub(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
879 CPU_DoubleU farg1
, farg2
, farg3
;
885 if (unlikely((float64_is_infinity(farg1
.d
) && float64_is_zero(farg2
.d
)) ||
886 (float64_is_zero(farg1
.d
) &&
887 float64_is_infinity(farg2
.d
)))) {
888 /* Multiplication of zero by infinity */
889 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXIMZ
);
891 if (unlikely(float64_is_signaling_nan(farg1
.d
) ||
892 float64_is_signaling_nan(farg2
.d
) ||
893 float64_is_signaling_nan(farg3
.d
))) {
895 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
897 /* This is the way the PowerPC specification defines it */
898 float128 ft0_128
, ft1_128
;
900 ft0_128
= float64_to_float128(farg1
.d
, &env
->fp_status
);
901 ft1_128
= float64_to_float128(farg2
.d
, &env
->fp_status
);
902 ft0_128
= float128_mul(ft0_128
, ft1_128
, &env
->fp_status
);
903 if (unlikely(float128_is_infinity(ft0_128
) &&
904 float64_is_infinity(farg3
.d
) &&
905 float128_is_neg(ft0_128
) == float64_is_neg(farg3
.d
))) {
906 /* Magnitude subtraction of infinities */
907 farg1
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXISI
);
909 ft1_128
= float64_to_float128(farg3
.d
, &env
->fp_status
);
910 ft0_128
= float128_sub(ft0_128
, ft1_128
, &env
->fp_status
);
911 farg1
.d
= float128_to_float64(ft0_128
, &env
->fp_status
);
913 if (likely(!float64_is_any_nan(farg1
.d
))) {
914 farg1
.d
= float64_chs(farg1
.d
);
921 uint64_t helper_frsp(CPUPPCState
*env
, uint64_t arg
)
928 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
929 /* sNaN square root */
930 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
932 f32
= float64_to_float32(farg
.d
, &env
->fp_status
);
933 farg
.d
= float32_to_float64(f32
, &env
->fp_status
);
939 uint64_t helper_fsqrt(CPUPPCState
*env
, uint64_t arg
)
945 if (unlikely(float64_is_neg(farg
.d
) && !float64_is_zero(farg
.d
))) {
946 /* Square root of a negative nonzero number */
947 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSQRT
);
949 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
950 /* sNaN square root */
951 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
953 farg
.d
= float64_sqrt(farg
.d
, &env
->fp_status
);
959 uint64_t helper_fre(CPUPPCState
*env
, uint64_t arg
)
965 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
966 /* sNaN reciprocal */
967 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
969 farg
.d
= float64_div(float64_one
, farg
.d
, &env
->fp_status
);
974 uint64_t helper_fres(CPUPPCState
*env
, uint64_t arg
)
981 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
982 /* sNaN reciprocal */
983 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
985 farg
.d
= float64_div(float64_one
, farg
.d
, &env
->fp_status
);
986 f32
= float64_to_float32(farg
.d
, &env
->fp_status
);
987 farg
.d
= float32_to_float64(f32
, &env
->fp_status
);
992 /* frsqrte - frsqrte. */
993 uint64_t helper_frsqrte(CPUPPCState
*env
, uint64_t arg
)
1000 if (unlikely(float64_is_neg(farg
.d
) && !float64_is_zero(farg
.d
))) {
1001 /* Reciprocal square root of a negative nonzero number */
1002 farg
.ll
= fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSQRT
);
1004 if (unlikely(float64_is_signaling_nan(farg
.d
))) {
1005 /* sNaN reciprocal square root */
1006 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
1008 farg
.d
= float64_sqrt(farg
.d
, &env
->fp_status
);
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
);
1017 uint64_t helper_fsel(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
1024 if ((!float64_is_neg(farg1
.d
) || float64_is_zero(farg1
.d
)) &&
1025 !float64_is_any_nan(farg1
.d
)) {
1032 void helper_fcmpu(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
1035 CPU_DoubleU farg1
, farg2
;
1041 if (unlikely(float64_is_any_nan(farg1
.d
) ||
1042 float64_is_any_nan(farg2
.d
))) {
1044 } else if (float64_lt(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1046 } else if (!float64_le(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1052 env
->fpscr
&= ~(0x0F << FPSCR_FPRF
);
1053 env
->fpscr
|= ret
<< FPSCR_FPRF
;
1054 env
->crf
[crfD
] = ret
;
1055 if (unlikely(ret
== 0x01UL
1056 && (float64_is_signaling_nan(farg1
.d
) ||
1057 float64_is_signaling_nan(farg2
.d
)))) {
1058 /* sNaN comparison */
1059 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
);
1063 void helper_fcmpo(CPUPPCState
*env
, uint64_t arg1
, uint64_t arg2
,
1066 CPU_DoubleU farg1
, farg2
;
1072 if (unlikely(float64_is_any_nan(farg1
.d
) ||
1073 float64_is_any_nan(farg2
.d
))) {
1075 } else if (float64_lt(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1077 } else if (!float64_le(farg1
.d
, farg2
.d
, &env
->fp_status
)) {
1083 env
->fpscr
&= ~(0x0F << FPSCR_FPRF
);
1084 env
->fpscr
|= ret
<< FPSCR_FPRF
;
1085 env
->crf
[crfD
] = ret
;
1086 if (unlikely(ret
== 0x01UL
)) {
1087 if (float64_is_signaling_nan(farg1
.d
) ||
1088 float64_is_signaling_nan(farg2
.d
)) {
1089 /* sNaN comparison */
1090 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXSNAN
|
1091 POWERPC_EXCP_FP_VXVC
);
1093 /* qNaN comparison */
1094 fload_invalid_op_excp(env
, POWERPC_EXCP_FP_VXVC
);
1099 /* Single-precision floating-point conversions */
1100 static inline uint32_t efscfsi(CPUPPCState
*env
, uint32_t val
)
1104 u
.f
= int32_to_float32(val
, &env
->vec_status
);
1109 static inline uint32_t efscfui(CPUPPCState
*env
, uint32_t val
)
1113 u
.f
= uint32_to_float32(val
, &env
->vec_status
);
1118 static inline int32_t efsctsi(CPUPPCState
*env
, uint32_t val
)
1123 /* NaN are not treated the same way IEEE 754 does */
1124 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1128 return float32_to_int32(u
.f
, &env
->vec_status
);
1131 static inline uint32_t efsctui(CPUPPCState
*env
, uint32_t val
)
1136 /* NaN are not treated the same way IEEE 754 does */
1137 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1141 return float32_to_uint32(u
.f
, &env
->vec_status
);
1144 static inline uint32_t efsctsiz(CPUPPCState
*env
, uint32_t val
)
1149 /* NaN are not treated the same way IEEE 754 does */
1150 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1154 return float32_to_int32_round_to_zero(u
.f
, &env
->vec_status
);
1157 static inline uint32_t efsctuiz(CPUPPCState
*env
, uint32_t val
)
1162 /* NaN are not treated the same way IEEE 754 does */
1163 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1167 return float32_to_uint32_round_to_zero(u
.f
, &env
->vec_status
);
1170 static inline uint32_t efscfsf(CPUPPCState
*env
, uint32_t val
)
1175 u
.f
= int32_to_float32(val
, &env
->vec_status
);
1176 tmp
= int64_to_float32(1ULL << 32, &env
->vec_status
);
1177 u
.f
= float32_div(u
.f
, tmp
, &env
->vec_status
);
1182 static inline uint32_t efscfuf(CPUPPCState
*env
, uint32_t val
)
1187 u
.f
= uint32_to_float32(val
, &env
->vec_status
);
1188 tmp
= uint64_to_float32(1ULL << 32, &env
->vec_status
);
1189 u
.f
= float32_div(u
.f
, tmp
, &env
->vec_status
);
1194 static inline uint32_t efsctsf(CPUPPCState
*env
, uint32_t val
)
1200 /* NaN are not treated the same way IEEE 754 does */
1201 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1204 tmp
= uint64_to_float32(1ULL << 32, &env
->vec_status
);
1205 u
.f
= float32_mul(u
.f
, tmp
, &env
->vec_status
);
1207 return float32_to_int32(u
.f
, &env
->vec_status
);
1210 static inline uint32_t efsctuf(CPUPPCState
*env
, uint32_t val
)
1216 /* NaN are not treated the same way IEEE 754 does */
1217 if (unlikely(float32_is_quiet_nan(u
.f
))) {
1220 tmp
= uint64_to_float32(1ULL << 32, &env
->vec_status
);
1221 u
.f
= float32_mul(u
.f
, tmp
, &env
->vec_status
);
1223 return float32_to_uint32(u
.f
, &env
->vec_status
);
1226 #define HELPER_SPE_SINGLE_CONV(name) \
1227 uint32_t helper_e##name(CPUPPCState *env, uint32_t val) \
1229 return e##name(env, val); \
1232 HELPER_SPE_SINGLE_CONV(fscfsi
);
1234 HELPER_SPE_SINGLE_CONV(fscfui
);
1236 HELPER_SPE_SINGLE_CONV(fscfuf
);
1238 HELPER_SPE_SINGLE_CONV(fscfsf
);
1240 HELPER_SPE_SINGLE_CONV(fsctsi
);
1242 HELPER_SPE_SINGLE_CONV(fsctui
);
1244 HELPER_SPE_SINGLE_CONV(fsctsiz
);
1246 HELPER_SPE_SINGLE_CONV(fsctuiz
);
1248 HELPER_SPE_SINGLE_CONV(fsctsf
);
1250 HELPER_SPE_SINGLE_CONV(fsctuf
);
1252 #define HELPER_SPE_VECTOR_CONV(name) \
1253 uint64_t helper_ev##name(CPUPPCState *env, uint64_t val) \
1255 return ((uint64_t)e##name(env, val >> 32) << 32) | \
1256 (uint64_t)e##name(env, val); \
1259 HELPER_SPE_VECTOR_CONV(fscfsi
);
1261 HELPER_SPE_VECTOR_CONV(fscfui
);
1263 HELPER_SPE_VECTOR_CONV(fscfuf
);
1265 HELPER_SPE_VECTOR_CONV(fscfsf
);
1267 HELPER_SPE_VECTOR_CONV(fsctsi
);
1269 HELPER_SPE_VECTOR_CONV(fsctui
);
1271 HELPER_SPE_VECTOR_CONV(fsctsiz
);
1273 HELPER_SPE_VECTOR_CONV(fsctuiz
);
1275 HELPER_SPE_VECTOR_CONV(fsctsf
);
1277 HELPER_SPE_VECTOR_CONV(fsctuf
);
1279 /* Single-precision floating-point arithmetic */
1280 static inline uint32_t efsadd(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1286 u1
.f
= float32_add(u1
.f
, u2
.f
, &env
->vec_status
);
1290 static inline uint32_t efssub(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1296 u1
.f
= float32_sub(u1
.f
, u2
.f
, &env
->vec_status
);
1300 static inline uint32_t efsmul(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1306 u1
.f
= float32_mul(u1
.f
, u2
.f
, &env
->vec_status
);
1310 static inline uint32_t efsdiv(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1316 u1
.f
= float32_div(u1
.f
, u2
.f
, &env
->vec_status
);
1320 #define HELPER_SPE_SINGLE_ARITH(name) \
1321 uint32_t helper_e##name(CPUPPCState *env, uint32_t op1, uint32_t op2) \
1323 return e##name(env, op1, op2); \
1326 HELPER_SPE_SINGLE_ARITH(fsadd
);
1328 HELPER_SPE_SINGLE_ARITH(fssub
);
1330 HELPER_SPE_SINGLE_ARITH(fsmul
);
1332 HELPER_SPE_SINGLE_ARITH(fsdiv
);
1334 #define HELPER_SPE_VECTOR_ARITH(name) \
1335 uint64_t helper_ev##name(CPUPPCState *env, uint64_t op1, uint64_t op2) \
1337 return ((uint64_t)e##name(env, op1 >> 32, op2 >> 32) << 32) | \
1338 (uint64_t)e##name(env, op1, op2); \
1341 HELPER_SPE_VECTOR_ARITH(fsadd
);
1343 HELPER_SPE_VECTOR_ARITH(fssub
);
1345 HELPER_SPE_VECTOR_ARITH(fsmul
);
1347 HELPER_SPE_VECTOR_ARITH(fsdiv
);
1349 /* Single-precision floating-point comparisons */
1350 static inline uint32_t efscmplt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1356 return float32_lt(u1
.f
, u2
.f
, &env
->vec_status
) ? 4 : 0;
1359 static inline uint32_t efscmpgt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1365 return float32_le(u1
.f
, u2
.f
, &env
->vec_status
) ? 0 : 4;
1368 static inline uint32_t efscmpeq(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1374 return float32_eq(u1
.f
, u2
.f
, &env
->vec_status
) ? 4 : 0;
1377 static inline uint32_t efststlt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1379 /* XXX: TODO: ignore special values (NaN, infinites, ...) */
1380 return efscmplt(env
, op1
, op2
);
1383 static inline uint32_t efststgt(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1385 /* XXX: TODO: ignore special values (NaN, infinites, ...) */
1386 return efscmpgt(env
, op1
, op2
);
1389 static inline uint32_t efststeq(CPUPPCState
*env
, uint32_t op1
, uint32_t op2
)
1391 /* XXX: TODO: ignore special values (NaN, infinites, ...) */
1392 return efscmpeq(env
, op1
, op2
);
1395 #define HELPER_SINGLE_SPE_CMP(name) \
1396 uint32_t helper_e##name(CPUPPCState *env, uint32_t op1, uint32_t op2) \
1398 return e##name(env, op1, op2) << 2; \
1401 HELPER_SINGLE_SPE_CMP(fststlt
);
1403 HELPER_SINGLE_SPE_CMP(fststgt
);
1405 HELPER_SINGLE_SPE_CMP(fststeq
);
1407 HELPER_SINGLE_SPE_CMP(fscmplt
);
1409 HELPER_SINGLE_SPE_CMP(fscmpgt
);
1411 HELPER_SINGLE_SPE_CMP(fscmpeq
);
1413 static inline uint32_t evcmp_merge(int t0
, int t1
)
1415 return (t0
<< 3) | (t1
<< 2) | ((t0
| t1
) << 1) | (t0
& t1
);
1418 #define HELPER_VECTOR_SPE_CMP(name) \
1419 uint32_t helper_ev##name(CPUPPCState *env, uint64_t op1, uint64_t op2) \
1421 return evcmp_merge(e##name(env, op1 >> 32, op2 >> 32), \
1422 e##name(env, op1, op2)); \
1425 HELPER_VECTOR_SPE_CMP(fststlt
);
1427 HELPER_VECTOR_SPE_CMP(fststgt
);
1429 HELPER_VECTOR_SPE_CMP(fststeq
);
1431 HELPER_VECTOR_SPE_CMP(fscmplt
);
1433 HELPER_VECTOR_SPE_CMP(fscmpgt
);
1435 HELPER_VECTOR_SPE_CMP(fscmpeq
);
1437 /* Double-precision floating-point conversion */
1438 uint64_t helper_efdcfsi(CPUPPCState
*env
, uint32_t val
)
1442 u
.d
= int32_to_float64(val
, &env
->vec_status
);
1447 uint64_t helper_efdcfsid(CPUPPCState
*env
, uint64_t val
)
1451 u
.d
= int64_to_float64(val
, &env
->vec_status
);
1456 uint64_t helper_efdcfui(CPUPPCState
*env
, uint32_t val
)
1460 u
.d
= uint32_to_float64(val
, &env
->vec_status
);
1465 uint64_t helper_efdcfuid(CPUPPCState
*env
, uint64_t val
)
1469 u
.d
= uint64_to_float64(val
, &env
->vec_status
);
1474 uint32_t helper_efdctsi(CPUPPCState
*env
, uint64_t val
)
1479 /* NaN are not treated the same way IEEE 754 does */
1480 if (unlikely(float64_is_any_nan(u
.d
))) {
1484 return float64_to_int32(u
.d
, &env
->vec_status
);
1487 uint32_t helper_efdctui(CPUPPCState
*env
, uint64_t val
)
1492 /* NaN are not treated the same way IEEE 754 does */
1493 if (unlikely(float64_is_any_nan(u
.d
))) {
1497 return float64_to_uint32(u
.d
, &env
->vec_status
);
1500 uint32_t helper_efdctsiz(CPUPPCState
*env
, uint64_t val
)
1505 /* NaN are not treated the same way IEEE 754 does */
1506 if (unlikely(float64_is_any_nan(u
.d
))) {
1510 return float64_to_int32_round_to_zero(u
.d
, &env
->vec_status
);
1513 uint64_t helper_efdctsidz(CPUPPCState
*env
, uint64_t val
)
1518 /* NaN are not treated the same way IEEE 754 does */
1519 if (unlikely(float64_is_any_nan(u
.d
))) {
1523 return float64_to_int64_round_to_zero(u
.d
, &env
->vec_status
);
1526 uint32_t helper_efdctuiz(CPUPPCState
*env
, uint64_t val
)
1531 /* NaN are not treated the same way IEEE 754 does */
1532 if (unlikely(float64_is_any_nan(u
.d
))) {
1536 return float64_to_uint32_round_to_zero(u
.d
, &env
->vec_status
);
1539 uint64_t helper_efdctuidz(CPUPPCState
*env
, uint64_t val
)
1544 /* NaN are not treated the same way IEEE 754 does */
1545 if (unlikely(float64_is_any_nan(u
.d
))) {
1549 return float64_to_uint64_round_to_zero(u
.d
, &env
->vec_status
);
1552 uint64_t helper_efdcfsf(CPUPPCState
*env
, uint32_t val
)
1557 u
.d
= int32_to_float64(val
, &env
->vec_status
);
1558 tmp
= int64_to_float64(1ULL << 32, &env
->vec_status
);
1559 u
.d
= float64_div(u
.d
, tmp
, &env
->vec_status
);
1564 uint64_t helper_efdcfuf(CPUPPCState
*env
, uint32_t val
)
1569 u
.d
= uint32_to_float64(val
, &env
->vec_status
);
1570 tmp
= int64_to_float64(1ULL << 32, &env
->vec_status
);
1571 u
.d
= float64_div(u
.d
, tmp
, &env
->vec_status
);
1576 uint32_t helper_efdctsf(CPUPPCState
*env
, uint64_t val
)
1582 /* NaN are not treated the same way IEEE 754 does */
1583 if (unlikely(float64_is_any_nan(u
.d
))) {
1586 tmp
= uint64_to_float64(1ULL << 32, &env
->vec_status
);
1587 u
.d
= float64_mul(u
.d
, tmp
, &env
->vec_status
);
1589 return float64_to_int32(u
.d
, &env
->vec_status
);
1592 uint32_t helper_efdctuf(CPUPPCState
*env
, uint64_t val
)
1598 /* NaN are not treated the same way IEEE 754 does */
1599 if (unlikely(float64_is_any_nan(u
.d
))) {
1602 tmp
= uint64_to_float64(1ULL << 32, &env
->vec_status
);
1603 u
.d
= float64_mul(u
.d
, tmp
, &env
->vec_status
);
1605 return float64_to_uint32(u
.d
, &env
->vec_status
);
1608 uint32_t helper_efscfd(CPUPPCState
*env
, uint64_t val
)
1614 u2
.f
= float64_to_float32(u1
.d
, &env
->vec_status
);
1619 uint64_t helper_efdcfs(CPUPPCState
*env
, uint32_t val
)
1625 u2
.d
= float32_to_float64(u1
.f
, &env
->vec_status
);
1630 /* Double precision fixed-point arithmetic */
1631 uint64_t helper_efdadd(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1637 u1
.d
= float64_add(u1
.d
, u2
.d
, &env
->vec_status
);
1641 uint64_t helper_efdsub(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1647 u1
.d
= float64_sub(u1
.d
, u2
.d
, &env
->vec_status
);
1651 uint64_t helper_efdmul(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1657 u1
.d
= float64_mul(u1
.d
, u2
.d
, &env
->vec_status
);
1661 uint64_t helper_efddiv(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1667 u1
.d
= float64_div(u1
.d
, u2
.d
, &env
->vec_status
);
1671 /* Double precision floating point helpers */
1672 uint32_t helper_efdtstlt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1678 return float64_lt(u1
.d
, u2
.d
, &env
->vec_status
) ? 4 : 0;
1681 uint32_t helper_efdtstgt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1687 return float64_le(u1
.d
, u2
.d
, &env
->vec_status
) ? 0 : 4;
1690 uint32_t helper_efdtsteq(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1696 return float64_eq_quiet(u1
.d
, u2
.d
, &env
->vec_status
) ? 4 : 0;
1699 uint32_t helper_efdcmplt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1701 /* XXX: TODO: test special values (NaN, infinites, ...) */
1702 return helper_efdtstlt(env
, op1
, op2
);
1705 uint32_t helper_efdcmpgt(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1707 /* XXX: TODO: test special values (NaN, infinites, ...) */
1708 return helper_efdtstgt(env
, op1
, op2
);
1711 uint32_t helper_efdcmpeq(CPUPPCState
*env
, uint64_t op1
, uint64_t op2
)
1713 /* XXX: TODO: test special values (NaN, infinites, ...) */
1714 return helper_efdtsteq(env
, op1
, op2
);