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 /*----------------------------------------------------------------------------
83 | Returns 1 if the extended double-precision floating-point value `a' is a
84 | NaN; otherwise returns 0.
85 *----------------------------------------------------------------------------*/
87 flag floatx80_is_nan( floatx80 a );
89 /*----------------------------------------------------------------------------
90 | The pattern for a default generated extended double-precision NaN.
91 *----------------------------------------------------------------------------*/
92 static inline floatx80 floatx80_default_nan(float_status *status)
97 r.low = LIT64( 0xFFFFFFFFFFFFFFFF );
101 /*----------------------------------------------------------------------------
102 | Raises the exceptions specified by `flags'. Floating-point traps can be
103 | defined here if desired. It is currently not possible for such a trap
104 | to substitute a result value. If traps are not implemented, this routine
105 | should be simply `float_exception_flags |= flags;'.
106 *----------------------------------------------------------------------------*/
108 void float_raise(uint8_t flags, float_status *status);
110 /*----------------------------------------------------------------------------
111 | Internal canonical NaN format.
112 *----------------------------------------------------------------------------*/
118 /*----------------------------------------------------------------------------
119 | Returns 1 if the single-precision floating-point value `a' is a NaN;
120 | otherwise returns 0.
121 *----------------------------------------------------------------------------*/
123 static inline flag float32_is_nan( float32 a )
126 return ( 0xFF000000 < (uint32_t) ( a<<1 ) );
130 /*----------------------------------------------------------------------------
131 | Returns 1 if the single-precision floating-point value `a' is a signaling
132 | NaN; otherwise returns 0.
133 *----------------------------------------------------------------------------*/
135 static inline flag float32_is_signaling_nan( float32 a )
138 return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
142 /*----------------------------------------------------------------------------
143 | Returns the result of converting the single-precision floating-point NaN
144 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
145 | exception is raised.
146 *----------------------------------------------------------------------------*/
148 static inline commonNaNT float32ToCommonNaN( float32 a, float_status *status )
152 if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_signaling, status );
155 z.high = ( (uint64_t) a )<<41;
160 /*----------------------------------------------------------------------------
161 | Returns the result of converting the canonical NaN `a' to the single-
162 | precision floating-point format.
163 *----------------------------------------------------------------------------*/
165 static inline float32 commonNaNToFloat32( commonNaNT a )
168 return ( ( (uint32_t) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 );
172 /*----------------------------------------------------------------------------
173 | Takes two single-precision floating-point values `a' and `b', one of which
174 | is a NaN, and returns the appropriate NaN result. If either `a' or `b' is a
175 | signaling NaN, the invalid exception is raised.
176 *----------------------------------------------------------------------------*/
178 static inline float32 propagateFloat32NaN( float32 a, float32 b, float_status *status )
180 flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
182 aIsNaN = float32_is_nan( a );
183 aIsSignalingNaN = float32_is_signaling_nan( a );
184 bIsNaN = float32_is_nan( b );
185 bIsSignalingNaN = float32_is_signaling_nan( b );
188 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_signaling, status );
190 return ( aIsSignalingNaN & bIsNaN ) ? b : a;
198 /*----------------------------------------------------------------------------
199 | Returns 1 if the double-precision floating-point value `a' is a NaN;
200 | otherwise returns 0.
201 *----------------------------------------------------------------------------*/
203 static inline flag float64_is_nan( float64 a )
206 return ( LIT64( 0xFFE0000000000000 ) < (uint64_t) ( a<<1 ) );
210 /*----------------------------------------------------------------------------
211 | Returns 1 if the double-precision floating-point value `a' is a signaling
212 | NaN; otherwise returns 0.
213 *----------------------------------------------------------------------------*/
215 static inline flag float64_is_signaling_nan( float64 a )
219 ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
220 && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
224 /*----------------------------------------------------------------------------
225 | Returns the result of converting the double-precision floating-point NaN
226 | `a' to the canonical NaN format. If `a' is a signaling NaN, the invalid
227 | exception is raised.
228 *----------------------------------------------------------------------------*/
230 static inline commonNaNT float64ToCommonNaN(float64 a, float_status *status)
234 if (float64_is_signaling_nan(a)) {
235 float_raise(float_flag_invalid, status);
237 z.sign = float64_val(a) >> 63;
239 z.high = float64_val(a) << 12;
243 /*----------------------------------------------------------------------------
244 | Returns the result of converting the canonical NaN `a' to the double-
245 | precision floating-point format.
246 *----------------------------------------------------------------------------*/
248 static inline float64 commonNaNToFloat64(commonNaNT a, float_status *status)
252 ( ( (uint64_t) a.sign )<<63 )
253 | LIT64( 0x7FF8000000000000 )
257 /*----------------------------------------------------------------------------
258 | Returns 1 if the extended double-precision floating-point value `a' is a
259 | signaling NaN; otherwise returns 0.
260 *----------------------------------------------------------------------------*/
262 static inline flag floatx80_is_signaling_nan( floatx80 a )
266 aLow = a.low & ~ LIT64( 0x4000000000000000 );
268 ( ( a.high & 0x7FFF ) == 0x7FFF )
269 && (uint64_t) ( aLow<<1 )
270 && ( a.low == aLow );
274 /*----------------------------------------------------------------------------
275 | Returns the result of converting the extended double-precision floating-
276 | point NaN `a' to the canonical NaN format. If `a' is a signaling NaN, the
277 | invalid exception is raised.
278 *----------------------------------------------------------------------------*/
280 static inline commonNaNT floatx80ToCommonNaN( floatx80 a, float_status *status )
284 if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_signaling, status );
292 /*----------------------------------------------------------------------------
293 | Returns the result of converting the canonical NaN `a' to the extended
294 | double-precision floating-point format.
295 *----------------------------------------------------------------------------*/
297 static inline floatx80 commonNaNToFloatx80(commonNaNT a, float_status *status)
302 z.low = LIT64( 0x4000000000000000 ) | ( a.high>>1 );
304 z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
306 z.high = ( ( (int16_t) a.sign )<<15 ) | 0x7FFF;
310 /*----------------------------------------------------------------------------
311 | Takes two extended double-precision floating-point values `a' and `b', one
312 | of which is a NaN, and returns the appropriate NaN result. If either `a' or
313 | `b' is a signaling NaN, the invalid exception is raised.
314 *----------------------------------------------------------------------------*/
316 static inline floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b, float_status *status )
318 flag aIsNaN, aIsSignalingNaN, bIsSignalingNaN;
319 #ifndef SOFTFLOAT_68K
323 aIsNaN = floatx80_is_nan( a );
324 aIsSignalingNaN = floatx80_is_signaling_nan( a );
325 bIsSignalingNaN = floatx80_is_signaling_nan( b );
327 a.low |= LIT64( 0x4000000000000000 );
328 b.low |= LIT64( 0x4000000000000000 );
329 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_signaling, status );
330 return aIsNaN ? a : b;
332 bIsNaN = floatx80_is_nan( b );
333 a.low |= LIT64( 0xC000000000000000 );
334 b.low |= LIT64( 0xC000000000000000 );
335 if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_signaling, status );
337 return ( aIsSignalingNaN & bIsNaN ) ? b : a;
347 /*----------------------------------------------------------------------------
348 | Takes extended double-precision floating-point NaN `a' and returns the
349 | appropriate NaN result. If `a' is a signaling NaN, the invalid exception
351 *----------------------------------------------------------------------------*/
353 static inline floatx80 propagateFloatx80NaNOneArg(floatx80 a, float_status *status)
355 if ( floatx80_is_signaling_nan( a ) )
356 float_raise( float_flag_signaling, status );
357 a.low |= LIT64( 0x4000000000000000 );
363 // 28-12-2016: Added for Previous:
365 /*----------------------------------------------------------------------------
366 | Returns 1 if the extended double-precision floating-point value `a' is
367 | zero; otherwise returns 0.
368 *----------------------------------------------------------------------------*/
370 static inline flag floatx80_is_zero( floatx80 a )
373 return ( ( a.high & 0x7FFF ) < 0x7FFF ) && ( a.low == 0 );
377 /*----------------------------------------------------------------------------
378 | Returns 1 if the extended double-precision floating-point value `a' is
379 | infinity; otherwise returns 0.
380 *----------------------------------------------------------------------------*/
382 static inline flag floatx80_is_infinity( floatx80 a )
385 return ( ( a.high & 0x7FFF ) == 0x7FFF ) && ( (uint64_t) ( a.low<<1 ) == 0 );
389 /*----------------------------------------------------------------------------
390 | Returns 1 if the extended double-precision floating-point value `a' is
391 | negative; otherwise returns 0.
392 *----------------------------------------------------------------------------*/
394 static inline flag floatx80_is_negative( floatx80 a )
397 return ( ( a.high & 0x8000 ) == 0x8000 );
401 /*----------------------------------------------------------------------------
402 | Returns 1 if the extended double-precision floating-point value `a' is
403 | unnormal; otherwise returns 0.
404 *----------------------------------------------------------------------------*/
405 static inline flag floatx80_is_unnormal( floatx80 a )
408 ( ( a.high & 0x7FFF ) > 0 )
409 && ( ( a.high & 0x7FFF ) < 0x7FFF)
410 && ( (uint64_t) ( a.low & LIT64( 0x8000000000000000 ) ) == LIT64( 0x0000000000000000 ) );
413 /*----------------------------------------------------------------------------
414 | Returns 1 if the extended double-precision floating-point value `a' is
415 | denormal; otherwise returns 0.
416 *----------------------------------------------------------------------------*/
418 static inline flag floatx80_is_denormal( floatx80 a )
421 ( ( a.high & 0x7FFF ) == 0 )
422 && ( (uint64_t) ( a.low & LIT64( 0x8000000000000000 ) ) == LIT64( 0x0000000000000000 ) )
423 && (uint64_t) ( a.low<<1 );
426 /*----------------------------------------------------------------------------
427 | Returns 1 if the extended double-precision floating-point value `a' is
428 | normal; otherwise returns 0.
429 *----------------------------------------------------------------------------*/
431 static inline flag floatx80_is_normal( floatx80 a )
434 ( ( a.high & 0x7FFF ) < 0x7FFF )
435 && ( (uint64_t) ( a.low & LIT64( 0x8000000000000000 ) ) == LIT64( 0x8000000000000000 ) );
437 // End of addition for Previous