2 /*============================================================================
4 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
5 Arithmetic Package, Release 2b.
7 Written by John R. Hauser. This work was made possible in part by the
8 International Computer Science Institute, located at Suite 600, 1947 Center
9 Street, Berkeley, California 94704. Funding was partially provided by the
10 National Science Foundation under grant MIP-9311980. The original version
11 of this code was written as part of a project to build a fixed-point vector
12 processor in collaboration with the University of California at Berkeley,
13 overseen by Profs. Nelson Morgan and John Wawrzynek. More information
14 is available through the Web page `http://www.cs.berkeley.edu/~jhauser/
15 arithmetic/SoftFloat.html'.
17 THIS SOFTWARE IS DISTRIBUTED AS IS, FOR FREE. Although reasonable effort has
18 been made to avoid it, THIS SOFTWARE MAY CONTAIN FAULTS THAT WILL AT TIMES
19 RESULT IN INCORRECT BEHAVIOR. USE OF THIS SOFTWARE IS RESTRICTED TO PERSONS
20 AND ORGANIZATIONS WHO CAN AND WILL TAKE FULL RESPONSIBILITY FOR ALL LOSSES,
21 COSTS, OR OTHER PROBLEMS THEY INCUR DUE TO THE SOFTWARE, AND WHO FURTHERMORE
22 EFFECTIVELY INDEMNIFY JOHN HAUSER AND THE INTERNATIONAL COMPUTER SCIENCE
23 INSTITUTE (possibly via similar legal warning) AGAINST ALL LOSSES, COSTS, OR
24 OTHER PROBLEMS INCURRED BY THEIR CUSTOMERS AND CLIENTS DUE TO THE SOFTWARE.
26 Derivative works are acceptable, even for commercial purposes, so long as
27 (1) the source code for the derivative work includes prominent notice that
28 the work is derivative, and (2) the source code includes prominent notice with
29 these four paragraphs for those parts of this code that are retained.
31 =============================================================================*/
33 #if defined(TARGET_MIPS)
34 #define SNAN_BIT_IS_ONE 1
36 #define SNAN_BIT_IS_ONE 0
39 /*----------------------------------------------------------------------------
40 | Raises the exceptions specified by `flags'. Floating-point traps can be
41 | defined here if desired. It is currently not possible for such a trap
42 | to substitute a result value. If traps are not implemented, this routine
43 | should be simply `float_exception_flags |= flags;'.
44 *----------------------------------------------------------------------------*/
46 void float_raise( int8 flags STATUS_PARAM
)
48 STATUS(float_exception_flags
) |= flags
;
51 /*----------------------------------------------------------------------------
52 | Internal canonical NaN format.
53 *----------------------------------------------------------------------------*/
59 /*----------------------------------------------------------------------------
60 | The pattern for a default generated single-precision NaN.
61 *----------------------------------------------------------------------------*/
62 #if defined(TARGET_SPARC)
63 #define float32_default_nan make_float32(0x7FFFFFFF)
64 #elif defined(TARGET_POWERPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA)
65 #define float32_default_nan make_float32(0x7FC00000)
67 #define float32_default_nan make_float32(0x7FBFFFFF)
69 #define float32_default_nan make_float32(0xFFC00000)
72 /*----------------------------------------------------------------------------
73 | Returns 1 if the single-precision floating-point value `a' is a quiet
74 | NaN; otherwise returns 0.
75 *----------------------------------------------------------------------------*/
77 int float32_is_quiet_nan( float32 a_
)
79 uint32_t a
= float32_val(a_
);
81 return ( ( ( a
>>22 ) & 0x1FF ) == 0x1FE ) && ( a
& 0x003FFFFF );
83 return ( 0xFF800000 <= (bits32
) ( a
<<1 ) );
87 /*----------------------------------------------------------------------------
88 | Returns 1 if the single-precision floating-point value `a' is a signaling
89 | NaN; otherwise returns 0.
90 *----------------------------------------------------------------------------*/
92 int float32_is_signaling_nan( float32 a_
)
94 uint32_t a
= float32_val(a_
);
96 return ( 0xFF800000 <= (bits32
) ( a
<<1 ) );
98 return ( ( ( a
>>22 ) & 0x1FF ) == 0x1FE ) && ( a
& 0x003FFFFF );
102 /*----------------------------------------------------------------------------
103 | Returns a quiet NaN if the single-precision floating point value `a' is a
104 | signaling NaN; otherwise returns `a'.
105 *----------------------------------------------------------------------------*/
107 float32
float32_maybe_silence_nan( float32 a_
)
109 if (float32_is_signaling_nan(a_
)) {
110 uint32_t a
= float32_val(a_
);
116 return make_float32(a
);
121 /*----------------------------------------------------------------------------
122 | Returns the result of converting the single-precision floating-point NaN
123 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
124 | exception is raised.
125 *----------------------------------------------------------------------------*/
127 static commonNaNT
float32ToCommonNaN( float32 a STATUS_PARAM
)
131 if ( float32_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
132 z
.sign
= float32_val(a
)>>31;
134 z
.high
= ( (bits64
) float32_val(a
) )<<41;
138 /*----------------------------------------------------------------------------
139 | Returns the result of converting the canonical NaN `a' to the single-
140 | precision floating-point format.
141 *----------------------------------------------------------------------------*/
143 static float32
commonNaNToFloat32( commonNaNT a
)
145 bits32 mantissa
= a
.high
>>41;
148 ( ( (bits32
) a
.sign
)<<31 ) | 0x7F800000 | ( a
.high
>>41 ) );
150 return float32_default_nan
;
153 /*----------------------------------------------------------------------------
154 | Select which NaN to propagate for a two-input operation.
155 | IEEE754 doesn't specify all the details of this, so the
156 | algorithm is target-specific.
157 | The routine is passed various bits of information about the
158 | two NaNs and should return 0 to select NaN a and 1 for NaN b.
159 | Note that signalling NaNs are always squashed to quiet NaNs
160 | by the caller, by flipping the SNaN bit before returning them.
162 | aIsLargerSignificand is only valid if both a and b are NaNs
163 | of some kind, and is true if a has the larger significand,
164 | or if both a and b have the same significand but a is
165 | positive but b is negative. It is only needed for the x87
167 *----------------------------------------------------------------------------*/
169 #if defined(TARGET_ARM)
170 static int pickNaN(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
171 flag aIsLargerSignificand
)
173 /* ARM mandated NaN propagation rules: take the first of:
174 * 1. A if it is signaling
175 * 2. B if it is signaling
178 * A signaling NaN is always quietened before returning it.
182 } else if (bIsSNaN
) {
184 } else if (aIsQNaN
) {
191 static int pickNaN(flag aIsQNaN
, flag aIsSNaN
, flag bIsQNaN
, flag bIsSNaN
,
192 flag aIsLargerSignificand
)
194 /* This implements x87 NaN propagation rules:
195 * SNaN + QNaN => return the QNaN
196 * two SNaNs => return the one with the larger significand, silenced
197 * two QNaNs => return the one with the larger significand
198 * SNaN and a non-NaN => return the SNaN, silenced
199 * QNaN and a non-NaN => return the QNaN
201 * If we get down to comparing significands and they are the same,
202 * return the NaN with the positive sign bit (if any).
206 return aIsLargerSignificand
? 0 : 1;
208 return bIsQNaN
? 1 : 0;
211 if (bIsSNaN
|| !bIsQNaN
)
214 return aIsLargerSignificand
? 0 : 1;
222 /*----------------------------------------------------------------------------
223 | Takes two single-precision floating-point values `a' and `b', one of which
224 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
225 | signaling NaN, the invalid exception is raised.
226 *----------------------------------------------------------------------------*/
228 static float32
propagateFloat32NaN( float32 a
, float32 b STATUS_PARAM
)
230 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
, aIsLargerSignificand
;
233 if ( STATUS(default_nan_mode
) )
234 return float32_default_nan
;
236 aIsNaN
= float32_is_quiet_nan( a
);
237 aIsSignalingNaN
= float32_is_signaling_nan( a
);
238 bIsNaN
= float32_is_quiet_nan( b
);
239 bIsSignalingNaN
= float32_is_signaling_nan( b
);
249 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
251 if ((bits32
)(av
<<1) < (bits32
)(bv
<<1)) {
252 aIsLargerSignificand
= 0;
253 } else if ((bits32
)(bv
<<1) < (bits32
)(av
<<1)) {
254 aIsLargerSignificand
= 1;
256 aIsLargerSignificand
= (av
< bv
) ? 1 : 0;
259 if (pickNaN(aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
,
260 aIsLargerSignificand
)) {
266 return make_float32(res
);
269 /*----------------------------------------------------------------------------
270 | The pattern for a default generated double-precision NaN.
271 *----------------------------------------------------------------------------*/
272 #if defined(TARGET_SPARC)
273 #define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF ))
274 #elif defined(TARGET_POWERPC) || defined(TARGET_ARM) || defined(TARGET_ALPHA)
275 #define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 ))
276 #elif SNAN_BIT_IS_ONE
277 #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF ))
279 #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 ))
282 /*----------------------------------------------------------------------------
283 | Returns 1 if the double-precision floating-point value `a' is a quiet
284 | NaN; otherwise returns 0.
285 *----------------------------------------------------------------------------*/
287 int float64_is_quiet_nan( float64 a_
)
289 bits64 a
= float64_val(a_
);
292 ( ( ( a
>>51 ) & 0xFFF ) == 0xFFE )
293 && ( a
& LIT64( 0x0007FFFFFFFFFFFF ) );
295 return ( LIT64( 0xFFF0000000000000 ) <= (bits64
) ( a
<<1 ) );
299 /*----------------------------------------------------------------------------
300 | Returns 1 if the double-precision floating-point value `a' is a signaling
301 | NaN; otherwise returns 0.
302 *----------------------------------------------------------------------------*/
304 int float64_is_signaling_nan( float64 a_
)
306 bits64 a
= float64_val(a_
);
308 return ( LIT64( 0xFFF0000000000000 ) <= (bits64
) ( a
<<1 ) );
311 ( ( ( a
>>51 ) & 0xFFF ) == 0xFFE )
312 && ( a
& LIT64( 0x0007FFFFFFFFFFFF ) );
316 /*----------------------------------------------------------------------------
317 | Returns a quiet NaN if the double-precision floating point value `a' is a
318 | signaling NaN; otherwise returns `a'.
319 *----------------------------------------------------------------------------*/
321 float64
float64_maybe_silence_nan( float64 a_
)
323 if (float64_is_signaling_nan(a_
)) {
324 bits64 a
= float64_val(a_
);
326 a
&= ~LIT64( 0x0008000000000000 );
328 a
|= LIT64( 0x0008000000000000 );
330 return make_float64(a
);
335 /*----------------------------------------------------------------------------
336 | Returns the result of converting the double-precision floating-point NaN
337 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
338 | exception is raised.
339 *----------------------------------------------------------------------------*/
341 static commonNaNT
float64ToCommonNaN( float64 a STATUS_PARAM
)
345 if ( float64_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
346 z
.sign
= float64_val(a
)>>63;
348 z
.high
= float64_val(a
)<<12;
352 /*----------------------------------------------------------------------------
353 | Returns the result of converting the canonical NaN `a' to the double-
354 | precision floating-point format.
355 *----------------------------------------------------------------------------*/
357 static float64
commonNaNToFloat64( commonNaNT a
)
359 bits64 mantissa
= a
.high
>>12;
363 ( ( (bits64
) a
.sign
)<<63 )
364 | LIT64( 0x7FF0000000000000 )
367 return float64_default_nan
;
370 /*----------------------------------------------------------------------------
371 | Takes two double-precision floating-point values `a' and `b', one of which
372 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
373 | signaling NaN, the invalid exception is raised.
374 *----------------------------------------------------------------------------*/
376 static float64
propagateFloat64NaN( float64 a
, float64 b STATUS_PARAM
)
378 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
, aIsLargerSignificand
;
381 if ( STATUS(default_nan_mode
) )
382 return float64_default_nan
;
384 aIsNaN
= float64_is_quiet_nan( a
);
385 aIsSignalingNaN
= float64_is_signaling_nan( a
);
386 bIsNaN
= float64_is_quiet_nan( b
);
387 bIsSignalingNaN
= float64_is_signaling_nan( b
);
391 av
&= ~LIT64( 0x0008000000000000 );
392 bv
&= ~LIT64( 0x0008000000000000 );
394 av
|= LIT64( 0x0008000000000000 );
395 bv
|= LIT64( 0x0008000000000000 );
397 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
399 if ((bits64
)(av
<<1) < (bits64
)(bv
<<1)) {
400 aIsLargerSignificand
= 0;
401 } else if ((bits64
)(bv
<<1) < (bits64
)(av
<<1)) {
402 aIsLargerSignificand
= 1;
404 aIsLargerSignificand
= (av
< bv
) ? 1 : 0;
407 if (pickNaN(aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
,
408 aIsLargerSignificand
)) {
414 return make_float64(res
);
419 /*----------------------------------------------------------------------------
420 | The pattern for a default generated extended double-precision NaN. The
421 | `high' and `low' values hold the most- and least-significant bits,
423 *----------------------------------------------------------------------------*/
425 #define floatx80_default_nan_high 0x7FFF
426 #define floatx80_default_nan_low LIT64( 0xBFFFFFFFFFFFFFFF )
428 #define floatx80_default_nan_high 0xFFFF
429 #define floatx80_default_nan_low LIT64( 0xC000000000000000 )
432 /*----------------------------------------------------------------------------
433 | Returns 1 if the extended double-precision floating-point value `a' is a
434 | quiet NaN; otherwise returns 0.
435 *----------------------------------------------------------------------------*/
437 int floatx80_is_quiet_nan( floatx80 a
)
442 aLow
= a
.low
& ~ LIT64( 0x4000000000000000 );
444 ( ( a
.high
& 0x7FFF ) == 0x7FFF )
445 && (bits64
) ( aLow
<<1 )
446 && ( a
.low
== aLow
);
448 return ( ( a
.high
& 0x7FFF ) == 0x7FFF ) && (bits64
) ( a
.low
<<1 );
452 /*----------------------------------------------------------------------------
453 | Returns 1 if the extended double-precision floating-point value `a' is a
454 | signaling NaN; otherwise returns 0.
455 *----------------------------------------------------------------------------*/
457 int floatx80_is_signaling_nan( floatx80 a
)
460 return ( ( a
.high
& 0x7FFF ) == 0x7FFF ) && (bits64
) ( a
.low
<<1 );
464 aLow
= a
.low
& ~ LIT64( 0x4000000000000000 );
466 ( ( a
.high
& 0x7FFF ) == 0x7FFF )
467 && (bits64
) ( aLow
<<1 )
468 && ( a
.low
== aLow
);
472 /*----------------------------------------------------------------------------
473 | Returns the result of converting the extended double-precision floating-
474 | point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
475 | invalid exception is raised.
476 *----------------------------------------------------------------------------*/
478 static commonNaNT
floatx80ToCommonNaN( floatx80 a STATUS_PARAM
)
482 if ( floatx80_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
489 /*----------------------------------------------------------------------------
490 | Returns the result of converting the canonical NaN `a' to the extended
491 | double-precision floating-point format.
492 *----------------------------------------------------------------------------*/
494 static floatx80
commonNaNToFloatx80( commonNaNT a
)
501 z
.low
= floatx80_default_nan_low
;
502 z
.high
= ( ( (bits16
) a
.sign
)<<15 ) | 0x7FFF;
506 /*----------------------------------------------------------------------------
507 | Takes two extended double-precision floating-point values `a' and `b', one
508 | of which is a NaN, and returns the appropriate NaN result. If either `a' or
509 | `b' is a signaling NaN, the invalid exception is raised.
510 *----------------------------------------------------------------------------*/
512 static floatx80
propagateFloatx80NaN( floatx80 a
, floatx80 b STATUS_PARAM
)
514 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
, aIsLargerSignificand
;
516 if ( STATUS(default_nan_mode
) ) {
517 a
.low
= floatx80_default_nan_low
;
518 a
.high
= floatx80_default_nan_high
;
522 aIsNaN
= floatx80_is_quiet_nan( a
);
523 aIsSignalingNaN
= floatx80_is_signaling_nan( a
);
524 bIsNaN
= floatx80_is_quiet_nan( b
);
525 bIsSignalingNaN
= floatx80_is_signaling_nan( b
);
527 a
.low
&= ~LIT64( 0xC000000000000000 );
528 b
.low
&= ~LIT64( 0xC000000000000000 );
530 a
.low
|= LIT64( 0xC000000000000000 );
531 b
.low
|= LIT64( 0xC000000000000000 );
533 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
536 aIsLargerSignificand
= 0;
537 } else if (b
.low
< a
.low
) {
538 aIsLargerSignificand
= 1;
540 aIsLargerSignificand
= (a
.high
< b
.high
) ? 1 : 0;
543 if (pickNaN(aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
,
544 aIsLargerSignificand
)) {
555 /*----------------------------------------------------------------------------
556 | The pattern for a default generated quadruple-precision NaN. The `high' and
557 | `low' values hold the most- and least-significant bits, respectively.
558 *----------------------------------------------------------------------------*/
560 #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF )
561 #define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
563 #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
564 #define float128_default_nan_low LIT64( 0x0000000000000000 )
567 /*----------------------------------------------------------------------------
568 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
569 | NaN; otherwise returns 0.
570 *----------------------------------------------------------------------------*/
572 int float128_is_quiet_nan( float128 a
)
576 ( ( ( a
.high
>>47 ) & 0xFFFF ) == 0xFFFE )
577 && ( a
.low
|| ( a
.high
& LIT64( 0x00007FFFFFFFFFFF ) ) );
580 ( LIT64( 0xFFFE000000000000 ) <= (bits64
) ( a
.high
<<1 ) )
581 && ( a
.low
|| ( a
.high
& LIT64( 0x0000FFFFFFFFFFFF ) ) );
585 /*----------------------------------------------------------------------------
586 | Returns 1 if the quadruple-precision floating-point value `a' is a
587 | signaling NaN; otherwise returns 0.
588 *----------------------------------------------------------------------------*/
590 int float128_is_signaling_nan( float128 a
)
594 ( LIT64( 0xFFFE000000000000 ) <= (bits64
) ( a
.high
<<1 ) )
595 && ( a
.low
|| ( a
.high
& LIT64( 0x0000FFFFFFFFFFFF ) ) );
598 ( ( ( a
.high
>>47 ) & 0xFFFF ) == 0xFFFE )
599 && ( a
.low
|| ( a
.high
& LIT64( 0x00007FFFFFFFFFFF ) ) );
603 /*----------------------------------------------------------------------------
604 | Returns the result of converting the quadruple-precision floating-point NaN
605 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
606 | exception is raised.
607 *----------------------------------------------------------------------------*/
609 static commonNaNT
float128ToCommonNaN( float128 a STATUS_PARAM
)
613 if ( float128_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
615 shortShift128Left( a
.high
, a
.low
, 16, &z
.high
, &z
.low
);
619 /*----------------------------------------------------------------------------
620 | Returns the result of converting the canonical NaN `a' to the quadruple-
621 | precision floating-point format.
622 *----------------------------------------------------------------------------*/
624 static float128
commonNaNToFloat128( commonNaNT a
)
628 shift128Right( a
.high
, a
.low
, 16, &z
.high
, &z
.low
);
629 z
.high
|= ( ( (bits64
) a
.sign
)<<63 ) | LIT64( 0x7FFF000000000000 );
633 /*----------------------------------------------------------------------------
634 | Takes two quadruple-precision floating-point values `a' and `b', one of
635 | which is a NaN, and returns the appropriate NaN result. If either `a' or
636 | `b' is a signaling NaN, the invalid exception is raised.
637 *----------------------------------------------------------------------------*/
639 static float128
propagateFloat128NaN( float128 a
, float128 b STATUS_PARAM
)
641 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
, aIsLargerSignificand
;
643 if ( STATUS(default_nan_mode
) ) {
644 a
.low
= float128_default_nan_low
;
645 a
.high
= float128_default_nan_high
;
649 aIsNaN
= float128_is_quiet_nan( a
);
650 aIsSignalingNaN
= float128_is_signaling_nan( a
);
651 bIsNaN
= float128_is_quiet_nan( b
);
652 bIsSignalingNaN
= float128_is_signaling_nan( b
);
654 a
.high
&= ~LIT64( 0x0000800000000000 );
655 b
.high
&= ~LIT64( 0x0000800000000000 );
657 a
.high
|= LIT64( 0x0000800000000000 );
658 b
.high
|= LIT64( 0x0000800000000000 );
660 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
662 if (lt128(a
.high
<<1, a
.low
, b
.high
<<1, b
.low
)) {
663 aIsLargerSignificand
= 0;
664 } else if (lt128(b
.high
<<1, b
.low
, a
.high
<<1, a
.low
)) {
665 aIsLargerSignificand
= 1;
667 aIsLargerSignificand
= (a
.high
< b
.high
) ? 1 : 0;
670 if (pickNaN(aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
,
671 aIsLargerSignificand
)) {