git.sesse.net Git - pistorm/blob - softfloat/softfloat-specialize.h

   1 /*
   2  * QEMU float support
   3  *
   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
  10  *  the BSD license
  11  *  GPL-v2-or-later
  12  *
  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.
  16  */
  17
  18 /*
  19 ===============================================================================
  20 This C source fragment is part of the SoftFloat IEC/IEEE Floating-point
  21 Arithmetic Package, Release 2a.
  22
  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'.
  32
  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.
  38
  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.
  43
  44 ===============================================================================
  45 */
  46
  47 /* BSD licensing:
  48  * Copyright (c) 2006, Fabrice Bellard
  49  * All rights reserved.
  50  *
  51  * Redistribution and use in source and binary forms, with or without
  52  * modification, are permitted provided that the following conditions are met:
  53  *
  54  * 1. Redistributions of source code must retain the above copyright notice,
  55  * this list of conditions and the following disclaimer.
  56  *
  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.
  60  *
  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.
  64  *
  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.
  76  */
  77
  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.
  80  */
  81
  82 /*----------------------------------------------------------------------------
  83 | Returns 1 if the extended double-precision floating-point value `a' is a
  84 | NaN; otherwise returns 0.
  85 *----------------------------------------------------------------------------*/
  86
  87 flag floatx80_is_nan( floatx80 a );
  88
  89 /*----------------------------------------------------------------------------
  90 | The pattern for a default generated extended double-precision NaN.
  91 *----------------------------------------------------------------------------*/
  92 static inline floatx80 floatx80_default_nan(float_status *status)
  93 {
  94         (void)status;
  95     floatx80 r;
  96     r.high = 0x7FFF;
  97     r.low = LIT64( 0xFFFFFFFFFFFFFFFF );
  98         return r;
  99 }
 100
 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 *----------------------------------------------------------------------------*/
 107
 108 void float_raise(uint8_t flags, float_status *status);
 109
 110 /*----------------------------------------------------------------------------
 111 | Internal canonical NaN format.
 112 *----------------------------------------------------------------------------*/
 113 typedef struct {
 114     flag sign;
 115     uint64_t high, low;
 116 } commonNaNT;
 117
 118 /*----------------------------------------------------------------------------
 119 | Returns 1 if the single-precision floating-point value `a' is a NaN;
 120 | otherwise returns 0.
 121 *----------------------------------------------------------------------------*/
 122
 123 static inline flag float32_is_nan( float32 a )
 124 {
 125
 126     return ( 0xFF000000 < (uint32_t) ( a<<1 ) );
 127
 128 }
 129
 130 /*----------------------------------------------------------------------------
 131 | Returns 1 if the single-precision floating-point value `a' is a signaling
 132 | NaN; otherwise returns 0.
 133 *----------------------------------------------------------------------------*/
 134
 135 static inline flag float32_is_signaling_nan( float32 a )
 136 {
 137
 138     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
 139
 140 }
 141
 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 *----------------------------------------------------------------------------*/
 147
 148 static inline commonNaNT float32ToCommonNaN( float32 a, float_status *status )
 149 {
 150     commonNaNT z;
 151
 152     if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_signaling, status );
 153     z.sign = a>>31;
 154     z.low = 0;
 155     z.high = ( (uint64_t) a )<<41;
 156     return z;
 157
 158 }
 159
 160 /*----------------------------------------------------------------------------
 161 | Returns the result of converting the canonical NaN `a' to the single-
 162 | precision floating-point format.
 163 *----------------------------------------------------------------------------*/
 164
 165 static inline float32 commonNaNToFloat32( commonNaNT a )
 166 {
 167
 168     return ( ( (uint32_t) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 );
 169
 170 }
 171
 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 *----------------------------------------------------------------------------*/
 177
 178 static inline float32 propagateFloat32NaN( float32 a, float32 b, float_status *status )
 179 {
 180     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
 181
 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 );
 186     a |= 0x00400000;
 187     b |= 0x00400000;
 188     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_signaling, status );
 189     if ( aIsNaN ) {
 190         return ( aIsSignalingNaN & bIsNaN ) ? b : a;
 191     }
 192     else {
 193         return b;
 194     }
 195
 196 }
 197
 198 /*----------------------------------------------------------------------------
 199 | Returns 1 if the double-precision floating-point value `a' is a NaN;
 200 | otherwise returns 0.
 201 *----------------------------------------------------------------------------*/
 202
 203 static inline flag float64_is_nan( float64 a )
 204 {
 205
 206     return ( LIT64( 0xFFE0000000000000 ) < (uint64_t) ( a<<1 ) );
 207
 208 }
 209
 210 /*----------------------------------------------------------------------------
 211 | Returns 1 if the double-precision floating-point value `a' is a signaling
 212 | NaN; otherwise returns 0.
 213 *----------------------------------------------------------------------------*/
 214
 215 static inline flag float64_is_signaling_nan( float64 a )
 216 {
 217
 218     return
 219            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
 220         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
 221
 222 }
 223
 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 *----------------------------------------------------------------------------*/
 229
 230 static inline commonNaNT float64ToCommonNaN(float64 a, float_status *status)
 231 {
 232     commonNaNT z;
 233
 234     if (float64_is_signaling_nan(a)) {
 235         float_raise(float_flag_invalid, status);
 236     }
 237     z.sign = float64_val(a) >> 63;
 238     z.low = 0;
 239     z.high = float64_val(a) << 12;
 240     return z;
 241 }
 242
 243 /*----------------------------------------------------------------------------
 244 | Returns the result of converting the canonical NaN `a' to the double-
 245 | precision floating-point format.
 246 *----------------------------------------------------------------------------*/
 247
 248 static inline float64 commonNaNToFloat64(commonNaNT a, float_status *status)
 249 {
 250         (void)status;
 251      return
 252           ( ( (uint64_t) a.sign )<<63 )
 253         | LIT64( 0x7FF8000000000000 )
 254         | ( a.high>>12 );
 255 }
 256
 257 /*----------------------------------------------------------------------------
 258 | Returns 1 if the extended double-precision floating-point value `a' is a
 259 | signaling NaN; otherwise returns 0.
 260 *----------------------------------------------------------------------------*/
 261
 262 static inline flag floatx80_is_signaling_nan( floatx80 a )
 263 {
 264     uint64_t aLow;
 265
 266     aLow = a.low & ~ LIT64( 0x4000000000000000 );
 267     return
 268            ( ( a.high & 0x7FFF ) == 0x7FFF )
 269         && (uint64_t) ( aLow<<1 )
 270         && ( a.low == aLow );
 271
 272 }
 273
 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 *----------------------------------------------------------------------------*/
 279
 280 static inline commonNaNT floatx80ToCommonNaN( floatx80 a, float_status *status )
 281 {
 282     commonNaNT z;
 283
 284     if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_signaling, status );
 285     z.sign = a.high>>15;
 286     z.low = 0;
 287     z.high = a.low<<1;
 288     return z;
 289
 290 }
 291
 292 /*----------------------------------------------------------------------------
 293 | Returns the result of converting the canonical NaN `a' to the extended
 294 | double-precision floating-point format.
 295 *----------------------------------------------------------------------------*/
 296
 297 static inline floatx80 commonNaNToFloatx80(commonNaNT a, float_status *status)
 298 {
 299         (void)status;
 300     floatx80 z;
 301 #ifdef SOFTFLOAT_68K
 302     z.low = LIT64( 0x4000000000000000 ) | ( a.high>>1 );
 303 #else
 304     z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
 305 #endif
 306     z.high = ( ( (int16_t) a.sign )<<15 ) | 0x7FFF;
 307     return z;
 308 }
 309
 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 *----------------------------------------------------------------------------*/
 315
 316 static inline floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b, float_status *status )
 317 {
 318     flag aIsNaN, aIsSignalingNaN, bIsSignalingNaN;
 319 #ifndef SOFTFLOAT_68K
 320     flag bIsNaN;
 321 #endif
 322
 323         aIsNaN = floatx80_is_nan( a );
 324     aIsSignalingNaN = floatx80_is_signaling_nan( a );
 325     bIsSignalingNaN = floatx80_is_signaling_nan( b );
 326 #ifdef SOFTFLOAT_68K
 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;
 331 #else
 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 );
 336     if ( aIsNaN ) {
 337         return ( aIsSignalingNaN & bIsNaN ) ? b : a;
 338     }
 339     else {
 340         return b;
 341     }
 342 #endif
 343
 344 }
 345
 346 #ifdef SOFTFLOAT_68K
 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
 350  | is raised.
 351  *----------------------------------------------------------------------------*/
 352
 353 static inline floatx80 propagateFloatx80NaNOneArg(floatx80 a, float_status *status)
 354 {
 355     if ( floatx80_is_signaling_nan( a ) )
 356         float_raise( float_flag_signaling, status );
 357     a.low |= LIT64( 0x4000000000000000 );
 358
 359     return a;
 360 }
 361 #endif
 362
 363 // 28-12-2016: Added for Previous:
 364
 365 /*----------------------------------------------------------------------------
 366  | Returns 1 if the extended double-precision floating-point value `a' is
 367  | zero; otherwise returns 0.
 368  *----------------------------------------------------------------------------*/
 369
 370 static inline flag floatx80_is_zero( floatx80 a )
 371 {
 372
 373     return ( ( a.high & 0x7FFF ) < 0x7FFF ) && ( a.low == 0 );
 374
 375 }
 376
 377 /*----------------------------------------------------------------------------
 378  | Returns 1 if the extended double-precision floating-point value `a' is
 379  | infinity; otherwise returns 0.
 380  *----------------------------------------------------------------------------*/
 381
 382 static inline flag floatx80_is_infinity( floatx80 a )
 383 {
 384
 385     return ( ( a.high & 0x7FFF ) == 0x7FFF ) && ( (uint64_t) ( a.low<<1 ) == 0 );
 386
 387 }
 388
 389 /*----------------------------------------------------------------------------
 390  | Returns 1 if the extended double-precision floating-point value `a' is
 391  | negative; otherwise returns 0.
 392  *----------------------------------------------------------------------------*/
 393
 394 static inline flag floatx80_is_negative( floatx80 a )
 395 {
 396
 397     return ( ( a.high & 0x8000 ) == 0x8000 );
 398
 399 }
 400
 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 )
 406 {
 407         return
 408                 ( ( a.high & 0x7FFF ) > 0 )
 409                 && ( ( a.high & 0x7FFF ) < 0x7FFF)
 410                 && ( (uint64_t) ( a.low & LIT64( 0x8000000000000000 ) ) == LIT64( 0x0000000000000000 ) );
 411 }
 412
 413 /*----------------------------------------------------------------------------
 414  | Returns 1 if the extended double-precision floating-point value `a' is
 415  | denormal; otherwise returns 0.
 416  *----------------------------------------------------------------------------*/
 417
 418 static inline flag floatx80_is_denormal( floatx80 a )
 419 {
 420         return
 421                 ( ( a.high & 0x7FFF ) == 0 )
 422                 && ( (uint64_t) ( a.low & LIT64( 0x8000000000000000 ) ) == LIT64( 0x0000000000000000 ) )
 423                 && (uint64_t) ( a.low<<1 );
 424 }
 425
 426 /*----------------------------------------------------------------------------
 427  | Returns 1 if the extended double-precision floating-point value `a' is
 428  | normal; otherwise returns 0.
 429  *----------------------------------------------------------------------------*/
 430
 431 static inline flag floatx80_is_normal( floatx80 a )
 432 {
 433         return
 434                 ( ( a.high & 0x7FFF ) < 0x7FFF )
 435                 && ( (uint64_t) ( a.low & LIT64( 0x8000000000000000 ) ) == LIT64( 0x8000000000000000 ) );
 436 }
 437 // End of addition for Previous
 438