*/static float64 propagateFloat64NaN( float64 a, float64 b ){    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;    aIsNaN = float64_is_nan( a );    aIsSignalingNaN = float64_is_signaling_nan( a );    bIsNaN = float64_is_nan( b );    bIsSignalingNaN = float64_is_signaling_nan( b );    a |= LIT64( 0x0008000000000000 );    b |= LIT64( 0x0008000000000000 );    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );    if ( aIsNaN ) {        return ( aIsSignalingNaN & bIsNaN ) ? b : a;    }    else {        return b;    }}#ifdef FLOATX80/*-------------------------------------------------------------------------------The pattern for a default generated extended double-precision NaN.  The`high' and `low' values hold the most- and least-significant bits,respectively.-------------------------------------------------------------------------------*/#define floatx80_default_nan_high 0xFFFF#define floatx80_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )/*-------------------------------------------------------------------------------Returns 1 if the extended double-precision floating-point value `a' is aNaN; otherwise returns 0.-------------------------------------------------------------------------------*/flag floatx80_is_nan( floatx80 a ){    return ( ( a.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( a.low<<1 );}/*-------------------------------------------------------------------------------Returns 1 if the extended double-precision floating-point value `a' is asignaling NaN; otherwise returns 0.-------------------------------------------------------------------------------*/flag floatx80_is_signaling_nan( floatx80 a ){    //register int lr;    bits64 aLow;    //__asm__("mov %0, lr" : : "g" (lr));    //fp_printk("floatx80_is_signalling_nan() called from 0x%08x\n",lr);    aLow = a.low & ~ LIT64( 0x4000000000000000 );    return           ( ( a.high & 0x7FFF ) == 0x7FFF )        && (bits64) ( aLow<<1 )        && ( a.low == aLow );}/*-------------------------------------------------------------------------------Returns the result of converting the extended double-precision floating-point NaN `a' to the canonical NaN format.  If `a' is a signaling NaN, theinvalid exception is raised.-------------------------------------------------------------------------------*/static commonNaNT floatx80ToCommonNaN( floatx80 a ){    commonNaNT z;    if ( floatx80_is_signaling_nan( a ) ) float_raise( float_flag_invalid );    z.sign = a.high>>15;    z.low = 0;    z.high = a.low<<1;    return z;}/*-------------------------------------------------------------------------------Returns the result of converting the canonical NaN `a' to the extendeddouble-precision floating-point format.-------------------------------------------------------------------------------*/static floatx80 commonNaNToFloatx80( commonNaNT a ){    floatx80 z;    z.low = LIT64( 0xC000000000000000 ) | ( a.high>>1 );    z.high = ( ( (bits16) a.sign )<<15 ) | 0x7FFF;    return z;}/*-------------------------------------------------------------------------------Takes two extended double-precision floating-point values `a' and `b', oneof which is a NaN, and returns the appropriate NaN result.  If either `a' or`b' is a signaling NaN, the invalid exception is raised.-------------------------------------------------------------------------------*/static floatx80 propagateFloatx80NaN( floatx80 a, floatx80 b ){    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;    aIsNaN = floatx80_is_nan( a );    aIsSignalingNaN = floatx80_is_signaling_nan( a );    bIsNaN = floatx80_is_nan( b );    bIsSignalingNaN = floatx80_is_signaling_nan( b );    a.low |= LIT64( 0xC000000000000000 );    b.low |= LIT64( 0xC000000000000000 );    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );    if ( aIsNaN ) {        return ( aIsSignalingNaN & bIsNaN ) ? b : a;    }    else {        return b;    }}#endif#ifdef FLOAT128/*-------------------------------------------------------------------------------The pattern for a default generated quadruple-precision NaN.  The `high' and`low' values hold the most- and least-significant bits, respectively.-------------------------------------------------------------------------------*/#define float128_default_nan_high LIT64( 0xFFFFFFFFFFFFFFFF )#define float128_default_nan_low  LIT64( 0xFFFFFFFFFFFFFFFF )/*-------------------------------------------------------------------------------Returns 1 if the quadruple-precision floating-point value `a' is a NaN;otherwise returns 0.-------------------------------------------------------------------------------*/flag float128_is_nan( float128 a ){    return           ( LIT64( 0xFFFE000000000000 ) <= (bits64) ( a.high<<1 ) )        && ( a.low || ( a.high & LIT64( 0x0000FFFFFFFFFFFF ) ) );}/*-------------------------------------------------------------------------------Returns 1 if the quadruple-precision floating-point value `a' is asignaling NaN; otherwise returns 0.-------------------------------------------------------------------------------*/flag float128_is_signaling_nan( float128 a ){    return           ( ( ( a.high>>47 ) & 0xFFFF ) == 0xFFFE )        && ( a.low || ( a.high & LIT64( 0x00007FFFFFFFFFFF ) ) );}/*-------------------------------------------------------------------------------Returns the result of converting the quadruple-precision floating-point NaN`a' to the canonical NaN format.  If `a' is a signaling NaN, the invalidexception is raised.-------------------------------------------------------------------------------*/static commonNaNT float128ToCommonNaN( float128 a ){    commonNaNT z;    if ( float128_is_signaling_nan( a ) ) float_raise( float_flag_invalid );    z.sign = a.high>>63;    shortShift128Left( a.high, a.low, 16, &z.high, &z.low );    return z;}/*-------------------------------------------------------------------------------Returns the result of converting the canonical NaN `a' to the quadruple-precision floating-point format.-------------------------------------------------------------------------------*/static float128 commonNaNToFloat128( commonNaNT a ){    float128 z;    shift128Right( a.high, a.low, 16, &z.high, &z.low );    z.high |= ( ( (bits64) a.sign )<<63 ) | LIT64( 0x7FFF800000000000 );    return z;}/*-------------------------------------------------------------------------------Takes two quadruple-precision floating-point values `a' and `b', one ofwhich is a NaN, and returns the appropriate NaN result.  If either `a' or`b' is a signaling NaN, the invalid exception is raised.-------------------------------------------------------------------------------*/static float128 propagateFloat128NaN( float128 a, float128 b ){    flag aIsNaN, aIsSignalingNaN, bIsNaN, bIsSignalingNaN;    aIsNaN = float128_is_nan( a );    aIsSignalingNaN = float128_is_signaling_nan( a );    bIsNaN = float128_is_nan( b );    bIsSignalingNaN = float128_is_signaling_nan( b );    a.high |= LIT64( 0x0000800000000000 );    b.high |= LIT64( 0x0000800000000000 );    if ( aIsSignalingNaN | bIsSignalingNaN ) float_raise( float_flag_invalid );    if ( aIsNaN ) {        return ( aIsSignalingNaN & bIsNaN ) ? b : a;    }    else {        return b;    }}#endif