Cross Reference: /src/lib/libc/softfloat/bits64/softfloat.c

Lines Matching defs:aSign
1394     flag aSign;
1401     aSign = extractFloat32Sign( a );
1402     if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1408     return roundAndPackInt32( aSign, aSig64 );
1426     flag aSign;
1433     aSign = extractFloat32Sign( a );
1438             if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1451     if ( aSign ) z = - z;
1470     flag aSign;
1477     aSign = extractFloat32Sign( a );
1481         if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1490     return roundAndPackInt64( aSign, aSig64, aSigExtra );
1507     flag aSign;
1515     aSign = extractFloat32Sign( a );
1520             if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1536     if ( aSign ) z = - z;
1552     flag aSign;
1558     aSign = extractFloat32Sign( a );
1561         return packFloat64( aSign, 0x7FF, 0 );
1564         if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1568     return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1584     flag aSign;
1590     aSign = extractFloat32Sign( a );
1593         return packFloatx80( aSign, 0x7FFF, 0 );
1596         if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1600     return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1618     flag aSign;
1624     aSign = extractFloat32Sign( a );
1627         return packFloat128( aSign, 0x7FFF, 0, 0 );
1630         if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1634     return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1651     flag aSign;
1667         aSign = extractFloat32Sign( a );
1671                 return packFloat32( aSign, 0x7F, 0 );
1677             return aSign ? 0xBF800000 : 0;
1679             return aSign ? 0x80000000 : 0x3F800000;
1681         return packFloat32( aSign, 0, 0 );
1861     flag aSign, bSign;
1863     aSign = extractFloat32Sign( a );
1865     if ( aSign == bSign ) {
1866         return addFloat32Sigs( a, b, aSign );
1869         return subFloat32Sigs( a, b, aSign );
1883     flag aSign, bSign;
1885     aSign = extractFloat32Sign( a );
1887     if ( aSign == bSign ) {
1888         return subFloat32Sigs( a, b, aSign );
1891         return addFloat32Sigs( a, b, aSign );
1905     flag aSign, bSign, zSign;
1913     aSign = extractFloat32Sign( a );
1917     zSign = aSign ^ bSign;
1966     flag aSign, bSign, zSign;
1972     aSign = extractFloat32Sign( a );
1976     zSign = aSign ^ bSign;
2030     flag aSign, bSign, zSign;
2040     aSign = extractFloat32Sign( a );
2118     return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2133     flag aSign;
2140     aSign = extractFloat32Sign( a );
2143         if ( ! aSign ) return a;
2147     if ( aSign ) {
2212     flag aSign, bSign;
2220     aSign = extractFloat32Sign( a );
2222     if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
2223     return ( a == b ) || ( aSign ^ ( a < b ) );
2236     flag aSign, bSign;
2244     aSign = extractFloat32Sign( a );
2246     if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
2247     return ( a != b ) && ( aSign ^ ( a < b ) );
2283     flag aSign, bSign;
2293     aSign = extractFloat32Sign( a );
2295     if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
2296     return ( a == b ) || ( aSign ^ ( a < b ) );
2310     flag aSign, bSign;
2320     aSign = extractFloat32Sign( a );
2322     if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
2323     return ( a != b ) && ( aSign ^ ( a < b ) );
2342     flag aSign;
2348     aSign = extractFloat64Sign( a );
2349     if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2353     return roundAndPackInt32( aSign, aSig );
2371     flag aSign;
2378     aSign = extractFloat64Sign( a );
2380         if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2392     if ( aSign ) z = - z;
2393     if ( ( z < 0 ) ^ aSign ) {
2396         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
2419     flag aSign;
2425     aSign = extractFloat64Sign( a );
2431             if (    ! aSign
2445     return roundAndPackInt64( aSign, aSig, aSigExtra );
2462     flag aSign;
2469     aSign = extractFloat64Sign( a );
2476                 if (    ! aSign
2497     if ( aSign ) z = - z;
2513     flag aSign;
2520     aSign = extractFloat64Sign( a );
2523         return packFloat32( aSign, 0xFF, 0 );
2531     return roundAndPackFloat32( aSign, aExp, zSig );
2547     flag aSign;
2553     aSign = extractFloat64Sign( a );
2556         return packFloatx80( aSign, 0x7FFF, 0 );
2559         if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2564             aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2582     flag aSign;
2588     aSign = extractFloat64Sign( a );
2591         return packFloat128( aSign, 0x7FFF, 0, 0 );
2594         if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2599     return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );
2616     flag aSign;
2632         aSign = extractFloat64Sign( a );
2636                 return packFloat64( aSign, 0x3FF, 0 );
2642             return aSign ? LIT64( 0xBFF0000000000000 ) : 0;
2645             aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 );
2647         return packFloat64( aSign, 0, 0 );
2827     flag aSign, bSign;
2829     aSign = extractFloat64Sign( a );
2831     if ( aSign == bSign ) {
2832         return addFloat64Sigs( a, b, aSign );
2835         return subFloat64Sigs( a, b, aSign );
2849     flag aSign, bSign;
2851     aSign = extractFloat64Sign( a );
2853     if ( aSign == bSign ) {
2854         return subFloat64Sigs( a, b, aSign );
2857         return addFloat64Sigs( a, b, aSign );
2871     flag aSign, bSign, zSign;
2877     aSign = extractFloat64Sign( a );
2881     zSign = aSign ^ bSign;
2930     flag aSign, bSign, zSign;
2938     aSign = extractFloat64Sign( a );
2942     zSign = aSign ^ bSign;
3002     flag aSign, bSign, zSign;
3010     aSign = extractFloat64Sign( a );
3075     return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3088     flag aSign;
3095     aSign = extractFloat64Sign( a );
3098         if ( ! aSign ) return a;
3102     if ( aSign ) {
3165     flag aSign, bSign;
3173     aSign = extractFloat64Sign( a );
3175     if ( aSign != bSign )
3176 	return aSign ||
3180 	( aSign ^ ( FLOAT64_DEMANGLE(a) < FLOAT64_DEMANGLE(b) ) );
3193     flag aSign, bSign;
3201     aSign = extractFloat64Sign( a );
3203     if ( aSign != bSign )
3204 	return aSign &&
3208 	( aSign ^ ( FLOAT64_DEMANGLE(a) < FLOAT64_DEMANGLE(b) ) );
3244     flag aSign, bSign;
3254     aSign = extractFloat64Sign( a );
3256     if ( aSign != bSign ) return aSign || ( (bits64) ( ( a | b )<<1 ) == 0 );
3257     return ( a == b ) || ( aSign ^ ( a < b ) );
3271     flag aSign, bSign;
3281     aSign = extractFloat64Sign( a );
3283     if ( aSign != bSign ) return aSign && ( (bits64) ( ( a | b )<<1 ) != 0 );
3284     return ( a != b ) && ( aSign ^ ( a < b ) );
3344     flag aSign;
3350     aSign = extractFloatx80Sign( a );
3351     if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3355     return roundAndPackInt32( aSign, aSig );
3372     flag aSign;
3379     aSign = extractFloatx80Sign( a );
3381         if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3392     if ( aSign ) z = - z;
3393     if ( ( z < 0 ) ^ aSign ) {
3396         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
3418     flag aSign;
3424     aSign = extractFloatx80Sign( a );
3429             if (    ! aSign
3442     return roundAndPackInt64( aSign, aSig, aSigExtra );
3459     flag aSign;
3466     aSign = extractFloatx80Sign( a );
3472             if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3486     if ( aSign ) z = - z;
3501     flag aSign;
3507     aSign = extractFloatx80Sign( a );
3512         return packFloat32( aSign, 0xFF, 0 );
3516     return roundAndPackFloat32( aSign, aExp, aSig );
3530     flag aSign;
3536     aSign = extractFloatx80Sign( a );
3541         return packFloat64( aSign, 0x7FF, 0 );
3545     return roundAndPackFloat64( aSign, aExp, zSig );
3561     flag aSign;
3567     aSign = extractFloatx80Sign( a );
3572     return packFloat128( aSign, aExp, zSig0, zSig1 );
3588     flag aSign;
3607         aSign = extractFloatx80Sign( a );
3613                     packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3620                   aSign ?
3625                   aSign ? packFloatx80( 1, 0, 0 )
3628         return packFloatx80( aSign, 0, 0 );
3801     flag aSign, bSign;
3803     aSign = extractFloatx80Sign( a );
3805     if ( aSign == bSign ) {
3806         return addFloatx80Sigs( a, b, aSign );
3809         return subFloatx80Sigs( a, b, aSign );
3823     flag aSign, bSign;
3825     aSign = extractFloatx80Sign( a );
3827     if ( aSign == bSign ) {
3828         return subFloatx80Sigs( a, b, aSign );
3831         return addFloatx80Sigs( a, b, aSign );
3845     flag aSign, bSign, zSign;
3852     aSign = extractFloatx80Sign( a );
3856     zSign = aSign ^ bSign;
3905     flag aSign, bSign, zSign;
3913     aSign = extractFloatx80Sign( a );
3917     zSign = aSign ^ bSign;
3986     flag aSign, zSign;
3994     aSign = extractFloatx80Sign( a );
4024     zSign = aSign;
4084     flag aSign;
4092     aSign = extractFloatx80Sign( a );
4095         if ( ! aSign ) return a;
4098     if ( aSign ) {
4187     flag aSign, bSign;
4197     aSign = extractFloatx80Sign( a );
4199     if ( aSign != bSign ) {
4201                aSign
4206           aSign ? le128( b.high>>X80SHIFT, b.low, a.high>>X80SHIFT, a.low )
4221     flag aSign, bSign;
4231     aSign = extractFloatx80Sign( a );
4233     if ( aSign != bSign ) {
4235                aSign
4240           aSign ? lt128( b.high>>X80SHIFT, b.low, a.high>>X80SHIFT, a.low )
4283     flag aSign, bSign;
4296     aSign = extractFloatx80Sign( a );
4298     if ( aSign != bSign ) {
4300                aSign
4305           aSign ? le128( b.high>>X80SHIFT, b.low, a.high>>X80SHIFT, a.low )
4320     flag aSign, bSign;
4333     aSign = extractFloatx80Sign( a );
4335     if ( aSign != bSign ) {
4337                aSign
4342           aSign ? lt128( b.high>>X80SHIFT, b.low, a.high>>X80SHIFT, a.low )
4364     flag aSign;
4371     aSign = extractFloat128Sign( a );
4372     if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
4377     return roundAndPackInt32( aSign, aSig0 );
4394     flag aSign;
4402     aSign = extractFloat128Sign( a );
4405         if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
4417     if ( aSign ) z = - z;
4418     if ( ( z < 0 ) ^ aSign ) {
4421         return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
4443     flag aSign;
4450     aSign = extractFloat128Sign( a );
4456             if (    ! aSign
4470     return roundAndPackInt64( aSign, aSig0, aSig1 );
4487     flag aSign;
4495     aSign = extractFloat128Sign( a );
4507                 if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
4531     if ( aSign ) z = - z;
4543     flag aSign;
4551     aSign = extractFloat128Sign( a );
4583     if ( aSign ) z = - z;
4599     flag aSign;
4607     aSign = extractFloat128Sign( a );
4612         return packFloat32( aSign, 0xFF, 0 );
4621     return roundAndPackFloat32( aSign, aExp, zSig );
4635     flag aSign;
4642     aSign = extractFloat128Sign( a );
4647         return packFloat64( aSign, 0x7FF, 0 );
4655     return roundAndPackFloat64( aSign, aExp, aSig0 );
4671     flag aSign;
4678     aSign = extractFloat128Sign( a );
4683         return packFloatx80( aSign, 0x7FFF, 0 );
4686         if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
4693     return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 );
4709     flag aSign;
4754             aSign = extractFloat128Sign( a );
4761                     return packFloat128( aSign, 0x3FFF, 0, 0 );
4768                       aSign ? packFloat128( 1, 0x3FFF, 0, 0 )
4772                       aSign ? packFloat128( 1, 0, 0, 0 )
4775             return packFloat128( aSign, 0, 0, 0 );
4978     flag aSign, bSign;
4980     aSign = extractFloat128Sign( a );
4982     if ( aSign == bSign ) {
4983         return addFloat128Sigs( a, b, aSign );
4986         return subFloat128Sigs( a, b, aSign );
5000     flag aSign, bSign;
5002     aSign = extractFloat128Sign( a );
5004     if ( aSign == bSign ) {
5005         return subFloat128Sigs( a, b, aSign );
5008         return addFloat128Sigs( a, b, aSign );
5022     flag aSign, bSign, zSign;
5030     aSign = extractFloat128Sign( a );
5035     zSign = aSign ^ bSign;
5087     flag aSign, bSign, zSign;
5096     aSign = extractFloat128Sign( a );
5101     zSign = aSign ^ bSign;
5172     flag aSign, zSign;
5182     aSign = extractFloat128Sign( a );
5269         normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 );
5282     flag aSign;
5291     aSign = extractFloat128Sign( a );
5294         if ( ! aSign ) return a;
5297     if ( aSign ) {
5383     flag aSign, bSign;
5393     aSign = extractFloat128Sign( a );
5395     if ( aSign != bSign ) {
5397                aSign
5402           aSign ? le128( b.high, b.low, a.high, a.low )
5416     flag aSign, bSign;
5426     aSign = extractFloat128Sign( a );
5428     if ( aSign != bSign ) {
5430                aSign
5435           aSign ? lt128( b.high, b.low, a.high, a.low )
5478     flag aSign, bSign;
5491     aSign = extractFloat128Sign( a );
5493     if ( aSign != bSign ) {
5495                aSign
5500           aSign ? le128( b.high, b.low, a.high, a.low )
5515     flag aSign, bSign;
5528     aSign = extractFloat128Sign( a );
5530     if ( aSign != bSign ) {
5532                aSign
5537           aSign ? lt128( b.high, b.low, a.high, a.low )
5570     flag aSign;
5577     aSign = extractFloat64Sign( a );
5579     if (aSign) {
5616     flag aSign;
5623     aSign = extractFloat32Sign( a );
5626     if (aSign) {