Return to softfloat-specialize.h CVS log

Up to [Qemu by Fabrice Bellard] / qemu / fpu

Annotation of qemu/fpu/softfloat-specialize.h, revision 1.1

1.1     ! root        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: /*----------------------------------------------------------------------------
        !            34: | Underflow tininess-detection mode, statically initialized to default value.
        !            35: | (The declaration in `softfloat.h' must match the `int8' type here.)
        !            36: *----------------------------------------------------------------------------*/
        !            37: int8 float_detect_tininess = float_tininess_after_rounding;
        !            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: 
        !            49:     STATUS(float_exception_flags) |= flags;
        !            50: 
        !            51: }
        !            52: 
        !            53: /*----------------------------------------------------------------------------
        !            54: | Internal canonical NaN format.
        !            55: *----------------------------------------------------------------------------*/
        !            56: typedef struct {
        !            57:     flag sign;
        !            58:     bits64 high, low;
        !            59: } commonNaNT;
        !            60: 
        !            61: /*----------------------------------------------------------------------------
        !            62: | The pattern for a default generated single-precision NaN.
        !            63: *----------------------------------------------------------------------------*/
        !            64: #define float32_default_nan 0xFFC00000
        !            65: 
        !            66: /*----------------------------------------------------------------------------
        !            67: | Returns 1 if the single-precision floating-point value `a' is a NaN;
        !            68: | otherwise returns 0.
        !            69: *----------------------------------------------------------------------------*/
        !            70: 
        !            71: flag float32_is_nan( float32 a )
        !            72: {
        !            73: 
        !            74:     return ( 0xFF000000 < (bits32) ( a<<1 ) );
        !            75: 
        !            76: }
        !            77: 
        !            78: /*----------------------------------------------------------------------------
        !            79: | Returns 1 if the single-precision floating-point value `a' is a signaling
        !            80: | NaN; otherwise returns 0.
        !            81: *----------------------------------------------------------------------------*/
        !            82: 
        !            83: flag float32_is_signaling_nan( float32 a )
        !            84: {
        !            85: 
        !            86:     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
        !            87: 
        !            88: }
        !            89: 
        !            90: /*----------------------------------------------------------------------------
        !            91: | Returns the result of converting the single-precision floating-point NaN
        !            92: | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
        !            93: | exception is raised.
        !            94: *----------------------------------------------------------------------------*/
        !            95: 
        !            96: static commonNaNT float32ToCommonNaN( float32 a STATUS_PARAM )
        !            97: {
        !            98:     commonNaNT z;
        !            99: 
        !           100:     if ( float32_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR );
        !           101:     z.sign = a>>31;
        !           102:     z.low = 0;
        !           103:     z.high = ( (bits64) a )<<41;
        !           104:     return z;
        !           105: 
        !           106: }
        !           107: 
        !           108: /*----------------------------------------------------------------------------
        !           109: | Returns the result of converting the canonical NaN `a' to the single-
        !           110: | precision floating-point format.
        !           111: *----------------------------------------------------------------------------*/
        !           112: 
        !           113: static float32 commonNaNToFloat32( commonNaNT a )
        !           114: {
        !           115: 
        !           116:     return ( ( (bits32) a.sign )<<31 ) | 0x7FC00000 | ( a.high>>41 );
        !           117: 
        !           118: }
        !           119: 
        !           120: /*----------------------------------------------------------------------------
        !           121: | Takes two single-precision floating-point values `a' and `b', one of which
        !           122: | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
        !           123: | signaling NaN, the invalid exception is raised.
        !           124: *----------------------------------------------------------------------------*/
        !           125: 
        !           126: static float32 propagateFloat32NaN( float32 a, float32 b STATUS_PARAM)
        !           127: {
        !           128:     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
        !           129: 
        !           130:     aIsNaN = float32_is_nan( a );
        !           131:     aIsSignalingNaN = float32_is_signaling_nan( a );
        !           132:     bIsNaN = float32_is_nan( b );
        !           133:     bIsSignalingNaN = float32_is_signaling_nan( b );
        !           134:     a |= 0x00400000;
        !           135:     b |= 0x00400000;
        !           136:     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
        !           137:     if ( aIsSignalingNaN ) {
        !           138:         if ( bIsSignalingNaN ) goto returnLargerSignificand;
        !           139:         return bIsNaN ? b : a;
        !           140:     }
        !           141:     else if ( aIsNaN ) {
        !           142:         if ( bIsSignalingNaN | ! bIsNaN ) return a;
        !           143:  returnLargerSignificand:
        !           144:         if ( (bits32) ( a<<1 ) < (bits32) ( b<<1 ) ) return b;
        !           145:         if ( (bits32) ( b<<1 ) < (bits32) ( a<<1 ) ) return a;
        !           146:         return ( a < b ) ? a : b;
        !           147:     }
        !           148:     else {
        !           149:         return b;
        !           150:     }
        !           151: 
        !           152: }
        !           153: 
        !           154: /*----------------------------------------------------------------------------
        !           155: | The pattern for a default generated double-precision NaN.
        !           156: *----------------------------------------------------------------------------*/
        !           157: #define float64_default_nan LIT64( 0xFFF8000000000000 )
        !           158: 
        !           159: /*----------------------------------------------------------------------------
        !           160: | Returns 1 if the double-precision floating-point value `a' is a NaN;
        !           161: | otherwise returns 0.
        !           162: *----------------------------------------------------------------------------*/
        !           163: 
        !           164: flag float64_is_nan( float64 a )
        !           165: {
        !           166: 
        !           167:     return ( LIT64( 0xFFE0000000000000 ) < (bits64) ( a<<1 ) );
        !           168: 
        !           169: }
        !           170: 
        !           171: /*----------------------------------------------------------------------------
        !           172: | Returns 1 if the double-precision floating-point value `a' is a signaling
        !           173: | NaN; otherwise returns 0.
        !           174: *----------------------------------------------------------------------------*/
        !           175: 
        !           176: flag float64_is_signaling_nan( float64 a )
        !           177: {
        !           178: 
        !           179:     return
        !           180:            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
        !           181:         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
        !           182: 
        !           183: }
        !           184: 
        !           185: /*----------------------------------------------------------------------------
        !           186: | Returns the result of converting the double-precision floating-point NaN
        !           187: | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
        !           188: | exception is raised.
        !           189: *----------------------------------------------------------------------------*/
        !           190: 
        !           191: static commonNaNT float64ToCommonNaN( float64 a STATUS_PARAM)
        !           192: {
        !           193:     commonNaNT z;
        !           194: 
        !           195:     if ( float64_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
        !           196:     z.sign = a>>63;
        !           197:     z.low = 0;
        !           198:     z.high = a<<12;
        !           199:     return z;
        !           200: 
        !           201: }
        !           202: 
        !           203: /*----------------------------------------------------------------------------
        !           204: | Returns the result of converting the canonical NaN `a' to the double-
        !           205: | precision floating-point format.
        !           206: *----------------------------------------------------------------------------*/
        !           207: 
        !           208: static float64 commonNaNToFloat64( commonNaNT a )
        !           209: {
        !           210: 
        !           211:     return
        !           212:           ( ( (bits64) a.sign )<<63 )
        !           213:         | LIT64( 0x7FF8000000000000 )
        !           214:         | ( a.high>>12 );
        !           215: 
        !           216: }
        !           217: 
        !           218: /*----------------------------------------------------------------------------
        !           219: | Takes two double-precision floating-point values `a' and `b', one of which
        !           220: | is a NaN, and returns the appropriate NaN result.  If either `a' or `b' is a
        !           221: | signaling NaN, the invalid exception is raised.
        !           222: *----------------------------------------------------------------------------*/
        !           223: 
        !           224: static float64 propagateFloat64NaN( float64 a, float64 b STATUS_PARAM)
        !           225: {
        !           226:     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
        !           227: 
        !           228:     aIsNaN = float64_is_nan( a );
        !           229:     aIsSignalingNaN = float64_is_signaling_nan( a );
        !           230:     bIsNaN = float64_is_nan( b );
        !           231:     bIsSignalingNaN = float64_is_signaling_nan( b );
        !           232:     a |= LIT64( 0x0008000000000000 );
        !           233:     b |= LIT64( 0x0008000000000000 );
        !           234:     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
        !           235:     if ( aIsSignalingNaN ) {
        !           236:         if ( bIsSignalingNaN ) goto returnLargerSignificand;
        !           237:         return bIsNaN ? b : a;
        !           238:     }
        !           239:     else if ( aIsNaN ) {
        !           240:         if ( bIsSignalingNaN | ! bIsNaN ) return a;
        !           241:  returnLargerSignificand:
        !           242:         if ( (bits64) ( a<<1 ) < (bits64) ( b<<1 ) ) return b;
        !           243:         if ( (bits64) ( b<<1 ) < (bits64) ( a<<1 ) ) return a;
        !           244:         return ( a < b ) ? a : b;
        !           245:     }
        !           246:     else {
        !           247:         return b;
        !           248:     }
        !           249: 
        !           250: }
        !           251: 
        !           252: #ifdef FLOATX80
        !           253: 
        !           254: /*----------------------------------------------------------------------------
        !           255: | The pattern for a default generated extended double-precision NaN.  The
        !           256: | `high' and `low' values hold the most- and least-significant bits,
        !           257: | respectively.
        !           258: *----------------------------------------------------------------------------*/
        !           259: #define floatx80_default_nan_high 0xFFFF
        !           260: #define floatx80_default_nan_low  LIT64( 0xC000000000000000 )
        !           261: 
        !           262: /*----------------------------------------------------------------------------
        !           263: | Returns 1 if the extended double-precision floating-point value `a' is a
        !           264: | NaN; otherwise returns 0.
        !           265: *----------------------------------------------------------------------------*/
        !           266: 
        !           267: flag floatx80_is_nan( floatx80 a )
        !           268: {
        !           269: 
        !           270:     return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );
        !           271: 
        !           272: }
        !           273: 
        !           274: /*----------------------------------------------------------------------------
        !           275: | Returns 1 if the extended double-precision floating-point value `a' is a
        !           276: | signaling NaN; otherwise returns 0.
        !           277: *----------------------------------------------------------------------------*/
        !           278: 
        !           279: flag floatx80_is_signaling_nan( floatx80 a )
        !           280: {
        !           281:     bits64 aLow;
        !           282: 
        !           283:     aLow = a.low & ~ LIT64( 0x4000000000000000 );
        !           284:     return
        !           285:            ( ( a.high & 0x7FFF ) == 0x7FFF )
        !           286:         && (bits64) ( aLow<<1 )
        !           287:         && ( a.low == aLow );
        !           288: 
        !           289: }
        !           290: 
        !           291: /*----------------------------------------------------------------------------
        !           292: | Returns the result of converting the extended double-precision floating-
        !           293: | point NaN `a' to the canonical NaN format.  If `a' is a signaling NaN, the
        !           294: | invalid exception is raised.
        !           295: *----------------------------------------------------------------------------*/
        !           296: 
        !           297: static commonNaNT floatx80ToCommonNaN( floatx80 a STATUS_PARAM)
        !           298: {
        !           299:     commonNaNT z;
        !           300: 
        !           301:     if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
        !           302:     z.sign = a.high>>15;
        !           303:     z.low = 0;
        !           304:     z.high = a.low<<1;
        !           305:     return z;
        !           306: 
        !           307: }
        !           308: 
        !           309: /*----------------------------------------------------------------------------
        !           310: | Returns the result of converting the canonical NaN `a' to the extended
        !           311: | double-precision floating-point format.
        !           312: *----------------------------------------------------------------------------*/
        !           313: 
        !           314: static floatx80 commonNaNToFloatx80( commonNaNT a )
        !           315: {
        !           316:     floatx80 z;
        !           317: 
        !           318:     z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );
        !           319:     z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;
        !           320:     return z;
        !           321: 
        !           322: }
        !           323: 
        !           324: /*----------------------------------------------------------------------------
        !           325: | Takes two extended double-precision floating-point values `a' and `b', one
        !           326: | of which is a NaN, and returns the appropriate NaN result.  If either `a' or
        !           327: | `b' is a signaling NaN, the invalid exception is raised.
        !           328: *----------------------------------------------------------------------------*/
        !           329: 
        !           330: static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b STATUS_PARAM)
        !           331: {
        !           332:     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
        !           333: 
        !           334:     aIsNaN = floatx80_is_nan( a );
        !           335:     aIsSignalingNaN = floatx80_is_signaling_nan( a );
        !           336:     bIsNaN = floatx80_is_nan( b );
        !           337:     bIsSignalingNaN = floatx80_is_signaling_nan( b );
        !           338:     a.low |= LIT64( 0xC000000000000000 );
        !           339:     b.low |= LIT64( 0xC000000000000000 );
        !           340:     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
        !           341:     if ( aIsSignalingNaN ) {
        !           342:         if ( bIsSignalingNaN ) goto returnLargerSignificand;
        !           343:         return bIsNaN ? b : a;
        !           344:     }
        !           345:     else if ( aIsNaN ) {
        !           346:         if ( bIsSignalingNaN | ! bIsNaN ) return a;
        !           347:  returnLargerSignificand:
        !           348:         if ( a.low < b.low ) return b;
        !           349:         if ( b.low < a.low ) return a;
        !           350:         return ( a.high < b.high ) ? a : b;
        !           351:     }
        !           352:     else {
        !           353:         return b;
        !           354:     }
        !           355: 
        !           356: }
        !           357: 
        !           358: #endif
        !           359: 
        !           360: #ifdef FLOAT128
        !           361: 
        !           362: /*----------------------------------------------------------------------------
        !           363: | The pattern for a default generated quadruple-precision NaN.  The `high' and
        !           364: | `low' values hold the most- and least-significant bits, respectively.
        !           365: *----------------------------------------------------------------------------*/
        !           366: #define float128_default_nan_high LIT64( 0xFFFF800000000000 )
        !           367: #define float128_default_nan_low  LIT64( 0x0000000000000000 )
        !           368: 
        !           369: /*----------------------------------------------------------------------------
        !           370: | Returns 1 if the quadruple-precision floating-point value `a' is a NaN;
        !           371: | otherwise returns 0.
        !           372: *----------------------------------------------------------------------------*/
        !           373: 
        !           374: flag float128_is_nan( float128 a )
        !           375: {
        !           376: 
        !           377:     return
        !           378:            ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )
        !           379:         && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );
        !           380: 
        !           381: }
        !           382: 
        !           383: /*----------------------------------------------------------------------------
        !           384: | Returns 1 if the quadruple-precision floating-point value `a' is a
        !           385: | signaling NaN; otherwise returns 0.
        !           386: *----------------------------------------------------------------------------*/
        !           387: 
        !           388: flag float128_is_signaling_nan( float128 a )
        !           389: {
        !           390: 
        !           391:     return
        !           392:            ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )
        !           393:         && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );
        !           394: 
        !           395: }
        !           396: 
        !           397: /*----------------------------------------------------------------------------
        !           398: | Returns the result of converting the quadruple-precision floating-point NaN
        !           399: | `a' to the canonical NaN format.  If `a' is a signaling NaN, the invalid
        !           400: | exception is raised.
        !           401: *----------------------------------------------------------------------------*/
        !           402: 
        !           403: static commonNaNT float128ToCommonNaN( float128 a STATUS_PARAM)
        !           404: {
        !           405:     commonNaNT z;
        !           406: 
        !           407:     if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid STATUS_VAR);
        !           408:     z.sign = a.high>>63;
        !           409:     shortShift128Left( a.high, a.low, 16, &z.high, &z.low );
        !           410:     return z;
        !           411: 
        !           412: }
        !           413: 
        !           414: /*----------------------------------------------------------------------------
        !           415: | Returns the result of converting the canonical NaN `a' to the quadruple-
        !           416: | precision floating-point format.
        !           417: *----------------------------------------------------------------------------*/
        !           418: 
        !           419: static float128 commonNaNToFloat128( commonNaNT a )
        !           420: {
        !           421:     float128 z;
        !           422: 
        !           423:     shift128Right( a.high, a.low, 16, &z.high, &z.low );
        !           424:     z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );
        !           425:     return z;
        !           426: 
        !           427: }
        !           428: 
        !           429: /*----------------------------------------------------------------------------
        !           430: | Takes two quadruple-precision floating-point values `a' and `b', one of
        !           431: | which is a NaN, and returns the appropriate NaN result.  If either `a' or
        !           432: | `b' is a signaling NaN, the invalid exception is raised.
        !           433: *----------------------------------------------------------------------------*/
        !           434: 
        !           435: static float128 propagateFloat128NaN( float128 a, float128 b STATUS_PARAM)
        !           436: {
        !           437:     flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;
        !           438: 
        !           439:     aIsNaN = float128_is_nan( a );
        !           440:     aIsSignalingNaN = float128_is_signaling_nan( a );
        !           441:     bIsNaN = float128_is_nan( b );
        !           442:     bIsSignalingNaN = float128_is_signaling_nan( b );
        !           443:     a.high |= LIT64( 0x0000800000000000 );
        !           444:     b.high |= LIT64( 0x0000800000000000 );
        !           445:     if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid STATUS_VAR);
        !           446:     if ( aIsSignalingNaN ) {
        !           447:         if ( bIsSignalingNaN ) goto returnLargerSignificand;
        !           448:         return bIsNaN ? b : a;
        !           449:     }
        !           450:     else if ( aIsNaN ) {
        !           451:         if ( bIsSignalingNaN | ! bIsNaN ) return a;
        !           452:  returnLargerSignificand:
        !           453:         if ( lt128( a.high<<1, a.low, b.high<<1, b.low ) ) return b;
        !           454:         if ( lt128( b.high<<1, b.low, a.high<<1, a.low ) ) return a;
        !           455:         return ( a.high < b.high ) ? a : b;
        !           456:     }
        !           457:     else {
        !           458:         return b;
        !           459:     }
        !           460: 
        !           461: }
        !           462: 
        !           463: #endif
        !           464: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.