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) || defined(TARGET_HPPA)
34 #define SNAN_BIT_IS_ONE 1
36 #define SNAN_BIT_IS_ONE 0
39 /*----------------------------------------------------------------------------
40 | Underflow tininess-detection mode, statically initialized to default value.
41 | (The declaration in `softfloat.h' must match the `int8' type here.)
42 *----------------------------------------------------------------------------*/
43 int8 float_detect_tininess
= float_tininess_after_rounding
;
45 /*----------------------------------------------------------------------------
46 | Raises the exceptions specified by `flags'. Floating-point traps can be
47 | defined here if desired. It is currently not possible for such a trap
48 | to substitute a result value. If traps are not implemented, this routine
49 | should be simply `float_exception_flags |= flags;'.
50 *----------------------------------------------------------------------------*/
52 void float_raise( int8 flags STATUS_PARAM
)
54 STATUS(float_exception_flags
) |= flags
;
57 /*----------------------------------------------------------------------------
58 | Internal canonical NaN format.
59 *----------------------------------------------------------------------------*/
65 /*----------------------------------------------------------------------------
66 | The pattern for a default generated single-precision NaN.
67 *----------------------------------------------------------------------------*/
69 #define float32_default_nan make_float32(0x7FBFFFFF)
71 #define float32_default_nan make_float32(0xFFC00000)
74 /*----------------------------------------------------------------------------
75 | Returns 1 if the single-precision floating-point value `a' is a quiet
76 | NaN; otherwise returns 0.
77 *----------------------------------------------------------------------------*/
79 int float32_is_nan( float32 a_
)
81 uint32_t a
= float32_val(a_
);
83 return ( ( ( a
>>22 ) & 0x1FF ) == 0x1FE ) && ( a
& 0x003FFFFF );
85 return ( 0xFF800000 <= (bits32
) ( a
<<1 ) );
89 /*----------------------------------------------------------------------------
90 | Returns 1 if the single-precision floating-point value `a' is a signaling
91 | NaN; otherwise returns 0.
92 *----------------------------------------------------------------------------*/
94 int float32_is_signaling_nan( float32 a_
)
96 uint32_t a
= float32_val(a_
);
98 return ( 0xFF800000 <= (bits32
) ( a
<<1 ) );
100 return ( ( ( a
>>22 ) & 0x1FF ) == 0x1FE ) && ( a
& 0x003FFFFF );
104 /*----------------------------------------------------------------------------
105 | Returns the result of converting the single-precision floating-point NaN
106 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
107 | exception is raised.
108 *----------------------------------------------------------------------------*/
110 static commonNaNT
float32ToCommonNaN( float32 a STATUS_PARAM
)
114 if ( float32_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
115 z
.sign
= float32_val(a
)>>31;
117 z
.high
= ( (bits64
) float32_val(a
) )<<41;
121 /*----------------------------------------------------------------------------
122 | Returns the result of converting the canonical NaN `a' to the single-
123 | precision floating-point format.
124 *----------------------------------------------------------------------------*/
126 static float32
commonNaNToFloat32( commonNaNT a
)
129 ( ( (bits32
) a
.sign
)<<31 ) | 0x7FC00000 | ( a
.high
>>41 ) );
132 /*----------------------------------------------------------------------------
133 | Takes two single-precision floating-point values `a' and `b', one of which
134 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
135 | signaling NaN, the invalid exception is raised.
136 *----------------------------------------------------------------------------*/
138 static float32
propagateFloat32NaN( float32 a
, float32 b STATUS_PARAM
)
140 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
;
143 aIsNaN
= float32_is_nan( a
);
144 aIsSignalingNaN
= float32_is_signaling_nan( a
);
145 bIsNaN
= float32_is_nan( b
);
146 bIsSignalingNaN
= float32_is_signaling_nan( b
);
156 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
157 if ( aIsSignalingNaN
) {
158 if ( bIsSignalingNaN
) goto returnLargerSignificand
;
159 res
= bIsNaN
? bv
: av
;
162 if ( bIsSignalingNaN
| ! bIsNaN
)
165 returnLargerSignificand
:
166 if ( (bits32
) ( av
<<1 ) < (bits32
) ( bv
<<1 ) )
168 else if ( (bits32
) ( bv
<<1 ) < (bits32
) ( av
<<1 ) )
171 res
= ( av
< bv
) ? av
: bv
;
177 return make_float32(res
);
180 /*----------------------------------------------------------------------------
181 | The pattern for a default generated double-precision NaN.
182 *----------------------------------------------------------------------------*/
184 #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF ))
186 #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 ))
189 /*----------------------------------------------------------------------------
190 | Returns 1 if the double-precision floating-point value `a' is a quiet
191 | NaN; otherwise returns 0.
192 *----------------------------------------------------------------------------*/
194 int float64_is_nan( float64 a_
)
196 bits64 a
= float64_val(a_
);
199 ( ( ( a
>>51 ) & 0xFFF ) == 0xFFE )
200 && ( a
& LIT64( 0x0007FFFFFFFFFFFF ) );
202 return ( LIT64( 0xFFF0000000000000 ) <= (bits64
) ( a
<<1 ) );
206 /*----------------------------------------------------------------------------
207 | Returns 1 if the double-precision floating-point value `a' is a signaling
208 | NaN; otherwise returns 0.
209 *----------------------------------------------------------------------------*/
211 int float64_is_signaling_nan( float64 a_
)
213 bits64 a
= float64_val(a_
);
215 return ( LIT64( 0xFFF0000000000000 ) <= (bits64
) ( a
<<1 ) );
218 ( ( ( a
>>51 ) & 0xFFF ) == 0xFFE )
219 && ( a
& LIT64( 0x0007FFFFFFFFFFFF ) );
223 /*----------------------------------------------------------------------------
224 | Returns the result of converting the double-precision floating-point NaN
225 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
226 | exception is raised.
227 *----------------------------------------------------------------------------*/
229 static commonNaNT
float64ToCommonNaN( float64 a STATUS_PARAM
)
233 if ( float64_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
234 z
.sign
= float64_val(a
)>>63;
236 z
.high
= float64_val(a
)<<12;
240 /*----------------------------------------------------------------------------
241 | Returns the result of converting the canonical NaN `a' to the double-
242 | precision floating-point format.
243 *----------------------------------------------------------------------------*/
245 static float64
commonNaNToFloat64( commonNaNT a
)
248 ( ( (bits64
) a
.sign
)<<63 )
249 | LIT64( 0x7FF8000000000000 )
253 /*----------------------------------------------------------------------------
254 | Takes two double-precision floating-point values `a' and `b', one of which
255 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
256 | signaling NaN, the invalid exception is raised.
257 *----------------------------------------------------------------------------*/
259 static float64
propagateFloat64NaN( float64 a
, float64 b STATUS_PARAM
)
261 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
;
264 aIsNaN
= float64_is_nan( a
);
265 aIsSignalingNaN
= float64_is_signaling_nan( a
);
266 bIsNaN
= float64_is_nan( b
);
267 bIsSignalingNaN
= float64_is_signaling_nan( b
);
271 av
&= ~LIT64( 0x0008000000000000 );
272 bv
&= ~LIT64( 0x0008000000000000 );
274 av
|= LIT64( 0x0008000000000000 );
275 bv
|= LIT64( 0x0008000000000000 );
277 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
278 if ( aIsSignalingNaN
) {
279 if ( bIsSignalingNaN
) goto returnLargerSignificand
;
280 res
= bIsNaN
? bv
: av
;
283 if ( bIsSignalingNaN
| ! bIsNaN
)
286 returnLargerSignificand
:
287 if ( (bits64
) ( av
<<1 ) < (bits64
) ( bv
<<1 ) )
289 else if ( (bits64
) ( bv
<<1 ) < (bits64
) ( av
<<1 ) )
292 res
= ( av
< bv
) ? av
: bv
;
298 return make_float64(res
);
303 /*----------------------------------------------------------------------------
304 | The pattern for a default generated extended double-precision NaN. The
305 | `high' and `low' values hold the most- and least-significant bits,
307 *----------------------------------------------------------------------------*/
309 #define floatx80_default_nan_high 0x7FFF
310 #define floatx80_default_nan_low LIT64( 0xBFFFFFFFFFFFFFFF )
312 #define floatx80_default_nan_high 0xFFFF
313 #define floatx80_default_nan_low LIT64( 0xC000000000000000 )
316 /*----------------------------------------------------------------------------
317 | Returns 1 if the extended double-precision floating-point value `a' is a
318 | quiet NaN; otherwise returns 0.
319 *----------------------------------------------------------------------------*/
321 int floatx80_is_nan( floatx80 a
)
326 aLow
= a
.low
& ~ LIT64( 0x4000000000000000 );
328 ( ( a
.high
& 0x7FFF ) == 0x7FFF )
329 && (bits64
) ( aLow
<<1 )
330 && ( a
.low
== aLow
);
332 return ( ( a
.high
& 0x7FFF ) == 0x7FFF ) && (bits64
) ( a
.low
<<1 );
336 /*----------------------------------------------------------------------------
337 | Returns 1 if the extended double-precision floating-point value `a' is a
338 | signaling NaN; otherwise returns 0.
339 *----------------------------------------------------------------------------*/
341 int floatx80_is_signaling_nan( floatx80 a
)
344 return ( ( a
.high
& 0x7FFF ) == 0x7FFF ) && (bits64
) ( a
.low
<<1 );
348 aLow
= a
.low
& ~ LIT64( 0x4000000000000000 );
350 ( ( a
.high
& 0x7FFF ) == 0x7FFF )
351 && (bits64
) ( aLow
<<1 )
352 && ( a
.low
== aLow
);
356 /*----------------------------------------------------------------------------
357 | Returns the result of converting the extended double-precision floating-
358 | point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
359 | invalid exception is raised.
360 *----------------------------------------------------------------------------*/
362 static commonNaNT
floatx80ToCommonNaN( floatx80 a STATUS_PARAM
)
366 if ( floatx80_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
373 /*----------------------------------------------------------------------------
374 | Returns the result of converting the canonical NaN `a' to the extended
375 | double-precision floating-point format.
376 *----------------------------------------------------------------------------*/
378 static floatx80
commonNaNToFloatx80( commonNaNT a
)
382 z
.low
= LIT64( 0xC000000000000000 ) | ( a
.high
>>1 );
383 z
.high
= ( ( (bits16
) a
.sign
)<<15 ) | 0x7FFF;
387 /*----------------------------------------------------------------------------
388 | Takes two extended double-precision floating-point values `a' and `b', one
389 | of which is a NaN, and returns the appropriate NaN result. If either `a' or
390 | `b' is a signaling NaN, the invalid exception is raised.
391 *----------------------------------------------------------------------------*/
393 static floatx80
propagateFloatx80NaN( floatx80 a
, floatx80 b STATUS_PARAM
)
395 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
;
397 aIsNaN
= floatx80_is_nan( a
);
398 aIsSignalingNaN
= floatx80_is_signaling_nan( a
);
399 bIsNaN
= floatx80_is_nan( b
);
400 bIsSignalingNaN
= floatx80_is_signaling_nan( b
);
402 a
.low
&= ~LIT64( 0xC000000000000000 );
403 b
.low
&= ~LIT64( 0xC000000000000000 );
405 a
.low
|= LIT64( 0xC000000000000000 );
406 b
.low
|= LIT64( 0xC000000000000000 );
408 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
409 if ( aIsSignalingNaN
) {
410 if ( bIsSignalingNaN
) goto returnLargerSignificand
;
411 return bIsNaN
? b
: a
;
414 if ( bIsSignalingNaN
| ! bIsNaN
) return a
;
415 returnLargerSignificand
:
416 if ( a
.low
< b
.low
) return b
;
417 if ( b
.low
< a
.low
) return a
;
418 return ( a
.high
< b
.high
) ? a
: b
;
429 /*----------------------------------------------------------------------------
430 | The pattern for a default generated quadruple-precision NaN. The `high' and
431 | `low' values hold the most- and least-significant bits, respectively.
432 *----------------------------------------------------------------------------*/
434 #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF )
435 #define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF )
437 #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
438 #define float128_default_nan_low LIT64( 0x0000000000000000 )
441 /*----------------------------------------------------------------------------
442 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
443 | NaN; otherwise returns 0.
444 *----------------------------------------------------------------------------*/
446 int float128_is_nan( float128 a
)
450 ( ( ( a
.high
>>47 ) & 0xFFFF ) == 0xFFFE )
451 && ( a
.low
|| ( a
.high
& LIT64( 0x00007FFFFFFFFFFF ) ) );
454 ( LIT64( 0xFFFE000000000000 ) <= (bits64
) ( a
.high
<<1 ) )
455 && ( a
.low
|| ( a
.high
& LIT64( 0x0000FFFFFFFFFFFF ) ) );
459 /*----------------------------------------------------------------------------
460 | Returns 1 if the quadruple-precision floating-point value `a' is a
461 | signaling NaN; otherwise returns 0.
462 *----------------------------------------------------------------------------*/
464 int float128_is_signaling_nan( float128 a
)
468 ( LIT64( 0xFFFE000000000000 ) <= (bits64
) ( a
.high
<<1 ) )
469 && ( a
.low
|| ( a
.high
& LIT64( 0x0000FFFFFFFFFFFF ) ) );
472 ( ( ( a
.high
>>47 ) & 0xFFFF ) == 0xFFFE )
473 && ( a
.low
|| ( a
.high
& LIT64( 0x00007FFFFFFFFFFF ) ) );
477 /*----------------------------------------------------------------------------
478 | Returns the result of converting the quadruple-precision floating-point NaN
479 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
480 | exception is raised.
481 *----------------------------------------------------------------------------*/
483 static commonNaNT
float128ToCommonNaN( float128 a STATUS_PARAM
)
487 if ( float128_is_signaling_nan( a
) ) float_raise( float_flag_invalid STATUS_VAR
);
489 shortShift128Left( a
.high
, a
.low
, 16, &z
.high
, &z
.low
);
493 /*----------------------------------------------------------------------------
494 | Returns the result of converting the canonical NaN `a' to the quadruple-
495 | precision floating-point format.
496 *----------------------------------------------------------------------------*/
498 static float128
commonNaNToFloat128( commonNaNT a
)
502 shift128Right( a
.high
, a
.low
, 16, &z
.high
, &z
.low
);
503 z
.high
|= ( ( (bits64
) a
.sign
)<<63 ) | LIT64( 0x7FFF800000000000 );
507 /*----------------------------------------------------------------------------
508 | Takes two quadruple-precision floating-point values `a' and `b', one of
509 | which is a NaN, and returns the appropriate NaN result. If either `a' or
510 | `b' is a signaling NaN, the invalid exception is raised.
511 *----------------------------------------------------------------------------*/
513 static float128
propagateFloat128NaN( float128 a
, float128 b STATUS_PARAM
)
515 flag aIsNaN
, aIsSignalingNaN
, bIsNaN
, bIsSignalingNaN
;
517 aIsNaN
= float128_is_nan( a
);
518 aIsSignalingNaN
= float128_is_signaling_nan( a
);
519 bIsNaN
= float128_is_nan( b
);
520 bIsSignalingNaN
= float128_is_signaling_nan( b
);
522 a
.high
&= ~LIT64( 0x0000800000000000 );
523 b
.high
&= ~LIT64( 0x0000800000000000 );
525 a
.high
|= LIT64( 0x0000800000000000 );
526 b
.high
|= LIT64( 0x0000800000000000 );
528 if ( aIsSignalingNaN
| bIsSignalingNaN
) float_raise( float_flag_invalid STATUS_VAR
);
529 if ( aIsSignalingNaN
) {
530 if ( bIsSignalingNaN
) goto returnLargerSignificand
;
531 return bIsNaN
? b
: a
;
534 if ( bIsSignalingNaN
| ! bIsNaN
) return a
;
535 returnLargerSignificand
:
536 if ( lt128( a
.high
<<1, a
.low
, b
.high
<<1, b
.low
) ) return b
;
537 if ( lt128( b
.high
<<1, b
.low
, a
.high
<<1, a
.low
) ) return a
;
538 return ( a
.high
< b
.high
) ? a
: b
;