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: | 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;
   44: 
   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: *----------------------------------------------------------------------------*/
   51: 
   52: void float_raise( int8 flags STATUS_PARAM )
   53: {
   54:     STATUS(float_exception_flags) |= flags;
   55: }
   56: 
   57: /*----------------------------------------------------------------------------
   58: | Internal canonical NaN format.
   59: *----------------------------------------------------------------------------*/
   60: typedef struct {
   61:     flag sign;
   62:     bits64 high, low;
   63: } commonNaNT;
   64: 
   65: /*----------------------------------------------------------------------------
   66: | The pattern for a default generated single-precision NaN.
   67: *----------------------------------------------------------------------------*/
   68: #if defined(TARGET_SPARC)
   69: #define float32_default_nan make_float32(0x7FFFFFFF)
   70: #elif defined(TARGET_POWERPC)
   71: #define float32_default_nan make_float32(0x7FC00000)
   72: #elif defined(TARGET_HPPA)
   73: #define float32_default_nan make_float32(0x7FA00000)
   74: #elif SNAN_BIT_IS_ONE
   75: #define float32_default_nan make_float32(0x7FBFFFFF)
   76: #else
   77: #define float32_default_nan make_float32(0xFFC00000)
   78: #endif
   79: 
   80: /*----------------------------------------------------------------------------
   81: | Returns 1 if the single-precision floating-point value `a' is a quiet
   82: | NaN; otherwise returns 0.
   83: *----------------------------------------------------------------------------*/
   84: 
   85: int float32_is_nan( float32 a_ )
   86: {
   87:     uint32_t a = float32_val(a_);
   88: #if SNAN_BIT_IS_ONE
   89:     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
   90: #else
   91:     return ( 0xFF800000 <= (bits32) ( a<<1 ) );
   92: #endif
   93: }
   94: 
   95: /*----------------------------------------------------------------------------
   96: | Returns 1 if the single-precision floating-point value `a' is a signaling
   97: | NaN; otherwise returns 0.
   98: *----------------------------------------------------------------------------*/
   99: 
  100: int float32_is_signaling_nan( float32 a_ )
  101: {
  102:     uint32_t a = float32_val(a_);
  103: #if SNAN_BIT_IS_ONE
  104:     return ( 0xFF800000 <= (bits32) ( a<<1 ) );
  105: #else
  106:     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
  107: #endif
  108: }
  109: 
  110: /*----------------------------------------------------------------------------
  111: | Returns the result of converting the single-precision floating-point NaN
  112: | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
  113: | exception is raised.
  114: *----------------------------------------------------------------------------*/
  115: 
  116: static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
  117: {
  118:     commonNaNT z;
  119: 
  120:     if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
  121:     z.sign = float32_val(a)>>31;
  122:     z.low = 0;
  123:     z.high = ( (bits64) float32_val(a) )<<41;
  124:     return z;
  125: }
  126: 
  127: /*----------------------------------------------------------------------------
  128: | Returns the result of converting the canonical NaN `a' to the single-
  129: | precision floating-point format.
  130: *----------------------------------------------------------------------------*/
  131: 
  132: static float32 commonNaNToFloat32( commonNaNT a )
  133: {
  134:     bits32 mantissa = a.high>>41;
  135:     if ( mantissa )
  136:         return make_float32(
  137:             ( ( (bits32) a.sign )<<31 ) | 0x7F800000 | ( a.high>>41 ) );
  138:     else
  139:         return float32_default_nan;
  140: }
  141: 
  142: /*----------------------------------------------------------------------------
  143: | Takes two single-precision floating-point values `a' and `b', one of which
  144: | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
  145: | signaling NaN, the invalid exception is raised.
  146: *----------------------------------------------------------------------------*/
  147: 
  148: static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
  149: {
  150:     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
  151:     bits32 av, bv, res;
  152: 
  153:     aIsNaN = float32_is_nan( a );
  154:     aIsSignalingNaN = float32_is_signaling_nan( a );
  155:     bIsNaN = float32_is_nan( b );
  156:     bIsSignalingNaN = float32_is_signaling_nan( b );
  157:     av = float32_val(a);
  158:     bv = float32_val(b);
  159: #if SNAN_BIT_IS_ONE
  160:     av &= ~0x00400000;
  161:     bv &= ~0x00400000;
  162: #else
  163:     av |= 0x00400000;
  164:     bv |= 0x00400000;
  165: #endif
  166:     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
  167:     if ( aIsSignalingNaN ) {
  168:         if ( bIsSignalingNaN ) goto returnLargerSignificand;
  169:         res = bIsNaN ? bv : av;
  170:     }
  171:     else if ( aIsNaN ) {
  172:         if ( bIsSignalingNaN | ! bIsNaN )
  173:             res = av;
  174:         else {
  175:  returnLargerSignificand:
  176:             if ( (bits32) ( av<<1 ) < (bits32) ( bv<<1 ) )
  177:                 res = bv;
  178:             else if ( (bits32) ( bv<<1 ) < (bits32) ( av<<1 ) )
  179:                 res = av;
  180:             else
  181:                 res = ( av < bv ) ? av : bv;
  182:         }
  183:     }
  184:     else {
  185:         res = bv;
  186:     }
  187:     return make_float32(res);
  188: }
  189: 
  190: /*----------------------------------------------------------------------------
  191: | The pattern for a default generated double-precision NaN.
  192: *----------------------------------------------------------------------------*/
  193: #if defined(TARGET_SPARC)
  194: #define float64_default_nan make_float64(LIT64( 0x7FFFFFFFFFFFFFFF ))
  195: #elif defined(TARGET_POWERPC)
  196: #define float64_default_nan make_float64(LIT64( 0x7FF8000000000000 ))
  197: #elif defined(TARGET_HPPA)
  198: #define float64_default_nan make_float64(LIT64( 0x7FF4000000000000 ))
  199: #elif SNAN_BIT_IS_ONE
  200: #define float64_default_nan make_float64(LIT64( 0x7FF7FFFFFFFFFFFF ))
  201: #else
  202: #define float64_default_nan make_float64(LIT64( 0xFFF8000000000000 ))
  203: #endif
  204: 
  205: /*----------------------------------------------------------------------------
  206: | Returns 1 if the double-precision floating-point value `a' is a quiet
  207: | NaN; otherwise returns 0.
  208: *----------------------------------------------------------------------------*/
  209: 
  210: int float64_is_nan( float64 a_ )
  211: {
  212:     bits64 a = float64_val(a_);
  213: #if SNAN_BIT_IS_ONE
  214:     return
  215:            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
  216:         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
  217: #else
  218:     return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
  219: #endif
  220: }
  221: 
  222: /*----------------------------------------------------------------------------
  223: | Returns 1 if the double-precision floating-point value `a' is a signaling
  224: | NaN; otherwise returns 0.
  225: *----------------------------------------------------------------------------*/
  226: 
  227: int float64_is_signaling_nan( float64 a_ )
  228: {
  229:     bits64 a = float64_val(a_);
  230: #if SNAN_BIT_IS_ONE
  231:     return ( LIT64( 0xFFF0000000000000 ) <= (bits64) ( a<<1 ) );
  232: #else
  233:     return
  234:            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
  235:         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
  236: #endif
  237: }
  238: 
  239: /*----------------------------------------------------------------------------
  240: | Returns the result of converting the double-precision floating-point NaN
  241: | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
  242: | exception is raised.
  243: *----------------------------------------------------------------------------*/
  244: 
  245: static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
  246: {
  247:     commonNaNT z;
  248: 
  249:     if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
  250:     z.sign = float64_val(a)>>63;
  251:     z.low = 0;
  252:     z.high = float64_val(a)<<12;
  253:     return z;
  254: }
  255: 
  256: /*----------------------------------------------------------------------------
  257: | Returns the result of converting the canonical NaN `a' to the double-
  258: | precision floating-point format.
  259: *----------------------------------------------------------------------------*/
  260: 
  261: static float64 commonNaNToFloat64( commonNaNT a )
  262: {
  263:     bits64 mantissa = a.high>>12;
  264: 
  265:     if ( mantissa )
  266:         return make_float64(
  267:               ( ( (bits64) a.sign )<<63 )
  268:             | LIT64( 0x7FF0000000000000 )
  269:             | ( a.high>>12 ));
  270:     else
  271:         return float64_default_nan;
  272: }
  273: 
  274: /*----------------------------------------------------------------------------
  275: | Takes two double-precision floating-point values `a' and `b', one of which
  276: | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
  277: | signaling NaN, the invalid exception is raised.
  278: *----------------------------------------------------------------------------*/
  279: 
  280: static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
  281: {
  282:     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
  283:     bits64 av, bv, res;
  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:     aIsNaN = floatx80_is_nan( a );
  422:     aIsSignalingNaN = floatx80_is_signaling_nan( a );
  423:     bIsNaN = floatx80_is_nan( b );
  424:     bIsSignalingNaN = floatx80_is_signaling_nan( b );
  425: #if SNAN_BIT_IS_ONE
  426:     a.low &= ~LIT64( 0xC000000000000000 );
  427:     b.low &= ~LIT64( 0xC000000000000000 );
  428: #else
  429:     a.low |= LIT64( 0xC000000000000000 );
  430:     b.low |= LIT64( 0xC000000000000000 );
  431: #endif
  432:     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
  433:     if ( aIsSignalingNaN ) {
  434:         if ( bIsSignalingNaN ) goto returnLargerSignificand;
  435:         return bIsNaN ? b : a;
  436:     }
  437:     else if ( aIsNaN ) {
  438:         if ( bIsSignalingNaN | ! bIsNaN ) return a;
  439:  returnLargerSignificand:
  440:         if ( a.low < b.low ) return b;
  441:         if ( b.low < a.low ) return a;
  442:         return ( a.high < b.high ) ? a : b;
  443:     }
  444:     else {
  445:         return b;
  446:     }
  447: }
  448: 
  449: #endif
  450: 
  451: #ifdef FLOAT128
  452: 
  453: /*----------------------------------------------------------------------------
  454: | The pattern for a default generated quadruple-precision NaN.  The `high' and
  455: | `low' values hold the most- and least-significant bits, respectively.
  456: *----------------------------------------------------------------------------*/
  457: #if SNAN_BIT_IS_ONE
  458: #define float128_default_nan_high LIT64( 0x7FFF7FFFFFFFFFFF )
  459: #define float128_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )
  460: #else
  461: #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
  462: #define float128_default_nan_low  LIT64( 0x0000000000000000 )
  463: #endif
  464: 
  465: /*----------------------------------------------------------------------------
  466: | Returns 1 if the quadruple-precision floating-point value `a' is a quiet
  467: | NaN; otherwise returns 0.
  468: *----------------------------------------------------------------------------*/
  469: 
  470: int float128_is_nan( float128 a )
  471: {
  472: #if SNAN_BIT_IS_ONE
  473:     return
  474:            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
  475:         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
  476: #else
  477:     return
  478:            ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
  479:         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
  480: #endif
  481: }
  482: 
  483: /*----------------------------------------------------------------------------
  484: | Returns 1 if the quadruple-precision floating-point value `a' is a
  485: | signaling NaN; otherwise returns 0.
  486: *----------------------------------------------------------------------------*/
  487: 
  488: int float128_is_signaling_nan( float128 a )
  489: {
  490: #if SNAN_BIT_IS_ONE
  491:     return
  492:            ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
  493:         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
  494: #else
  495:     return
  496:            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
  497:         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
  498: #endif
  499: }
  500: 
  501: /*----------------------------------------------------------------------------
  502: | Returns the result of converting the quadruple-precision floating-point NaN
  503: | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
  504: | exception is raised.
  505: *----------------------------------------------------------------------------*/
  506: 
  507: static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
  508: {
  509:     commonNaNT z;
  510: 
  511:     if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
  512:     z.sign = a.high>>63;
  513:     shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
  514:     return z;
  515: }
  516: 
  517: /*----------------------------------------------------------------------------
  518: | Returns the result of converting the canonical NaN `a' to the quadruple-
  519: | precision floating-point format.
  520: *----------------------------------------------------------------------------*/
  521: 
  522: static float128 commonNaNToFloat128( commonNaNT a )
  523: {
  524:     float128 z;
  525: 
  526:     shift128Right( a.high, a.low, 16, &z.high, &z.low );
  527:     z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF000000000000 );
  528:     return z;
  529: }