Lines Matching refs:aSign
1368 flag aSign;
1376 aSign = extractFloat32Sign( a );
1377 if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1383 return roundAndPackInt32( aSign, aSig64 STATUS_VAR );
1399 flag aSign;
1407 aSign = extractFloat32Sign( a );
1412 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1425 if ( aSign ) z = - z;
1442 flag aSign;
1449 aSign = extractFloat32Sign( a );
1454 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1472 if ( aSign ) {
1491 flag aSign;
1499 aSign = extractFloat32Sign( a );
1503 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1512 return roundAndPackInt64( aSign, aSig64, aSigExtra STATUS_VAR );
1528 flag aSign;
1537 aSign = extractFloat32Sign( a );
1542 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1558 if ( aSign ) z = - z;
1572 flag aSign;
1579 aSign = extractFloat32Sign( a );
1582 return packFloat64( aSign, 0x7FF, 0 );
1585 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1589 return packFloat64( aSign, aExp + 0x380, ( (uint64_t) aSig )<<29 );
1604 flag aSign;
1611 aSign = extractFloat32Sign( a );
1614 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
1617 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1621 return packFloatx80( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<40 );
1638 flag aSign;
1645 aSign = extractFloat32Sign( a );
1648 return packFloat128( aSign, 0x7FFF, 0, 0 );
1651 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1655 return packFloat128( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<25, 0 );
1670 flag aSign;
1687 aSign = extractFloat32Sign( a );
1691 return packFloat32( aSign, 0x7F, 0 );
1695 return make_float32(aSign ? 0xBF800000 : 0);
1697 return make_float32(aSign ? 0x80000000 : 0x3F800000);
1699 return packFloat32( aSign, 0, 0 );
1883 flag aSign, bSign;
1887 aSign = extractFloat32Sign( a );
1889 if ( aSign == bSign ) {
1890 return addFloat32Sigs( a, b, aSign STATUS_VAR);
1893 return subFloat32Sigs( a, b, aSign STATUS_VAR );
1906 flag aSign, bSign;
1910 aSign = extractFloat32Sign( a );
1912 if ( aSign == bSign ) {
1913 return subFloat32Sigs( a, b, aSign STATUS_VAR );
1916 return addFloat32Sigs( a, b, aSign STATUS_VAR );
1929 flag aSign, bSign, zSign;
1940 aSign = extractFloat32Sign( a );
1944 zSign = aSign ^ bSign;
1992 flag aSign, bSign, zSign;
2000 aSign = extractFloat32Sign( a );
2004 zSign = aSign ^ bSign;
2056 flag aSign, zSign;
2068 aSign = extractFloat32Sign( a );
2145 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR );
2157 flag aSign;
2165 aSign = extractFloat32Sign( a );
2168 if ( ! aSign ) return a;
2172 if ( aSign ) {
2243 flag aSign;
2252 aSign = extractFloat32Sign( a );
2256 return (aSign) ? float32_zero : a;
2291 flag aSign, zSign;
2298 aSign = extractFloat32Sign( a );
2304 if ( aSign ) {
2365 flag aSign, bSign;
2376 aSign = extractFloat32Sign( a );
2380 if ( aSign != bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
2381 return ( av == bv ) || ( aSign ^ ( av < bv ) );
2394 flag aSign, bSign;
2405 aSign = extractFloat32Sign( a );
2409 if ( aSign != bSign ) return aSign && ( (uint32_t) ( ( av | bv )<<1 ) != 0 );
2410 return ( av != bv ) && ( aSign ^ ( av < bv ) );
2468 flag aSign, bSign;
2481 aSign = extractFloat32Sign( a );
2485 if ( aSign != bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<1 ) == 0 );
2486 return ( av == bv ) || ( aSign ^ ( av < bv ) );
2499 flag aSign, bSign;
2512 aSign = extractFloat32Sign( a );
2516 if ( aSign != bSign ) return aSign && ( (uint32_t) ( ( av | bv )<<1 ) != 0 );
2517 return ( av != bv ) && ( aSign ^ ( av < bv ) );
2556 flag aSign;
2563 aSign = extractFloat64Sign( a );
2564 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2568 return roundAndPackInt32( aSign, aSig STATUS_VAR );
2584 flag aSign;
2592 aSign = extractFloat64Sign( a );
2594 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2606 if ( aSign ) z = - z;
2607 if ( ( z < 0 ) ^ aSign ) {
2610 return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
2631 flag aSign;
2638 aSign = extractFloat64Sign( a );
2641 aSign = 0;
2656 if ( aSign ) {
2659 if ( ( (int16_t)z < 0 ) ^ aSign ) {
2662 return aSign ? (int32_t) 0xffff8000 : 0x7FFF;
2682 flag aSign;
2689 aSign = extractFloat64Sign( a );
2695 if ( ! aSign
2709 return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
2725 flag aSign;
2733 aSign = extractFloat64Sign( a );
2740 if ( ! aSign
2761 if ( aSign ) z = - z;
2775 flag aSign;
2783 aSign = extractFloat64Sign( a );
2786 return packFloat32( aSign, 0xFF, 0 );
2794 return roundAndPackFloat32( aSign, aExp, zSig STATUS_VAR );
2820 flag aSign;
2824 aSign = extractFloat16Sign(a);
2832 return packFloat32(aSign, 0xff, aSig << 13);
2838 return packFloat32(aSign, 0, 0);
2845 return packFloat32( aSign, aExp + 0x70, aSig << 13);
2850 flag aSign;
2860 aSign = extractFloat32Sign( a );
2866 return packFloat16(aSign, 0, 0);
2873 return packFloat16(aSign, 0x1f, 0x3ff);
2875 return packFloat16(aSign, 0x1f, 0);
2878 return packFloat16(aSign, 0, 0);
2902 increment = aSign ? 0 : mask;
2905 increment = aSign ? mask : 0;
2924 return packFloat16(aSign, 0x1f, 0);
2929 return packFloat16(aSign, 0x1f, 0x3ff);
2933 return packFloat16(aSign, 0, 0);
2939 return packFloat16(aSign, aExp + 14, aSig >> 13);
2953 flag aSign;
2960 aSign = extractFloat64Sign( a );
2963 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2966 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2971 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2988 flag aSign;
2995 aSign = extractFloat64Sign( a );
2998 return packFloat128( aSign, 0x7FFF, 0, 0 );
3001 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
3006 return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );
3021 flag aSign;
3038 aSign = extractFloat64Sign( a );
3042 return packFloat64( aSign, 0x3FF, 0 );
3046 return make_float64(aSign ? LIT64( 0xBFF0000000000000 ) : 0);
3049 aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 ));
3051 return packFloat64( aSign, 0, 0 );
3247 flag aSign, bSign;
3251 aSign = extractFloat64Sign( a );
3253 if ( aSign == bSign ) {
3254 return addFloat64Sigs( a, b, aSign STATUS_VAR );
3257 return subFloat64Sigs( a, b, aSign STATUS_VAR );
3270 flag aSign, bSign;
3274 aSign = extractFloat64Sign( a );
3276 if ( aSign == bSign ) {
3277 return subFloat64Sigs( a, b, aSign STATUS_VAR );
3280 return addFloat64Sigs( a, b, aSign STATUS_VAR );
3293 flag aSign, bSign, zSign;
3302 aSign = extractFloat64Sign( a );
3306 zSign = aSign ^ bSign;
3354 flag aSign, bSign, zSign;
3364 aSign = extractFloat64Sign( a );
3368 zSign = aSign ^ bSign;
3426 flag aSign, zSign;
3436 aSign = extractFloat64Sign( a );
3500 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR );
3512 flag aSign;
3520 aSign = extractFloat64Sign( a );
3523 if ( ! aSign ) return a;
3527 if ( aSign ) {
3563 flag aSign, zSign;
3570 aSign = extractFloat64Sign( a );
3576 if ( aSign ) {
3637 flag aSign, bSign;
3648 aSign = extractFloat64Sign( a );
3652 if ( aSign != bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
3653 return ( av == bv ) || ( aSign ^ ( av < bv ) );
3666 flag aSign, bSign;
3677 aSign = extractFloat64Sign( a );
3681 if ( aSign != bSign ) return aSign && ( (uint64_t) ( ( av | bv )<<1 ) != 0 );
3682 return ( av != bv ) && ( aSign ^ ( av < bv ) );
3743 flag aSign, bSign;
3756 aSign = extractFloat64Sign( a );
3760 if ( aSign != bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<1 ) == 0 );
3761 return ( av == bv ) || ( aSign ^ ( av < bv ) );
3774 flag aSign, bSign;
3787 aSign = extractFloat64Sign( a );
3791 if ( aSign != bSign ) return aSign && ( (uint64_t) ( ( av | bv )<<1 ) != 0 );
3792 return ( av != bv ) && ( aSign ^ ( av < bv ) );
3833 flag aSign;
3839 aSign = extractFloatx80Sign( a );
3840 if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
3844 return roundAndPackInt32( aSign, aSig STATUS_VAR );
3860 flag aSign;
3867 aSign = extractFloatx80Sign( a );
3869 if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
3880 if ( aSign ) z = - z;
3881 if ( ( z < 0 ) ^ aSign ) {
3884 return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
3905 flag aSign;
3911 aSign = extractFloatx80Sign( a );
3916 if ( ! aSign
3929 return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
3945 flag aSign;
3952 aSign = extractFloatx80Sign( a );
3958 if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3972 if ( aSign ) z = - z;
3986 flag aSign;
3992 aSign = extractFloatx80Sign( a );
3997 return packFloat32( aSign, 0xFF, 0 );
4001 return roundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
4014 flag aSign;
4020 aSign = extractFloatx80Sign( a );
4025 return packFloat64( aSign, 0x7FF, 0 );
4029 return roundAndPackFloat64( aSign, aExp, zSig STATUS_VAR );
4044 flag aSign;
4050 aSign = extractFloatx80Sign( a );
4055 return packFloat128( aSign, aExp, zSig0, zSig1 );
4070 flag aSign;
4089 aSign = extractFloatx80Sign( a );
4095 packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
4100 aSign ?
4105 aSign ? packFloatx80( 1, 0, 0 )
4108 return packFloatx80( aSign, 0, 0 );
4276 flag aSign, bSign;
4278 aSign = extractFloatx80Sign( a );
4280 if ( aSign == bSign ) {
4281 return addFloatx80Sigs( a, b, aSign STATUS_VAR );
4284 return subFloatx80Sigs( a, b, aSign STATUS_VAR );
4297 flag aSign, bSign;
4299 aSign = extractFloatx80Sign( a );
4301 if ( aSign == bSign ) {
4302 return subFloatx80Sigs( a, b, aSign STATUS_VAR );
4305 return addFloatx80Sigs( a, b, aSign STATUS_VAR );
4318 flag aSign, bSign, zSign;
4325 aSign = extractFloatx80Sign( a );
4329 zSign = aSign ^ bSign;
4377 flag aSign, bSign, zSign;
4385 aSign = extractFloatx80Sign( a );
4389 zSign = aSign ^ bSign;
4457 flag aSign, zSign;
4465 aSign = extractFloatx80Sign( a );
4494 zSign = aSign;
4553 flag aSign;
4561 aSign = extractFloatx80Sign( a );
4564 if ( ! aSign ) return a;
4567 if ( aSign ) {
4652 flag aSign, bSign;
4662 aSign = extractFloatx80Sign( a );
4664 if ( aSign != bSign ) {
4666 aSign
4671 aSign ? le128( b.high, b.low, a.high, a.low )
4685 flag aSign, bSign;
4695 aSign = extractFloatx80Sign( a );
4697 if ( aSign != bSign ) {
4699 aSign
4704 aSign ? lt128( b.high, b.low, a.high, a.low )
4767 flag aSign, bSign;
4780 aSign = extractFloatx80Sign( a );
4782 if ( aSign != bSign ) {
4784 aSign
4789 aSign ? le128( b.high, b.low, a.high, a.low )
4803 flag aSign, bSign;
4816 aSign = extractFloatx80Sign( a );
4818 if ( aSign != bSign ) {
4820 aSign
4825 aSign ? lt128( b.high, b.low, a.high, a.low )
4868 flag aSign;
4875 aSign = extractFloat128Sign( a );
4876 if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
4881 return roundAndPackInt32( aSign, aSig0 STATUS_VAR );
4897 flag aSign;
4905 aSign = extractFloat128Sign( a );
4908 if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
4920 if ( aSign ) z = - z;
4921 if ( ( z < 0 ) ^ aSign ) {
4924 return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
4945 flag aSign;
4952 aSign = extractFloat128Sign( a );
4958 if ( ! aSign
4972 return roundAndPackInt64( aSign, aSig0, aSig1 STATUS_VAR );
4988 flag aSign;
4996 aSign = extractFloat128Sign( a );
5008 if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
5032 if ( aSign ) z = - z;
5046 flag aSign;
5054 aSign = extractFloat128Sign( a );
5059 return packFloat32( aSign, 0xFF, 0 );
5068 return roundAndPackFloat32( aSign, aExp, zSig STATUS_VAR );
5081 flag aSign;
5088 aSign = extractFloat128Sign( a );
5093 return packFloat64( aSign, 0x7FF, 0 );
5101 return roundAndPackFloat64( aSign, aExp, aSig0 STATUS_VAR );
5116 flag aSign;
5123 aSign = extractFloat128Sign( a );
5128 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
5131 if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
5138 return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 STATUS_VAR );
5153 flag aSign;
5198 aSign = extractFloat128Sign( a );
5205 return packFloat128( aSign, 0x3FFF, 0, 0 );
5210 aSign ? packFloat128( 1, 0x3FFF, 0, 0 )
5214 aSign ? packFloat128( 1, 0, 0, 0 )
5217 return packFloat128( aSign, 0, 0, 0 );
5425 flag aSign, bSign;
5427 aSign = extractFloat128Sign( a );
5429 if ( aSign == bSign ) {
5430 return addFloat128Sigs( a, b, aSign STATUS_VAR );
5433 return subFloat128Sigs( a, b, aSign STATUS_VAR );
5446 flag aSign, bSign;
5448 aSign = extractFloat128Sign( a );
5450 if ( aSign == bSign ) {
5451 return subFloat128Sigs( a, b, aSign STATUS_VAR );
5454 return addFloat128Sigs( a, b, aSign STATUS_VAR );
5467 flag aSign, bSign, zSign;
5475 aSign = extractFloat128Sign( a );
5480 zSign = aSign ^ bSign;
5531 flag aSign, bSign, zSign;
5540 aSign = extractFloat128Sign( a );
5545 zSign = aSign ^ bSign;
5615 flag aSign, zSign;
5625 aSign = extractFloat128Sign( a );
5712 normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 STATUS_VAR );
5724 flag aSign;
5733 aSign = extractFloat128Sign( a );
5736 if ( ! aSign ) return a;
5739 if ( aSign ) {
5821 flag aSign, bSign;
5831 aSign = extractFloat128Sign( a );
5833 if ( aSign != bSign ) {
5835 aSign
5840 aSign ? le128( b.high, b.low, a.high, a.low )
5854 flag aSign, bSign;
5864 aSign = extractFloat128Sign( a );
5866 if ( aSign != bSign ) {
5868 aSign
5873 aSign ? lt128( b.high, b.low, a.high, a.low )
5937 flag aSign, bSign;
5950 aSign = extractFloat128Sign( a );
5952 if ( aSign != bSign ) {
5954 aSign
5959 aSign ? le128( b.high, b.low, a.high, a.low )
5973 flag aSign, bSign;
5986 aSign = extractFloat128Sign( a );
5988 if ( aSign != bSign ) {
5990 aSign
5995 aSign ? lt128( b.high, b.low, a.high, a.low )
6171 flag aSign, bSign; \
6187 aSign = extractFloat ## s ## Sign( a ); \
6191 if ( aSign != bSign ) { \
6196 return 1 - (2 * aSign); \
6202 return 1 - 2 * (aSign ^ ( av < bv )); \
6223 flag aSign, bSign;
6236 aSign = extractFloatx80Sign( a );
6238 if ( aSign != bSign ) {
6245 return 1 - (2 * aSign);
6251 return 1 - 2 * (aSign ^ ( lt128( a.high, a.low, b.high, b.low ) ));
6269 flag aSign, bSign;
6282 aSign = extractFloat128Sign( a );
6284 if ( aSign != bSign ) {
6289 return 1 - (2 * aSign);
6295 return 1 - 2 * (aSign ^ ( lt128( a.high, a.low, b.high, b.low ) ));
6318 flag aSign, bSign; \
6326 aSign = extractFloat ## s ## Sign(a); \
6330 if (aSign != bSign) { \
6332 return aSign ? a : b; \
6334 return aSign ? b : a; \
6338 return (aSign ^ (av < bv)) ? a : b; \
6340 return (aSign ^ (av < bv)) ? b : a; \
6362 flag aSign;
6369 aSign = extractFloat32Sign( a );
6390 return normalizeRoundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
6395 flag aSign;
6402 aSign = extractFloat64Sign( a );
6423 return normalizeRoundAndPackFloat64( aSign, aExp, aSig STATUS_VAR );
6429 flag aSign;
6435 aSign = extractFloatx80Sign( a );
6455 aSign, aExp, aSig, 0 STATUS_VAR );
6462 flag aSign;
6469 aSign = extractFloat128Sign( a );
6488 return normalizeRoundAndPackFloat128( aSign, aExp, aSig0, aSig1
