|
1 |
|
2 /*============================================================================ |
|
3 |
|
4 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point |
|
5 Arithmetic Package, Release 2b. |
|
6 |
|
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'. |
|
16 |
|
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. |
|
25 |
|
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. |
|
30 |
|
31 =============================================================================*/ |
|
32 |
|
33 #if defined(TARGET_MIPS) || defined(TARGET_HPPA) |
|
34 #define SNAN_BIT_IS_ONE 1 |
|
35 #else |
|
36 #define SNAN_BIT_IS_ONE 0 |
|
37 #endif |
|
38 |
|
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 *----------------------------------------------------------------------------*/ |
|
45 |
|
46 void float_raise( int8 flags STATUS_PARAM ) |
|
47 { |
|
48 STATUS(float_exception_flags) |= flags; |
|
49 } |
|
50 |
|
51 /*---------------------------------------------------------------------------- |
|
52 | Internal canonical NaN format. |
|
53 *----------------------------------------------------------------------------*/ |
|
54 typedef struct { |
|
55 flag sign; |
|
56 bits64 high, low; |
|
57 } commonNaNT; |
|
58 |
|
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) |
|
65 #define float32_default_nan make_float32(0x7FC00000) |
|
66 #elif defined(TARGET_HPPA) |
|
67 #define float32_default_nan make_float32(0x7FA00000) |
|
68 #elif SNAN_BIT_IS_ONE |
|
69 #define float32_default_nan make_float32(0x7FBFFFFF) |
|
70 #else |
|
71 #define float32_default_nan make_float32(0xFFC00000) |
|
72 #endif |
|
73 |
|
74 /*---------------------------------------------------------------------------- |
|
75 | Returns 1 if the single-precision floating-point value `a' is a quiet |
|
76 | NaN; otherwise returns 0. |
|
77 *----------------------------------------------------------------------------*/ |
|
78 |
|
79 int float32_is_nan( float32 a_ ) |
|
80 { |
|
81 uint32_t a = float32_val(a_); |
|
82 #if SNAN_BIT_IS_ONE |
|
83 return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); |
|
84 #else |
|
85 return ( 0xFF800000 <= (bits32) ( a<<1 ) ); |
|
86 #endif |
|
87 } |
|
88 |
|
89 /*---------------------------------------------------------------------------- |
|
90 | Returns 1 if the single-precision floating-point value `a' is a signaling |
|
91 | NaN; otherwise returns 0. |
|
92 *----------------------------------------------------------------------------*/ |
|
93 |
|
94 int float32_is_signaling_nan( float32 a_ ) |
|
95 { |
|
96 uint32_t a = float32_val(a_); |
|
97 #if SNAN_BIT_IS_ONE |
|
98 return ( 0xFF800000 <= (bits32) ( a<<1 ) ); |
|
99 #else |
|
100 return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF ); |
|
101 #endif |
|
102 } |
|
103 |
|
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 *----------------------------------------------------------------------------*/ |
|
109 |
|
110 static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM ) |
|
111 { |
|
112 commonNaNT z; |
|
113 |
|
114 if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR ); |
|
115 z.sign = float32_val(a)>>31; |
|
116 z.low = 0; |
|
117 z.high = ( (bits64) float32_val(a) )<<41; |
|
118 return z; |
|
119 } |
|
120 |
|
121 /*---------------------------------------------------------------------------- |
|
122 | Returns the result of converting the canonical NaN `a' to the single- |
|
123 | precision floating-point format. |
|
124 *----------------------------------------------------------------------------*/ |
|
125 |
|
126 static float32 commonNaNToFloat32( commonNaNT a ) |
|
127 { |
|
128 bits32 mantissa = a.high>>41; |
|
129 if ( mantissa ) |
|
130 return make_float32( |
|
131 ( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) ); |
|
132 else |
|
133 return float32_default_nan; |
|
134 } |
|
135 |
|
136 /*---------------------------------------------------------------------------- |
|
137 | Takes two single-precision floating-point values `a' and `b', one of which |
|
138 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a |
|
139 | signaling NaN, the invalid exception is raised. |
|
140 *----------------------------------------------------------------------------*/ |
|
141 |
|
142 static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM) |
|
143 { |
|
144 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; |
|
145 bits32 av, bv, res; |
|
146 |
|
147 if ( STATUS(default_nan_mode) ) |
|
148 return float32_default_nan; |
|
149 |
|
150 aIsNaN = float32_is_nan( a ); |
|
151 aIsSignalingNaN = float32_is_signaling_nan( a ); |
|
152 bIsNaN = float32_is_nan( b ); |
|
153 bIsSignalingNaN = float32_is_signaling_nan( b ); |
|
154 av = float32_val(a); |
|
155 bv = float32_val(b); |
|
156 #if SNAN_BIT_IS_ONE |
|
157 av &= ~0x00400000; |
|
158 bv &= ~0x00400000; |
|
159 #else |
|
160 av |= 0x00400000; |
|
161 bv |= 0x00400000; |
|
162 #endif |
|
163 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); |
|
164 if ( aIsSignalingNaN ) { |
|
165 if ( bIsSignalingNaN ) goto returnLargerSignificand; |
|
166 res = bIsNaN ? bv : av; |
|
167 } |
|
168 else if ( aIsNaN ) { |
|
169 if ( bIsSignalingNaN | ! bIsNaN ) |
|
170 res = av; |
|
171 else { |
|
172 returnLargerSignificand: |
|
173 if ( (bits32) ( av<<1 ) < (bits32) ( bv<<1 ) ) |
|
174 res = bv; |
|
175 else if ( (bits32) ( bv<<1 ) < (bits32) ( av<<1 ) ) |
|
176 res = av; |
|
177 else |
|
178 res = ( av < bv ) ? av : bv; |
|
179 } |
|
180 } |
|
181 else { |
|
182 res = bv; |
|
183 } |
|
184 return make_float32(res); |
|
185 } |
|
186 |
|
187 /*---------------------------------------------------------------------------- |
|
188 | The pattern for a default generated double-precision NaN. |
|
189 *----------------------------------------------------------------------------*/ |
|
190 #if defined(TARGET_SPARC) |
|
191 #define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF )) |
|
192 #elif defined(TARGET_POWERPC) || defined(TARGET_ARM) |
|
193 #define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 )) |
|
194 #elif defined(TARGET_HPPA) |
|
195 #define float64_default_nan make_float64(LIT64( 0x7FF4000000000000 )) |
|
196 #elif SNAN_BIT_IS_ONE |
|
197 #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF )) |
|
198 #else |
|
199 #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 )) |
|
200 #endif |
|
201 |
|
202 /*---------------------------------------------------------------------------- |
|
203 | Returns 1 if the double-precision floating-point value `a' is a quiet |
|
204 | NaN; otherwise returns 0. |
|
205 *----------------------------------------------------------------------------*/ |
|
206 |
|
207 int float64_is_nan( float64 a_ ) |
|
208 { |
|
209 bits64 a = float64_val(a_); |
|
210 #if SNAN_BIT_IS_ONE |
|
211 return |
|
212 ( ( ( a>>51 ) & 0xFFF ) == 0xFFE ) |
|
213 && ( a & LIT64( 0x0007FFFFFFFFFFFF ) ); |
|
214 #else |
|
215 return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) ); |
|
216 #endif |
|
217 } |
|
218 |
|
219 /*---------------------------------------------------------------------------- |
|
220 | Returns 1 if the double-precision floating-point value `a' is a signaling |
|
221 | NaN; otherwise returns 0. |
|
222 *----------------------------------------------------------------------------*/ |
|
223 |
|
224 int float64_is_signaling_nan( float64 a_ ) |
|
225 { |
|
226 bits64 a = float64_val(a_); |
|
227 #if SNAN_BIT_IS_ONE |
|
228 return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) ); |
|
229 #else |
|
230 return |
|
231 ( ( ( a>>51 ) & 0xFFF ) == 0xFFE ) |
|
232 && ( a & LIT64( 0x0007FFFFFFFFFFFF ) ); |
|
233 #endif |
|
234 } |
|
235 |
|
236 /*---------------------------------------------------------------------------- |
|
237 | Returns the result of converting the double-precision floating-point NaN |
|
238 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid |
|
239 | exception is raised. |
|
240 *----------------------------------------------------------------------------*/ |
|
241 |
|
242 static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM) |
|
243 { |
|
244 commonNaNT z; |
|
245 |
|
246 if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR); |
|
247 z.sign = float64_val(a)>>63; |
|
248 z.low = 0; |
|
249 z.high = float64_val(a)<<12; |
|
250 return z; |
|
251 } |
|
252 |
|
253 /*---------------------------------------------------------------------------- |
|
254 | Returns the result of converting the canonical NaN `a' to the double- |
|
255 | precision floating-point format. |
|
256 *----------------------------------------------------------------------------*/ |
|
257 |
|
258 static float64 commonNaNToFloat64( commonNaNT a ) |
|
259 { |
|
260 bits64 mantissa = a.high>>12; |
|
261 |
|
262 if ( mantissa ) |
|
263 return make_float64( |
|
264 ( ( (bits64) a.sign )<<63 ) |
|
265 | LIT64( 0x7FF0000000000000 ) |
|
266 | ( a.high>>12 )); |
|
267 else |
|
268 return float64_default_nan; |
|
269 } |
|
270 |
|
271 /*---------------------------------------------------------------------------- |
|
272 | Takes two double-precision floating-point values `a' and `b', one of which |
|
273 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a |
|
274 | signaling NaN, the invalid exception is raised. |
|
275 *----------------------------------------------------------------------------*/ |
|
276 |
|
277 static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM) |
|
278 { |
|
279 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; |
|
280 bits64 av, bv, res; |
|
281 |
|
282 if ( STATUS(default_nan_mode) ) |
|
283 return float64_default_nan; |
|
284 |
|
285 aIsNaN = float64_is_nan( a ); |
|
286 aIsSignalingNaN = float64_is_signaling_nan( a ); |
|
287 bIsNaN = float64_is_nan( b ); |
|
288 bIsSignalingNaN = float64_is_signaling_nan( b ); |
|
289 av = float64_val(a); |
|
290 bv = float64_val(b); |
|
291 #if SNAN_BIT_IS_ONE |
|
292 av &= ~LIT64( 0x0008000000000000 ); |
|
293 bv &= ~LIT64( 0x0008000000000000 ); |
|
294 #else |
|
295 av |= LIT64( 0x0008000000000000 ); |
|
296 bv |= LIT64( 0x0008000000000000 ); |
|
297 #endif |
|
298 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); |
|
299 if ( aIsSignalingNaN ) { |
|
300 if ( bIsSignalingNaN ) goto returnLargerSignificand; |
|
301 res = bIsNaN ? bv : av; |
|
302 } |
|
303 else if ( aIsNaN ) { |
|
304 if ( bIsSignalingNaN | ! bIsNaN ) |
|
305 res = av; |
|
306 else { |
|
307 returnLargerSignificand: |
|
308 if ( (bits64) ( av<<1 ) < (bits64) ( bv<<1 ) ) |
|
309 res = bv; |
|
310 else if ( (bits64) ( bv<<1 ) < (bits64) ( av<<1 ) ) |
|
311 res = av; |
|
312 else |
|
313 res = ( av < bv ) ? av : bv; |
|
314 } |
|
315 } |
|
316 else { |
|
317 res = bv; |
|
318 } |
|
319 return make_float64(res); |
|
320 } |
|
321 |
|
322 #ifdef FLOATX80 |
|
323 |
|
324 /*---------------------------------------------------------------------------- |
|
325 | The pattern for a default generated extended double-precision NaN. The |
|
326 | `high' and `low' values hold the most- and least-significant bits, |
|
327 | respectively. |
|
328 *----------------------------------------------------------------------------*/ |
|
329 #if SNAN_BIT_IS_ONE |
|
330 #define floatx80_default_nan_high 0x7FFF |
|
331 #define floatx80_default_nan_low LIT64( 0xBFFFFFFFFFFFFFFF ) |
|
332 #else |
|
333 #define floatx80_default_nan_high 0xFFFF |
|
334 #define floatx80_default_nan_low LIT64( 0xC000000000000000 ) |
|
335 #endif |
|
336 |
|
337 /*---------------------------------------------------------------------------- |
|
338 | Returns 1 if the extended double-precision floating-point value `a' is a |
|
339 | quiet NaN; otherwise returns 0. |
|
340 *----------------------------------------------------------------------------*/ |
|
341 |
|
342 int floatx80_is_nan( floatx80 a ) |
|
343 { |
|
344 #if SNAN_BIT_IS_ONE |
|
345 bits64 aLow; |
|
346 |
|
347 aLow = a.low & ~ LIT64( 0x4000000000000000 ); |
|
348 return |
|
349 ( ( a.high & 0x7FFF ) == 0x7FFF ) |
|
350 && (bits64) ( aLow<<1 ) |
|
351 && ( a.low == aLow ); |
|
352 #else |
|
353 return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 ); |
|
354 #endif |
|
355 } |
|
356 |
|
357 /*---------------------------------------------------------------------------- |
|
358 | Returns 1 if the extended double-precision floating-point value `a' is a |
|
359 | signaling NaN; otherwise returns 0. |
|
360 *----------------------------------------------------------------------------*/ |
|
361 |
|
362 int floatx80_is_signaling_nan( floatx80 a ) |
|
363 { |
|
364 #if SNAN_BIT_IS_ONE |
|
365 return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 ); |
|
366 #else |
|
367 bits64 aLow; |
|
368 |
|
369 aLow = a.low & ~ LIT64( 0x4000000000000000 ); |
|
370 return |
|
371 ( ( a.high & 0x7FFF ) == 0x7FFF ) |
|
372 && (bits64) ( aLow<<1 ) |
|
373 && ( a.low == aLow ); |
|
374 #endif |
|
375 } |
|
376 |
|
377 /*---------------------------------------------------------------------------- |
|
378 | Returns the result of converting the extended double-precision floating- |
|
379 | point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the |
|
380 | invalid exception is raised. |
|
381 *----------------------------------------------------------------------------*/ |
|
382 |
|
383 static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM) |
|
384 { |
|
385 commonNaNT z; |
|
386 |
|
387 if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR); |
|
388 z.sign = a.high>>15; |
|
389 z.low = 0; |
|
390 z.high = a.low; |
|
391 return z; |
|
392 } |
|
393 |
|
394 /*---------------------------------------------------------------------------- |
|
395 | Returns the result of converting the canonical NaN `a' to the extended |
|
396 | double-precision floating-point format. |
|
397 *----------------------------------------------------------------------------*/ |
|
398 |
|
399 static floatx80 commonNaNToFloatx80( commonNaNT a ) |
|
400 { |
|
401 floatx80 z; |
|
402 |
|
403 if (a.high) |
|
404 z.low = a.high; |
|
405 else |
|
406 z.low = floatx80_default_nan_low; |
|
407 z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF; |
|
408 return z; |
|
409 } |
|
410 |
|
411 /*---------------------------------------------------------------------------- |
|
412 | Takes two extended double-precision floating-point values `a' and `b', one |
|
413 | of which is a NaN, and returns the appropriate NaN result. If either `a' or |
|
414 | `b' is a signaling NaN, the invalid exception is raised. |
|
415 *----------------------------------------------------------------------------*/ |
|
416 |
|
417 static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM) |
|
418 { |
|
419 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; |
|
420 |
|
421 if ( STATUS(default_nan_mode) ) { |
|
422 a.low = floatx80_default_nan_low; |
|
423 a.high = floatx80_default_nan_high; |
|
424 return a; |
|
425 } |
|
426 |
|
427 aIsNaN = floatx80_is_nan( a ); |
|
428 aIsSignalingNaN = floatx80_is_signaling_nan( a ); |
|
429 bIsNaN = floatx80_is_nan( b ); |
|
430 bIsSignalingNaN = floatx80_is_signaling_nan( b ); |
|
431 #if SNAN_BIT_IS_ONE |
|
432 a.low &= ~LIT64( 0xC000000000000000 ); |
|
433 b.low &= ~LIT64( 0xC000000000000000 ); |
|
434 #else |
|
435 a.low |= LIT64( 0xC000000000000000 ); |
|
436 b.low |= LIT64( 0xC000000000000000 ); |
|
437 #endif |
|
438 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); |
|
439 if ( aIsSignalingNaN ) { |
|
440 if ( bIsSignalingNaN ) goto returnLargerSignificand; |
|
441 return bIsNaN ? b : a; |
|
442 } |
|
443 else if ( aIsNaN ) { |
|
444 if ( bIsSignalingNaN | ! bIsNaN ) return a; |
|
445 returnLargerSignificand: |
|
446 if ( a.low < b.low ) return b; |
|
447 if ( b.low < a.low ) return a; |
|
448 return ( a.high < b.high ) ? a : b; |
|
449 } |
|
450 else { |
|
451 return b; |
|
452 } |
|
453 } |
|
454 |
|
455 #endif |
|
456 |
|
457 #ifdef FLOAT128 |
|
458 |
|
459 /*---------------------------------------------------------------------------- |
|
460 | The pattern for a default generated quadruple-precision NaN. The `high' and |
|
461 | `low' values hold the most- and least-significant bits, respectively. |
|
462 *----------------------------------------------------------------------------*/ |
|
463 #if SNAN_BIT_IS_ONE |
|
464 #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF ) |
|
465 #define float128_default_nan_low LIT64( 0xFFFFFFFFFFFFFFFF ) |
|
466 #else |
|
467 #define float128_default_nan_high LIT64( 0xFFFF800000000000 ) |
|
468 #define float128_default_nan_low LIT64( 0x0000000000000000 ) |
|
469 #endif |
|
470 |
|
471 /*---------------------------------------------------------------------------- |
|
472 | Returns 1 if the quadruple-precision floating-point value `a' is a quiet |
|
473 | NaN; otherwise returns 0. |
|
474 *----------------------------------------------------------------------------*/ |
|
475 |
|
476 int float128_is_nan( float128 a ) |
|
477 { |
|
478 #if SNAN_BIT_IS_ONE |
|
479 return |
|
480 ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE ) |
|
481 && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) ); |
|
482 #else |
|
483 return |
|
484 ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) ) |
|
485 && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); |
|
486 #endif |
|
487 } |
|
488 |
|
489 /*---------------------------------------------------------------------------- |
|
490 | Returns 1 if the quadruple-precision floating-point value `a' is a |
|
491 | signaling NaN; otherwise returns 0. |
|
492 *----------------------------------------------------------------------------*/ |
|
493 |
|
494 int float128_is_signaling_nan( float128 a ) |
|
495 { |
|
496 #if SNAN_BIT_IS_ONE |
|
497 return |
|
498 ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) ) |
|
499 && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) ); |
|
500 #else |
|
501 return |
|
502 ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE ) |
|
503 && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) ); |
|
504 #endif |
|
505 } |
|
506 |
|
507 /*---------------------------------------------------------------------------- |
|
508 | Returns the result of converting the quadruple-precision floating-point NaN |
|
509 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid |
|
510 | exception is raised. |
|
511 *----------------------------------------------------------------------------*/ |
|
512 |
|
513 static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM) |
|
514 { |
|
515 commonNaNT z; |
|
516 |
|
517 if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR); |
|
518 z.sign = a.high>>63; |
|
519 shortShift128Left( a.high, a.low, 16, &z.high, &z.low ); |
|
520 return z; |
|
521 } |
|
522 |
|
523 /*---------------------------------------------------------------------------- |
|
524 | Returns the result of converting the canonical NaN `a' to the quadruple- |
|
525 | precision floating-point format. |
|
526 *----------------------------------------------------------------------------*/ |
|
527 |
|
528 static float128 commonNaNToFloat128( commonNaNT a ) |
|
529 { |
|
530 float128 z; |
|
531 |
|
532 shift128Right( a.high, a.low, 16, &z.high, &z.low ); |
|
533 z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 ); |
|
534 return z; |
|
535 } |
|
536 |
|
537 /*---------------------------------------------------------------------------- |
|
538 | Takes two quadruple-precision floating-point values `a' and `b', one of |
|
539 | which is a NaN, and returns the appropriate NaN result. If either `a' or |
|
540 | `b' is a signaling NaN, the invalid exception is raised. |
|
541 *----------------------------------------------------------------------------*/ |
|
542 |
|
543 static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM) |
|
544 { |
|
545 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN; |
|
546 |
|
547 if ( STATUS(default_nan_mode) ) { |
|
548 a.low = float128_default_nan_low; |
|
549 a.high = float128_default_nan_high; |
|
550 return a; |
|
551 } |
|
552 |
|
553 aIsNaN = float128_is_nan( a ); |
|
554 aIsSignalingNaN = float128_is_signaling_nan( a ); |
|
555 bIsNaN = float128_is_nan( b ); |
|
556 bIsSignalingNaN = float128_is_signaling_nan( b ); |
|
557 #if SNAN_BIT_IS_ONE |
|
558 a.high &= ~LIT64( 0x0000800000000000 ); |
|
559 b.high &= ~LIT64( 0x0000800000000000 ); |
|
560 #else |
|
561 a.high |= LIT64( 0x0000800000000000 ); |
|
562 b.high |= LIT64( 0x0000800000000000 ); |
|
563 #endif |
|
564 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR); |
|
565 if ( aIsSignalingNaN ) { |
|
566 if ( bIsSignalingNaN ) goto returnLargerSignificand; |
|
567 return bIsNaN ? b : a; |
|
568 } |
|
569 else if ( aIsNaN ) { |
|
570 if ( bIsSignalingNaN | ! bIsNaN ) return a; |
|
571 returnLargerSignificand: |
|
572 if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b; |
|
573 if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a; |
|
574 return ( a.high < b.high ) ? a : b; |
|
575 } |
|
576 else { |
|
577 return b; |
|
578 } |
|
579 } |
|
580 |
|
581 #endif |