Lines Matching defs:aSign
1296 flag aSign;
1303 aSign = extractFloat32Sign( a );
1304 if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1310 return roundAndPackInt32( aSign, aSig64 STATUS_VAR );
1326 flag aSign;
1333 aSign = extractFloat32Sign( a );
1338 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1351 if ( aSign ) z = - z;
1368 flag aSign;
1375 aSign = extractFloat32Sign( a );
1379 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1388 return roundAndPackInt64( aSign, aSig64, aSigExtra STATUS_VAR );
1404 flag aSign;
1412 aSign = extractFloat32Sign( a );
1417 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1433 if ( aSign ) z = - z;
1447 flag aSign;
1453 aSign = extractFloat32Sign( a );
1456 return packFloat64( aSign, 0x7FF, 0 );
1459 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1463 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1478 flag aSign;
1484 aSign = extractFloat32Sign( a );
1487 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
1490 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1494 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1511 flag aSign;
1517 aSign = extractFloat32Sign( a );
1520 return packFloat128( aSign, 0x7FFF, 0, 0 );
1523 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1527 return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1542 flag aSign;
1558 aSign = extractFloat32Sign( a );
1562 return packFloat32( aSign, 0x7F, 0 );
1566 return make_float32(aSign ? 0xBF800000 : 0);
1568 return make_float32(aSign ? 0x80000000 : 0x3F800000);
1570 return packFloat32( aSign, 0, 0 );
1749 flag aSign, bSign;
1751 aSign = extractFloat32Sign( a );
1753 if ( aSign == bSign ) {
1754 return addFloat32Sigs( a, b, aSign STATUS_VAR);
1757 return subFloat32Sigs( a, b, aSign STATUS_VAR );
1770 flag aSign, bSign;
1772 aSign = extractFloat32Sign( a );
1774 if ( aSign == bSign ) {
1775 return subFloat32Sigs( a, b, aSign STATUS_VAR );
1778 return addFloat32Sigs( a, b, aSign STATUS_VAR );
1791 flag aSign, bSign, zSign;
1799 aSign = extractFloat32Sign( a );
1803 zSign = aSign ^ bSign;
1851 flag aSign, bSign, zSign;
1857 aSign = extractFloat32Sign( a );
1861 zSign = aSign ^ bSign;
1913 flag aSign, zSign;
1923 aSign = extractFloat32Sign( a );
2000 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR );
2012 flag aSign;
2019 aSign = extractFloat32Sign( a );
2022 if ( ! aSign ) return a;
2026 if ( aSign ) {
2097 flag aSign;
2105 aSign = extractFloat32Sign( a );
2109 return (aSign) ? float32_zero : a;
2144 flag aSign, zSign;
2150 aSign = extractFloat32Sign( a );
2156 if ( aSign ) {
2215 flag aSign, bSign;
2224 aSign = extractFloat32Sign( a );
2228 if ( aSign != bSign ) return aSign || ( (bits32) ( ( av | bv )<<1 ) == 0 );
2229 return ( av == bv ) || ( aSign ^ ( av < bv ) );
2241 flag aSign, bSign;
2250 aSign = extractFloat32Sign( a );
2254 if ( aSign != bSign ) return aSign && ( (bits32) ( ( av | bv )<<1 ) != 0 );
2255 return ( av != bv ) && ( aSign ^ ( av < bv ) );
2291 flag aSign, bSign;
2302 aSign = extractFloat32Sign( a );
2306 if ( aSign != bSign ) return aSign || ( (bits32) ( ( av | bv )<<1 ) == 0 );
2307 return ( av == bv ) || ( aSign ^ ( av < bv ) );
2320 flag aSign, bSign;
2331 aSign = extractFloat32Sign( a );
2335 if ( aSign != bSign ) return aSign && ( (bits32) ( ( av | bv )<<1 ) != 0 );
2336 return ( av != bv ) && ( aSign ^ ( av < bv ) );
2352 flag aSign;
2358 aSign = extractFloat64Sign( a );
2359 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2363 return roundAndPackInt32( aSign, aSig STATUS_VAR );
2379 flag aSign;
2386 aSign = extractFloat64Sign( a );
2388 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2400 if ( aSign ) z = - z;
2401 if ( ( z < 0 ) ^ aSign ) {
2404 return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
2425 flag aSign;
2431 aSign = extractFloat64Sign( a );
2437 if ( ! aSign
2451 return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
2467 flag aSign;
2474 aSign = extractFloat64Sign( a );
2481 if ( ! aSign
2502 if ( aSign ) z = - z;
2516 flag aSign;
2523 aSign = extractFloat64Sign( a );
2526 return packFloat32( aSign, 0xFF, 0 );
2534 return roundAndPackFloat32( aSign, aExp, zSig STATUS_VAR );
2559 flag aSign;
2563 aSign = a >> 15;
2573 return packFloat32(aSign, 0xff, aSig << 13);
2579 return packFloat32(aSign, 0, 0);
2586 return packFloat32( aSign, aExp + 0x70, aSig << 13);
2591 flag aSign;
2600 aSign = extractFloat32Sign( a );
2607 return packFloat16(aSign, 0x1f, aSig >> 13);
2609 if (aExp == 0 && aSign == 0) {
2610 return packFloat16(aSign, 0, 0);
2636 increment = aSign ? 0 : mask;
2639 increment = aSign ? mask : 0;
2658 return packFloat16(aSign, 0x1f, 0);
2663 return packFloat16(aSign, 0x1f, 0x3ff);
2667 return packFloat16(aSign, 0, 0);
2673 return packFloat16(aSign, aExp + 14, aSig >> 13);
2687 flag aSign;
2693 aSign = extractFloat64Sign( a );
2696 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2699 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2704 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2721 flag aSign;
2727 aSign = extractFloat64Sign( a );
2730 return packFloat128( aSign, 0x7FFF, 0, 0 );
2733 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2738 return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );
2753 flag aSign;
2769 aSign = extractFloat64Sign( a );
2773 return packFloat64( aSign, 0x3FF, 0 );
2777 return make_float64(aSign ? LIT64( 0xBFF0000000000000 ) : 0);
2780 aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 ));
2782 return packFloat64( aSign, 0, 0 );
2973 flag aSign, bSign;
2975 aSign = extractFloat64Sign( a );
2977 if ( aSign == bSign ) {
2978 return addFloat64Sigs( a, b, aSign STATUS_VAR );
2981 return subFloat64Sigs( a, b, aSign STATUS_VAR );
2994 flag aSign, bSign;
2996 aSign = extractFloat64Sign( a );
2998 if ( aSign == bSign ) {
2999 return subFloat64Sigs( a, b, aSign STATUS_VAR );
3002 return addFloat64Sigs( a, b, aSign STATUS_VAR );
3015 flag aSign, bSign, zSign;
3021 aSign = extractFloat64Sign( a );
3025 zSign = aSign ^ bSign;
3073 flag aSign, bSign, zSign;
3081 aSign = extractFloat64Sign( a );
3085 zSign = aSign ^ bSign;
3143 flag aSign, zSign;
3151 aSign = extractFloat64Sign( a );
3215 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR );
3227 flag aSign;
3234 aSign = extractFloat64Sign( a );
3237 if ( ! aSign ) return a;
3241 if ( aSign ) {
3277 flag aSign, zSign;
3283 aSign = extractFloat64Sign( a );
3289 if ( aSign ) {
3349 flag aSign, bSign;
3358 aSign = extractFloat64Sign( a );
3362 if ( aSign != bSign ) return aSign || ( (bits64) ( ( av | bv )<<1 ) == 0 );
3363 return ( av == bv ) || ( aSign ^ ( av < bv ) );
3375 flag aSign, bSign;
3384 aSign = extractFloat64Sign( a );
3388 if ( aSign != bSign ) return aSign && ( (bits64) ( ( av | bv )<<1 ) != 0 );
3389 return ( av != bv ) && ( aSign ^ ( av < bv ) );
3425 flag aSign, bSign;
3436 aSign = extractFloat64Sign( a );
3440 if ( aSign != bSign ) return aSign || ( (bits64) ( ( av | bv )<<1 ) == 0 );
3441 return ( av == bv ) || ( aSign ^ ( av < bv ) );
3454 flag aSign, bSign;
3465 aSign = extractFloat64Sign( a );
3469 if ( aSign != bSign ) return aSign && ( (bits64) ( ( av | bv )<<1 ) != 0 );
3470 return ( av != bv ) && ( aSign ^ ( av < bv ) );
3488 flag aSign;
3494 aSign = extractFloatx80Sign( a );
3495 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3499 return roundAndPackInt32( aSign, aSig STATUS_VAR );
3515 flag aSign;
3522 aSign = extractFloatx80Sign( a );
3524 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3535 if ( aSign ) z = - z;
3536 if ( ( z < 0 ) ^ aSign ) {
3539 return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
3560 flag aSign;
3566 aSign = extractFloatx80Sign( a );
3571 if ( ! aSign
3584 return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
3600 flag aSign;
3607 aSign = extractFloatx80Sign( a );
3613 if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3627 if ( aSign ) z = - z;
3641 flag aSign;
3647 aSign = extractFloatx80Sign( a );
3652 return packFloat32( aSign, 0xFF, 0 );
3656 return roundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
3669 flag aSign;
3675 aSign = extractFloatx80Sign( a );
3680 return packFloat64( aSign, 0x7FF, 0 );
3684 return roundAndPackFloat64( aSign, aExp, zSig STATUS_VAR );
3699 flag aSign;
3705 aSign = extractFloatx80Sign( a );
3710 return packFloat128( aSign, aExp, zSig0, zSig1 );
3725 flag aSign;
3744 aSign = extractFloatx80Sign( a );
3750 packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3755 aSign ?
3760 aSign ? packFloatx80( 1, 0, 0 )
3763 return packFloatx80( aSign, 0, 0 );
3931 flag aSign, bSign;
3933 aSign = extractFloatx80Sign( a );
3935 if ( aSign == bSign ) {
3936 return addFloatx80Sigs( a, b, aSign STATUS_VAR );
3939 return subFloatx80Sigs( a, b, aSign STATUS_VAR );
3952 flag aSign, bSign;
3954 aSign = extractFloatx80Sign( a );
3956 if ( aSign == bSign ) {
3957 return subFloatx80Sigs( a, b, aSign STATUS_VAR );
3960 return addFloatx80Sigs( a, b, aSign STATUS_VAR );
3973 flag aSign, bSign, zSign;
3980 aSign = extractFloatx80Sign( a );
3984 zSign = aSign ^ bSign;
4032 flag aSign, bSign, zSign;
4040 aSign = extractFloatx80Sign( a );
4044 zSign = aSign ^ bSign;
4112 flag aSign, zSign;
4120 aSign = extractFloatx80Sign( a );
4149 zSign = aSign;
4208 flag aSign;
4216 aSign = extractFloatx80Sign( a );
4219 if ( ! aSign ) return a;
4222 if ( aSign ) {
4309 flag aSign, bSign;
4319 aSign = extractFloatx80Sign( a );
4321 if ( aSign != bSign ) {
4323 aSign
4328 aSign ? le128( b.high, b.low, a.high, a.low )
4342 flag aSign, bSign;
4352 aSign = extractFloatx80Sign( a );
4354 if ( aSign != bSign ) {
4356 aSign
4361 aSign ? lt128( b.high, b.low, a.high, a.low )
4402 flag aSign, bSign;
4415 aSign = extractFloatx80Sign( a );
4417 if ( aSign != bSign ) {
4419 aSign
4424 aSign ? le128( b.high, b.low, a.high, a.low )
4438 flag aSign, bSign;
4451 aSign = extractFloatx80Sign( a );
4453 if ( aSign != bSign ) {
4455 aSign
4460 aSign ? lt128( b.high, b.low, a.high, a.low )
4481 flag aSign;
4488 aSign = extractFloat128Sign( a );
4489 if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
4494 return roundAndPackInt32( aSign, aSig0 STATUS_VAR );
4510 flag aSign;
4518 aSign = extractFloat128Sign( a );
4521 if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
4533 if ( aSign ) z = - z;
4534 if ( ( z < 0 ) ^ aSign ) {
4537 return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
4558 flag aSign;
4565 aSign = extractFloat128Sign( a );
4571 if ( ! aSign
4585 return roundAndPackInt64( aSign, aSig0, aSig1 STATUS_VAR );
4601 flag aSign;
4609 aSign = extractFloat128Sign( a );
4621 if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
4645 if ( aSign ) z = - z;
4659 flag aSign;
4667 aSign = extractFloat128Sign( a );
4672 return packFloat32( aSign, 0xFF, 0 );
4681 return roundAndPackFloat32( aSign, aExp, zSig STATUS_VAR );
4694 flag aSign;
4701 aSign = extractFloat128Sign( a );
4706 return packFloat64( aSign, 0x7FF, 0 );
4714 return roundAndPackFloat64( aSign, aExp, aSig0 STATUS_VAR );
4729 flag aSign;
4736 aSign = extractFloat128Sign( a );
4741 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
4744 if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
4751 return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 STATUS_VAR );
4766 flag aSign;
4811 aSign = extractFloat128Sign( a );
4818 return packFloat128( aSign, 0x3FFF, 0, 0 );
4823 aSign ? packFloat128( 1, 0x3FFF, 0, 0 )
4827 aSign ? packFloat128( 1, 0, 0, 0 )
4830 return packFloat128( aSign, 0, 0, 0 );
5033 flag aSign, bSign;
5035 aSign = extractFloat128Sign( a );
5037 if ( aSign == bSign ) {
5038 return addFloat128Sigs( a, b, aSign STATUS_VAR );
5041 return subFloat128Sigs( a, b, aSign STATUS_VAR );
5054 flag aSign, bSign;
5056 aSign = extractFloat128Sign( a );
5058 if ( aSign == bSign ) {
5059 return subFloat128Sigs( a, b, aSign STATUS_VAR );
5062 return addFloat128Sigs( a, b, aSign STATUS_VAR );
5075 flag aSign, bSign, zSign;
5083 aSign = extractFloat128Sign( a );
5088 zSign = aSign ^ bSign;
5139 flag aSign, bSign, zSign;
5148 aSign = extractFloat128Sign( a );
5153 zSign = aSign ^ bSign;
5223 flag aSign, zSign;
5233 aSign = extractFloat128Sign( a );
5320 normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 STATUS_VAR );
5332 flag aSign;
5341 aSign = extractFloat128Sign( a );
5344 if ( ! aSign ) return a;
5347 if ( aSign ) {
5431 flag aSign, bSign;
5441 aSign = extractFloat128Sign( a );
5443 if ( aSign != bSign ) {
5445 aSign
5450 aSign ? le128( b.high, b.low, a.high, a.low )
5463 flag aSign, bSign;
5473 aSign = extractFloat128Sign( a );
5475 if ( aSign != bSign ) {
5477 aSign
5482 aSign ? lt128( b.high, b.low, a.high, a.low )
5523 flag aSign, bSign;
5536 aSign = extractFloat128Sign( a );
5538 if ( aSign != bSign ) {
5540 aSign
5545 aSign ? le128( b.high, b.low, a.high, a.low )
5559 flag aSign, bSign;
5572 aSign = extractFloat128Sign( a );
5574 if ( aSign != bSign ) {
5576 aSign
5581 aSign ? lt128( b.high, b.low, a.high, a.low )
5698 flag aSign, bSign; \
5712 aSign = extractFloat ## s ## Sign( a ); \
5716 if ( aSign != bSign ) { \
5721 return 1 - (2 * aSign); \
5727 return 1 - 2 * (aSign ^ ( av < bv )); \
5748 flag aSign, bSign;
5761 aSign = extractFloat128Sign( a );
5763 if ( aSign != bSign ) {
5768 return 1 - (2 * aSign);
5774 return 1 - 2 * (aSign ^ ( lt128( a.high, a.low, b.high, b.low ) ));
5792 flag aSign;
5798 aSign = extractFloat32Sign( a );
5810 return normalizeRoundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
5815 flag aSign;
5821 aSign = extractFloat64Sign( a );
5833 return normalizeRoundAndPackFloat64( aSign, aExp, aSig STATUS_VAR );
5839 flag aSign;
5845 aSign = extractFloatx80Sign( a );
5855 aSign, aExp, aSig, 0 STATUS_VAR );
5862 flag aSign;
5869 aSign = extractFloat128Sign( a );
5879 return normalizeRoundAndPackFloat128( aSign, aExp, aSig0, aSig1