4 * The code in this source file is derived from release 2a of the SoftFloat
5 * IEC/IEEE Floating-point Arithmetic Package. Those parts of the code (and
6 * some later contributions) are provided under that license, as detailed below.
7 * It has subsequently been modified by contributors to the QEMU Project,
8 * so some portions are provided under:
9 * the SoftFloat-2a license
13 * Any future contributions to this file after December 1st 2014 will be
14 * taken to be licensed under the Softfloat-2a license unless specifically
15 * indicated otherwise.
19 ===============================================================================
20 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
21 Arithmetic Package, Release 2a.
23 Written by John R. Hauser. This work was made possible in part by the
24 International Computer Science Institute, located at Suite 600, 1947 Center
25 Street, Berkeley, California 94704. Funding was partially provided by the
26 National Science Foundation under grant MIP-9311980. The original version
27 of this code was written as part of a project to build a fixed-point vector
28 processor in collaboration with the University of California at Berkeley,
29 overseen by Profs. Nelson Morgan and John Wawrzynek. More information
30 is available through the Web page `http://HTTP.CS.Berkeley.EDU/~jhauser/
31 arithmetic/SoftFloat.html'.
33 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort
34 has been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT
35 TIMES RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO
36 PERSONS AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ANY
37 AND ALL LOSSES, COSTS, OR OTHER PROBLEMS ARISING FROM ITS USE.
39 Derivative works are acceptable, even for commercial purposes, so long as
40 (1) they include prominent notice that the work is derivative, and (2) they
41 include prominent notice akin to these four paragraphs for those parts of
42 this code that are retained.
44 ===============================================================================
48 * Copyright (c) 2006, Fabrice Bellard
49 * All rights reserved.
51 * Redistribution and use in source and binary forms, with or without
52 * modification, are permitted provided that the following conditions are met:
54 * 1. Redistributions of source code must retain the above copyright notice,
55 * this list of conditions and the following disclaimer.
57 * 2. Redistributions in binary form must reproduce the above copyright notice,
58 * this list of conditions and the following disclaimer in the documentation
59 * and/or other materials provided with the distribution.
61 * 3. Neither the name of the copyright holder nor the names of its contributors
62 * may be used to endorse or promote products derived from this software without
63 * specific prior written permission.
65 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
66 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
67 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
68 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
69 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
70 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
71 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
72 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
73 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
74 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
75 * THE POSSIBILITY OF SUCH DAMAGE.
78 /* Portions of this work are licensed under the terms of the GNU GPL,
79 * version 2 or later. See the COPYING file in the top-level directory.
82 #if defined(TARGET_XTENSA)
83 /* Define for architectures which deviate from IEEE in not supporting
84 * signaling NaNs (so all NaNs are treated as quiet).
86 #define NO_SIGNALING_NANS 1
89 /*----------------------------------------------------------------------------
90 | The pattern for a default generated half-precision NaN.
91 *----------------------------------------------------------------------------*/
92 float16
float16_default_nan(float_status
*status
)
94 #if defined(TARGET_ARM)
95 return const_float16(0x7E00);
97 if (status
->snan_bit_is_one
) {
98 return const_float16(0x7DFF);
100 #if defined(TARGET_MIPS)
101 return const_float16(0x7E00);
103 return const_float16(0xFE00);
109 /*----------------------------------------------------------------------------
110 | The pattern for a default generated single-precision NaN.
111 *----------------------------------------------------------------------------*/
112 float32
float32_default_nan(float_status
*status
)
114 #if defined(TARGET_SPARC)
115 return const_float32(0x7FFFFFFF);
116 #elif defined(TARGET_PPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA) || \
117 defined(TARGET_XTENSA) || defined(TARGET_S390X) || defined(TARGET_TRICORE)
118 return const_float32(0x7FC00000);
120 if (status
->snan_bit_is_one
) {
121 return const_float32(0x7FBFFFFF);
123 #if defined(TARGET_MIPS)
124 return const_float32(0x7FC00000);
126 return const_float32(0xFFC00000);
132 /*----------------------------------------------------------------------------
133 | The pattern for a default generated double-precision NaN.
134 *----------------------------------------------------------------------------*/
135 float64
float64_default_nan(float_status
*status
)
137 #if defined(TARGET_SPARC)
138 return const_float64(LIT64(0x7FFFFFFFFFFFFFFF));
139 #elif defined(TARGET_PPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA) || \
140 defined(TARGET_S390X)
141 return const_float64(LIT64(0x7FF8000000000000));
143 if (status
->snan_bit_is_one
) {
144 return const_float64(LIT64(0x7FF7FFFFFFFFFFFF));
146 #if defined(TARGET_MIPS)
147 return const_float64(LIT64(0x7FF8000000000000));
149 return const_float64(LIT64(0xFFF8000000000000));
155 /*----------------------------------------------------------------------------
156 | The pattern for a default generated extended double-precision NaN.
157 *----------------------------------------------------------------------------*/
158 floatx80
floatx80_default_nan(float_status
*status
)
162 if (status
->snan_bit_is_one
) {
163 r
.low
= LIT64(0xBFFFFFFFFFFFFFFF);
166 r
.low
= LIT64(0xC000000000000000);
172 /*----------------------------------------------------------------------------
173 | The pattern for a default generated quadruple-precision NaN.
174 *----------------------------------------------------------------------------*/
175 float128
float128_default_nan(float_status
*status
)
179 if (status
->snan_bit_is_one
) {
180 r
.low
= LIT64(0xFFFFFFFFFFFFFFFF);
181 r
.high
= LIT64(0x7FFF7FFFFFFFFFFF);
183 r
.low
= LIT64(0x0000000000000000);
184 #if defined(TARGET_S390X)
185 r
.high
= LIT64(0x7FFF800000000000);
187 r
.high
= LIT64(0xFFFF800000000000);
193 /*----------------------------------------------------------------------------
194 | Raises the exceptions specified by `flags'. Floating-point traps can be
195 | defined here if desired. It is currently not possible for such a trap
196 | to substitute a result value. If traps are not implemented, this routine
197 | should be simply `float_exception_flags |= flags;'.
198 *----------------------------------------------------------------------------*/
200 void float_raise(int8_t flags
, float_status
*status
)
202 status
->float_exception_flags
|= flags
;
205 /*----------------------------------------------------------------------------
206 | Internal canonical NaN format.
207 *----------------------------------------------------------------------------*/
213 #ifdef NO_SIGNALING_NANS
214 int float16_is_quiet_nan(float16 a_
, float_status
*status
)
216 return float16_is_any_nan(a_
);
219 int float16_is_signaling_nan(float16 a_
, float_status
*status
)
224 /*----------------------------------------------------------------------------
225 | Returns 1 if the half-precision floating-point value `a' is a quiet
226 | NaN; otherwise returns 0.
227 *----------------------------------------------------------------------------*/
229 int float16_is_quiet_nan(float16 a_
, float_status
*status
)
231 uint16_t a
= float16_val(a_
);
232 if (status
->snan_bit_is_one
) {
233 return (((a
>> 9) & 0x3F) == 0x3E) && (a
& 0x1FF);
235 return ((a
& ~0x8000) >= 0x7C80);
239 /*----------------------------------------------------------------------------
240 | Returns 1 if the half-precision floating-point value `a' is a signaling
241 | NaN; otherwise returns 0.
242 *----------------------------------------------------------------------------*/
244 int float16_is_signaling_nan(float16 a_
, float_status
*status
)
246 uint16_t a
= float16_val(a_
);
247 if (status
->snan_bit_is_one
) {
248 return ((a
& ~0x8000) >= 0x7C80);
250 return (((a
>> 9) & 0x3F) == 0x3E) && (a
& 0x1FF);
255 /*----------------------------------------------------------------------------
256 | Returns a quiet NaN if the half-precision floating point value `a' is a
257 | signaling NaN; otherwise returns `a'.
258 *----------------------------------------------------------------------------*/
259 float16
float16_maybe_silence_nan(float16 a_
, float_status
*status
)
261 if (float16_is_signaling_nan(a_
, status
)) {
262 if (status
->snan_bit_is_one
) {
263 return float16_default_nan(status
);
265 uint16_t a
= float16_val(a_
);
267 return make_float16(a
);
273 /*----------------------------------------------------------------------------
274 | Returns the result of converting the half-precision floating-point NaN
275 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
276 | exception is raised.
277 *----------------------------------------------------------------------------*/
279 static commonNaNT
float16ToCommonNaN(float16 a
, float_status
*status
)
283 if (float16_is_signaling_nan(a
, status
)) {
284 float_raise(float_flag_invalid
, status
);
286 z
.sign
= float16_val(a
) >> 15;
288 z
.high
= ((uint64_t) float16_val(a
)) << 54;
292 /*----------------------------------------------------------------------------
293 | Returns the result of converting the canonical NaN `a' to the half-
294 | precision floating-point format.
295 *----------------------------------------------------------------------------*/
297 static float16
commonNaNToFloat16(commonNaNT a
, float_status
*status
)
299 uint16_t mantissa
= a
.high
>> 54;
301 if (status
->default_nan_mode
) {
302 return float16_default_nan(status
);
306 return make_float16(((((uint16_t) a
.sign
) << 15)
307 | (0x1F << 10) | mantissa
));
309 return float16_default_nan(status
);
313 #ifdef NO_SIGNALING_NANS
314 int float32_is_quiet_nan(float32 a_
, float_status
*status
)
316 return float32_is_any_nan(a_
);
319 int float32_is_signaling_nan(float32 a_
, float_status
*status
)
324 /*----------------------------------------------------------------------------
325 | Returns 1 if the single-precision floating-point value `a' is a quiet
326 | NaN; otherwise returns 0.
327 *----------------------------------------------------------------------------*/
329 int float32_is_quiet_nan(float32 a_
, float_status
*status
)
331 uint32_t a
= float32_val(a_
);
332 if (status
->snan_bit_is_one
) {
333 return (((a
>> 22) & 0x1FF) == 0x1FE) && (a
& 0x003FFFFF);
335 return ((uint32_t)(a
<< 1) >= 0xFF800000);
339 /*----------------------------------------------------------------------------
340 | Returns 1 if the single-precision floating-point value `a' is a signaling
341 | NaN; otherwise returns 0.
342 *----------------------------------------------------------------------------*/
344 int float32_is_signaling_nan(float32 a_
, float_status
*status
)
346 uint32_t a
= float32_val(a_
);
347 if (status
->snan_bit_is_one
) {
348 return ((uint32_t)(a
<< 1) >= 0xFF800000);
350 return (((a
>> 22) & 0x1FF) == 0x1FE) && (a
& 0x003FFFFF);
355 /*----------------------------------------------------------------------------
356 | Returns a quiet NaN if the single-precision floating point value `a' is a
357 | signaling NaN; otherwise returns `a'.
358 *----------------------------------------------------------------------------*/
360 float32
float32_maybe_silence_nan(float32 a_
, float_status
*status
)
362 if (float32_is_signaling_nan(a_
, status
)) {
363 if (status
->snan_bit_is_one
) {
364 return float32_default_nan(status
);
366 uint32_t a
= float32_val(a_
);
368 return make_float32(a
);
374 /*----------------------------------------------------------------------------
375 | Returns the result of converting the single-precision floating-point NaN
376 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
377 | exception is raised.
378 *----------------------------------------------------------------------------*/
380 static commonNaNT
float32ToCommonNaN(float32 a
, float_status
*status
)
384 if (float32_is_signaling_nan(a
, status
)) {
385 float_raise(float_flag_invalid
, status
);
387 z
.sign
= float32_val(a
) >> 31;
389 z
.high
= ((uint64_t)float32_val(a
)) << 41;
393 /*----------------------------------------------------------------------------
394 | Returns the result of converting the canonical NaN `a' to the single-
395 | precision floating-point format.
396 *----------------------------------------------------------------------------*/
398 static float32
commonNaNToFloat32(commonNaNT a
, float_status
*status
)
400 uint32_t mantissa
= a
.high
>> 41;
402 if (status
->default_nan_mode
) {
403 return float32_default_nan(status
);
408 (((uint32_t)a
.sign
) << 31) | 0x7F800000 | (a
.high
>> 41));
410 return float32_default_nan(status
);
414 /*----------------------------------------------------------------------------
415 | Select which NaN to propagate for a two-input operation.
416 | IEEE754 doesn't specify all the details of this, so the
417 | algorithm is target-specific.
418 | The routine is passed various bits of information about the
419 | two NaNs and should return 0 to select NaN a and 1 for NaN b.
420 | Note that signalling NaNs are always squashed to quiet NaNs
421 | by the caller, by calling floatXX_maybe_silence_nan() before
424 | aIsLargerSignificand is only valid if both a and b are NaNs
425 | of some kind, and is true if a has the larger significand,
426 | or if both a and b have the same significand but a is
427 | positive but b is negative. It is only needed for the x87
429 *----------------------------------------------------------------------------*/
431 #if defined(TARGET_ARM)
432 static int pickNaN(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
433 flag aIsLargerSignificand
)
435 /* ARM mandated NaN propagation rules: take the first of:
436 * 1. A if it is signaling
437 * 2. B if it is signaling
440 * A signaling NaN is always quietened before returning it.
444 } else if (bIsSNaN
) {
446 } else if (aIsQNaN
) {
452 #elif defined(TARGET_MIPS)
453 static int pickNaN(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
454 flag aIsLargerSignificand
)
456 /* According to MIPS specifications, if one of the two operands is
457 * a sNaN, a new qNaN has to be generated. This is done in
458 * floatXX_maybe_silence_nan(). For qNaN inputs the specifications
459 * says: "When possible, this QNaN result is one of the operand QNaN
460 * values." In practice it seems that most implementations choose
461 * the first operand if both operands are qNaN. In short this gives
462 * the following rules:
463 * 1. A if it is signaling
464 * 2. B if it is signaling
467 * A signaling NaN is always silenced before returning it.
471 } else if (bIsSNaN
) {
473 } else if (aIsQNaN
) {
479 #elif defined(TARGET_PPC) || defined(TARGET_XTENSA)
480 static int pickNaN(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
481 flag aIsLargerSignificand
)
483 /* PowerPC propagation rules:
484 * 1. A if it sNaN or qNaN
485 * 2. B if it sNaN or qNaN
486 * A signaling NaN is always silenced before returning it.
488 if (aIsSNaN
|| aIsQNaN
) {
495 static int pickNaN(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
496 flag aIsLargerSignificand
)
498 /* This implements x87 NaN propagation rules:
499 * SNaN + QNaN => return the QNaN
500 * two SNaNs => return the one with the larger significand, silenced
501 * two QNaNs => return the one with the larger significand
502 * SNaN and a non-NaN => return the SNaN, silenced
503 * QNaN and a non-NaN => return the QNaN
505 * If we get down to comparing significands and they are the same,
506 * return the NaN with the positive sign bit (if any).
510 return aIsLargerSignificand
? 0 : 1;
512 return bIsQNaN
? 1 : 0;
513 } else if (aIsQNaN
) {
514 if (bIsSNaN
|| !bIsQNaN
) {
517 return aIsLargerSignificand
? 0 : 1;
525 /*----------------------------------------------------------------------------
526 | Select which NaN to propagate for a three-input operation.
527 | For the moment we assume that no CPU needs the 'larger significand'
529 | Return values : 0 : a; 1 : b; 2 : c; 3 : default-NaN
530 *----------------------------------------------------------------------------*/
531 #if defined(TARGET_ARM)
532 static int pickNaNMulAdd(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
533 flag cIsQNaN
, flag cIsSNaN
, flag infzero
,
534 float_status
*status
)
536 /* For ARM, the (inf,zero,qnan) case sets InvalidOp and returns
539 if (infzero
&& cIsQNaN
) {
540 float_raise(float_flag_invalid
, status
);
544 /* This looks different from the ARM ARM pseudocode, because the ARM ARM
545 * puts the operands to a fused mac operation (a*b)+c in the order c,a,b.
549 } else if (aIsSNaN
) {
551 } else if (bIsSNaN
) {
553 } else if (cIsQNaN
) {
555 } else if (aIsQNaN
) {
561 #elif defined(TARGET_MIPS)
562 static int pickNaNMulAdd(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
563 flag cIsQNaN
, flag cIsSNaN
, flag infzero
,
564 float_status
*status
)
566 /* For MIPS, the (inf,zero,qnan) case sets InvalidOp and returns
570 float_raise(float_flag_invalid
, status
);
574 /* Prefer sNaN over qNaN, in the a, b, c order. */
577 } else if (bIsSNaN
) {
579 } else if (cIsSNaN
) {
581 } else if (aIsQNaN
) {
583 } else if (bIsQNaN
) {
589 #elif defined(TARGET_PPC)
590 static int pickNaNMulAdd(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
591 flag cIsQNaN
, flag cIsSNaN
, flag infzero
,
592 float_status
*status
)
594 /* For PPC, the (inf,zero,qnan) case sets InvalidOp, but we prefer
595 * to return an input NaN if we have one (ie c) rather than generating
599 float_raise(float_flag_invalid
, status
);
603 /* If fRA is a NaN return it; otherwise if fRB is a NaN return it;
604 * otherwise return fRC. Note that muladd on PPC is (fRA * fRC) + frB
606 if (aIsSNaN
|| aIsQNaN
) {
608 } else if (cIsSNaN
|| cIsQNaN
) {
615 /* A default implementation: prefer a to b to c.
616 * This is unlikely to actually match any real implementation.
618 static int pickNaNMulAdd(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
619 flag cIsQNaN
, flag cIsSNaN
, flag infzero
,
620 float_status
*status
)
622 if (aIsSNaN
|| aIsQNaN
) {
624 } else if (bIsSNaN
|| bIsQNaN
) {
632 /*----------------------------------------------------------------------------
633 | Takes two single-precision floating-point values `a' and `b', one of which
634 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
635 | signaling NaN, the invalid exception is raised.
636 *----------------------------------------------------------------------------*/
638 static float32
propagateFloat32NaN(float32 a
, float32 b
, float_status
*status
)
640 flag aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
;
641 flag aIsLargerSignificand
;
644 aIsQuietNaN
= float32_is_quiet_nan(a
, status
);
645 aIsSignalingNaN
= float32_is_signaling_nan(a
, status
);
646 bIsQuietNaN
= float32_is_quiet_nan(b
, status
);
647 bIsSignalingNaN
= float32_is_signaling_nan(b
, status
);
651 if (aIsSignalingNaN
| bIsSignalingNaN
) {
652 float_raise(float_flag_invalid
, status
);
655 if (status
->default_nan_mode
) {
656 return float32_default_nan(status
);
659 if ((uint32_t)(av
<< 1) < (uint32_t)(bv
<< 1)) {
660 aIsLargerSignificand
= 0;
661 } else if ((uint32_t)(bv
<< 1) < (uint32_t)(av
<< 1)) {
662 aIsLargerSignificand
= 1;
664 aIsLargerSignificand
= (av
< bv
) ? 1 : 0;
667 if (pickNaN(aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
,
668 aIsLargerSignificand
)) {
669 return float32_maybe_silence_nan(b
, status
);
671 return float32_maybe_silence_nan(a
, status
);
675 /*----------------------------------------------------------------------------
676 | Takes three single-precision floating-point values `a', `b' and `c', one of
677 | which is a NaN, and returns the appropriate NaN result. If any of `a',
678 | `b' or `c' is a signaling NaN, the invalid exception is raised.
679 | The input infzero indicates whether a*b was 0*inf or inf*0 (in which case
680 | obviously c is a NaN, and whether to propagate c or some other NaN is
681 | implementation defined).
682 *----------------------------------------------------------------------------*/
684 static float32
propagateFloat32MulAddNaN(float32 a
, float32 b
,
685 float32 c
, flag infzero
,
686 float_status
*status
)
688 flag aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
,
689 cIsQuietNaN
, cIsSignalingNaN
;
692 aIsQuietNaN
= float32_is_quiet_nan(a
, status
);
693 aIsSignalingNaN
= float32_is_signaling_nan(a
, status
);
694 bIsQuietNaN
= float32_is_quiet_nan(b
, status
);
695 bIsSignalingNaN
= float32_is_signaling_nan(b
, status
);
696 cIsQuietNaN
= float32_is_quiet_nan(c
, status
);
697 cIsSignalingNaN
= float32_is_signaling_nan(c
, status
);
699 if (aIsSignalingNaN
| bIsSignalingNaN
| cIsSignalingNaN
) {
700 float_raise(float_flag_invalid
, status
);
703 which
= pickNaNMulAdd(aIsQuietNaN
, aIsSignalingNaN
,
704 bIsQuietNaN
, bIsSignalingNaN
,
705 cIsQuietNaN
, cIsSignalingNaN
, infzero
, status
);
707 if (status
->default_nan_mode
) {
708 /* Note that this check is after pickNaNMulAdd so that function
709 * has an opportunity to set the Invalid flag.
711 return float32_default_nan(status
);
716 return float32_maybe_silence_nan(a
, status
);
718 return float32_maybe_silence_nan(b
, status
);
720 return float32_maybe_silence_nan(c
, status
);
723 return float32_default_nan(status
);
727 #ifdef NO_SIGNALING_NANS
728 int float64_is_quiet_nan(float64 a_
, float_status
*status
)
730 return float64_is_any_nan(a_
);
733 int float64_is_signaling_nan(float64 a_
, float_status
*status
)
738 /*----------------------------------------------------------------------------
739 | Returns 1 if the double-precision floating-point value `a' is a quiet
740 | NaN; otherwise returns 0.
741 *----------------------------------------------------------------------------*/
743 int float64_is_quiet_nan(float64 a_
, float_status
*status
)
745 uint64_t a
= float64_val(a_
);
746 if (status
->snan_bit_is_one
) {
747 return (((a
>> 51) & 0xFFF) == 0xFFE)
748 && (a
& 0x0007FFFFFFFFFFFFULL
);
750 return ((a
<< 1) >= 0xFFF0000000000000ULL
);
754 /*----------------------------------------------------------------------------
755 | Returns 1 if the double-precision floating-point value `a' is a signaling
756 | NaN; otherwise returns 0.
757 *----------------------------------------------------------------------------*/
759 int float64_is_signaling_nan(float64 a_
, float_status
*status
)
761 uint64_t a
= float64_val(a_
);
762 if (status
->snan_bit_is_one
) {
763 return ((a
<< 1) >= 0xFFF0000000000000ULL
);
765 return (((a
>> 51) & 0xFFF) == 0xFFE)
766 && (a
& LIT64(0x0007FFFFFFFFFFFF));
771 /*----------------------------------------------------------------------------
772 | Returns a quiet NaN if the double-precision floating point value `a' is a
773 | signaling NaN; otherwise returns `a'.
774 *----------------------------------------------------------------------------*/
776 float64
float64_maybe_silence_nan(float64 a_
, float_status
*status
)
778 if (float64_is_signaling_nan(a_
, status
)) {
779 if (status
->snan_bit_is_one
) {
780 return float64_default_nan(status
);
782 uint64_t a
= float64_val(a_
);
783 a
|= LIT64(0x0008000000000000);
784 return make_float64(a
);
790 /*----------------------------------------------------------------------------
791 | Returns the result of converting the double-precision floating-point NaN
792 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
793 | exception is raised.
794 *----------------------------------------------------------------------------*/
796 static commonNaNT
float64ToCommonNaN(float64 a
, float_status
*status
)
800 if (float64_is_signaling_nan(a
, status
)) {
801 float_raise(float_flag_invalid
, status
);
803 z
.sign
= float64_val(a
) >> 63;
805 z
.high
= float64_val(a
) << 12;
809 /*----------------------------------------------------------------------------
810 | Returns the result of converting the canonical NaN `a' to the double-
811 | precision floating-point format.
812 *----------------------------------------------------------------------------*/
814 static float64
commonNaNToFloat64(commonNaNT a
, float_status
*status
)
816 uint64_t mantissa
= a
.high
>> 12;
818 if (status
->default_nan_mode
) {
819 return float64_default_nan(status
);
824 (((uint64_t) a
.sign
) << 63)
825 | LIT64(0x7FF0000000000000)
828 return float64_default_nan(status
);
832 /*----------------------------------------------------------------------------
833 | Takes two double-precision floating-point values `a' and `b', one of which
834 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
835 | signaling NaN, the invalid exception is raised.
836 *----------------------------------------------------------------------------*/
838 static float64
propagateFloat64NaN(float64 a
, float64 b
, float_status
*status
)
840 flag aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
;
841 flag aIsLargerSignificand
;
844 aIsQuietNaN
= float64_is_quiet_nan(a
, status
);
845 aIsSignalingNaN
= float64_is_signaling_nan(a
, status
);
846 bIsQuietNaN
= float64_is_quiet_nan(b
, status
);
847 bIsSignalingNaN
= float64_is_signaling_nan(b
, status
);
851 if (aIsSignalingNaN
| bIsSignalingNaN
) {
852 float_raise(float_flag_invalid
, status
);
855 if (status
->default_nan_mode
) {
856 return float64_default_nan(status
);
859 if ((uint64_t)(av
<< 1) < (uint64_t)(bv
<< 1)) {
860 aIsLargerSignificand
= 0;
861 } else if ((uint64_t)(bv
<< 1) < (uint64_t)(av
<< 1)) {
862 aIsLargerSignificand
= 1;
864 aIsLargerSignificand
= (av
< bv
) ? 1 : 0;
867 if (pickNaN(aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
,
868 aIsLargerSignificand
)) {
869 return float64_maybe_silence_nan(b
, status
);
871 return float64_maybe_silence_nan(a
, status
);
875 /*----------------------------------------------------------------------------
876 | Takes three double-precision floating-point values `a', `b' and `c', one of
877 | which is a NaN, and returns the appropriate NaN result. If any of `a',
878 | `b' or `c' is a signaling NaN, the invalid exception is raised.
879 | The input infzero indicates whether a*b was 0*inf or inf*0 (in which case
880 | obviously c is a NaN, and whether to propagate c or some other NaN is
881 | implementation defined).
882 *----------------------------------------------------------------------------*/
884 static float64
propagateFloat64MulAddNaN(float64 a
, float64 b
,
885 float64 c
, flag infzero
,
886 float_status
*status
)
888 flag aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
,
889 cIsQuietNaN
, cIsSignalingNaN
;
892 aIsQuietNaN
= float64_is_quiet_nan(a
, status
);
893 aIsSignalingNaN
= float64_is_signaling_nan(a
, status
);
894 bIsQuietNaN
= float64_is_quiet_nan(b
, status
);
895 bIsSignalingNaN
= float64_is_signaling_nan(b
, status
);
896 cIsQuietNaN
= float64_is_quiet_nan(c
, status
);
897 cIsSignalingNaN
= float64_is_signaling_nan(c
, status
);
899 if (aIsSignalingNaN
| bIsSignalingNaN
| cIsSignalingNaN
) {
900 float_raise(float_flag_invalid
, status
);
903 which
= pickNaNMulAdd(aIsQuietNaN
, aIsSignalingNaN
,
904 bIsQuietNaN
, bIsSignalingNaN
,
905 cIsQuietNaN
, cIsSignalingNaN
, infzero
, status
);
907 if (status
->default_nan_mode
) {
908 /* Note that this check is after pickNaNMulAdd so that function
909 * has an opportunity to set the Invalid flag.
911 return float64_default_nan(status
);
916 return float64_maybe_silence_nan(a
, status
);
918 return float64_maybe_silence_nan(b
, status
);
920 return float64_maybe_silence_nan(c
, status
);
923 return float64_default_nan(status
);
927 #ifdef NO_SIGNALING_NANS
928 int floatx80_is_quiet_nan(floatx80 a_
, float_status
*status
)
930 return floatx80_is_any_nan(a_
);
933 int floatx80_is_signaling_nan(floatx80 a_
, float_status
*status
)
938 /*----------------------------------------------------------------------------
939 | Returns 1 if the extended double-precision floating-point value `a' is a
940 | quiet NaN; otherwise returns 0. This slightly differs from the same
941 | function for other types as floatx80 has an explicit bit.
942 *----------------------------------------------------------------------------*/
944 int floatx80_is_quiet_nan(floatx80 a
, float_status
*status
)
946 if (status
->snan_bit_is_one
) {
949 aLow
= a
.low
& ~0x4000000000000000ULL
;
950 return ((a
.high
& 0x7FFF) == 0x7FFF)
954 return ((a
.high
& 0x7FFF) == 0x7FFF)
955 && (LIT64(0x8000000000000000) <= ((uint64_t)(a
.low
<< 1)));
959 /*----------------------------------------------------------------------------
960 | Returns 1 if the extended double-precision floating-point value `a' is a
961 | signaling NaN; otherwise returns 0. This slightly differs from the same
962 | function for other types as floatx80 has an explicit bit.
963 *----------------------------------------------------------------------------*/
965 int floatx80_is_signaling_nan(floatx80 a
, float_status
*status
)
967 if (status
->snan_bit_is_one
) {
968 return ((a
.high
& 0x7FFF) == 0x7FFF)
969 && ((a
.low
<< 1) >= 0x8000000000000000ULL
);
973 aLow
= a
.low
& ~LIT64(0x4000000000000000);
974 return ((a
.high
& 0x7FFF) == 0x7FFF)
975 && (uint64_t)(aLow
<< 1)
981 /*----------------------------------------------------------------------------
982 | Returns a quiet NaN if the extended double-precision floating point value
983 | `a' is a signaling NaN; otherwise returns `a'.
984 *----------------------------------------------------------------------------*/
986 floatx80
floatx80_maybe_silence_nan(floatx80 a
, float_status
*status
)
988 if (floatx80_is_signaling_nan(a
, status
)) {
989 if (status
->snan_bit_is_one
) {
990 a
= floatx80_default_nan(status
);
992 a
.low
|= LIT64(0xC000000000000000);
999 /*----------------------------------------------------------------------------
1000 | Returns the result of converting the extended double-precision floating-
1001 | point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
1002 | invalid exception is raised.
1003 *----------------------------------------------------------------------------*/
1005 static commonNaNT
floatx80ToCommonNaN(floatx80 a
, float_status
*status
)
1010 if (floatx80_is_signaling_nan(a
, status
)) {
1011 float_raise(float_flag_invalid
, status
);
1014 z
.sign
= a
.high
>> 15;
1016 z
.high
= a
.low
<< 1;
1018 dflt
= floatx80_default_nan(status
);
1019 z
.sign
= dflt
.high
>> 15;
1021 z
.high
= dflt
.low
<< 1;
1026 /*----------------------------------------------------------------------------
1027 | Returns the result of converting the canonical NaN `a' to the extended
1028 | double-precision floating-point format.
1029 *----------------------------------------------------------------------------*/
1031 static floatx80
commonNaNToFloatx80(commonNaNT a
, float_status
*status
)
1035 if (status
->default_nan_mode
) {
1036 return floatx80_default_nan(status
);
1040 z
.low
= LIT64(0x8000000000000000) | a
.high
>> 1;
1041 z
.high
= (((uint16_t)a
.sign
) << 15) | 0x7FFF;
1043 z
= floatx80_default_nan(status
);
1048 /*----------------------------------------------------------------------------
1049 | Takes two extended double-precision floating-point values `a' and `b', one
1050 | of which is a NaN, and returns the appropriate NaN result. If either `a' or
1051 | `b' is a signaling NaN, the invalid exception is raised.
1052 *----------------------------------------------------------------------------*/
1054 static floatx80
propagateFloatx80NaN(floatx80 a
, floatx80 b
,
1055 float_status
*status
)
1057 flag aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
;
1058 flag aIsLargerSignificand
;
1060 aIsQuietNaN
= floatx80_is_quiet_nan(a
, status
);
1061 aIsSignalingNaN
= floatx80_is_signaling_nan(a
, status
);
1062 bIsQuietNaN
= floatx80_is_quiet_nan(b
, status
);
1063 bIsSignalingNaN
= floatx80_is_signaling_nan(b
, status
);
1065 if (aIsSignalingNaN
| bIsSignalingNaN
) {
1066 float_raise(float_flag_invalid
, status
);
1069 if (status
->default_nan_mode
) {
1070 return floatx80_default_nan(status
);
1073 if (a
.low
< b
.low
) {
1074 aIsLargerSignificand
= 0;
1075 } else if (b
.low
< a
.low
) {
1076 aIsLargerSignificand
= 1;
1078 aIsLargerSignificand
= (a
.high
< b
.high
) ? 1 : 0;
1081 if (pickNaN(aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
,
1082 aIsLargerSignificand
)) {
1083 return floatx80_maybe_silence_nan(b
, status
);
1085 return floatx80_maybe_silence_nan(a
, status
);
1089 #ifdef NO_SIGNALING_NANS
1090 int float128_is_quiet_nan(float128 a_
, float_status
*status
)
1092 return float128_is_any_nan(a_
);
1095 int float128_is_signaling_nan(float128 a_
, float_status
*status
)
1100 /*----------------------------------------------------------------------------
1101 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
1102 | NaN; otherwise returns 0.
1103 *----------------------------------------------------------------------------*/
1105 int float128_is_quiet_nan(float128 a
, float_status
*status
)
1107 if (status
->snan_bit_is_one
) {
1108 return (((a
.high
>> 47) & 0xFFFF) == 0xFFFE)
1109 && (a
.low
|| (a
.high
& 0x00007FFFFFFFFFFFULL
));
1111 return ((a
.high
<< 1) >= 0xFFFF000000000000ULL
)
1112 && (a
.low
|| (a
.high
& 0x0000FFFFFFFFFFFFULL
));
1116 /*----------------------------------------------------------------------------
1117 | Returns 1 if the quadruple-precision floating-point value `a' is a
1118 | signaling NaN; otherwise returns 0.
1119 *----------------------------------------------------------------------------*/
1121 int float128_is_signaling_nan(float128 a
, float_status
*status
)
1123 if (status
->snan_bit_is_one
) {
1124 return ((a
.high
<< 1) >= 0xFFFF000000000000ULL
)
1125 && (a
.low
|| (a
.high
& 0x0000FFFFFFFFFFFFULL
));
1127 return (((a
.high
>> 47) & 0xFFFF) == 0xFFFE)
1128 && (a
.low
|| (a
.high
& LIT64(0x00007FFFFFFFFFFF)));
1133 /*----------------------------------------------------------------------------
1134 | Returns a quiet NaN if the quadruple-precision floating point value `a' is
1135 | a signaling NaN; otherwise returns `a'.
1136 *----------------------------------------------------------------------------*/
1138 float128
float128_maybe_silence_nan(float128 a
, float_status
*status
)
1140 if (float128_is_signaling_nan(a
, status
)) {
1141 if (status
->snan_bit_is_one
) {
1142 a
= float128_default_nan(status
);
1144 a
.high
|= LIT64(0x0000800000000000);
1151 /*----------------------------------------------------------------------------
1152 | Returns the result of converting the quadruple-precision floating-point NaN
1153 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
1154 | exception is raised.
1155 *----------------------------------------------------------------------------*/
1157 static commonNaNT
float128ToCommonNaN(float128 a
, float_status
*status
)
1161 if (float128_is_signaling_nan(a
, status
)) {
1162 float_raise(float_flag_invalid
, status
);
1164 z
.sign
= a
.high
>> 63;
1165 shortShift128Left(a
.high
, a
.low
, 16, &z
.high
, &z
.low
);
1169 /*----------------------------------------------------------------------------
1170 | Returns the result of converting the canonical NaN `a' to the quadruple-
1171 | precision floating-point format.
1172 *----------------------------------------------------------------------------*/
1174 static float128
commonNaNToFloat128(commonNaNT a
, float_status
*status
)
1178 if (status
->default_nan_mode
) {
1179 return float128_default_nan(status
);
1182 shift128Right(a
.high
, a
.low
, 16, &z
.high
, &z
.low
);
1183 z
.high
|= (((uint64_t)a
.sign
) << 63) | LIT64(0x7FFF000000000000);
1187 /*----------------------------------------------------------------------------
1188 | Takes two quadruple-precision floating-point values `a' and `b', one of
1189 | which is a NaN, and returns the appropriate NaN result. If either `a' or
1190 | `b' is a signaling NaN, the invalid exception is raised.
1191 *----------------------------------------------------------------------------*/
1193 static float128
propagateFloat128NaN(float128 a
, float128 b
,
1194 float_status
*status
)
1196 flag aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
;
1197 flag aIsLargerSignificand
;
1199 aIsQuietNaN
= float128_is_quiet_nan(a
, status
);
1200 aIsSignalingNaN
= float128_is_signaling_nan(a
, status
);
1201 bIsQuietNaN
= float128_is_quiet_nan(b
, status
);
1202 bIsSignalingNaN
= float128_is_signaling_nan(b
, status
);
1204 if (aIsSignalingNaN
| bIsSignalingNaN
) {
1205 float_raise(float_flag_invalid
, status
);
1208 if (status
->default_nan_mode
) {
1209 return float128_default_nan(status
);
1212 if (lt128(a
.high
<< 1, a
.low
, b
.high
<< 1, b
.low
)) {
1213 aIsLargerSignificand
= 0;
1214 } else if (lt128(b
.high
<< 1, b
.low
, a
.high
<< 1, a
.low
)) {
1215 aIsLargerSignificand
= 1;
1217 aIsLargerSignificand
= (a
.high
< b
.high
) ? 1 : 0;
1220 if (pickNaN(aIsQuietNaN
, aIsSignalingNaN
, bIsQuietNaN
, bIsSignalingNaN
,
1221 aIsLargerSignificand
)) {
1222 return float128_maybe_silence_nan(b
, status
);
1224 return float128_maybe_silence_nan(a
, status
);