Lines Matching refs:aSign
1320 flag aSign;
1327 aSign = extractFloat32Sign( a );
1328 if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
1334 return roundAndPackInt32( aSign, aSig64 );
1351 flag aSign;
1358 aSign = extractFloat32Sign( a );
1363 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
1376 if ( aSign ) z = - z;
1394 flag aSign;
1401 aSign = extractFloat32Sign( a );
1405 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1414 return roundAndPackInt64( aSign, aSig64, aSigExtra );
1430 flag aSign;
1438 aSign = extractFloat32Sign( a );
1443 if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
1459 if ( aSign ) z = - z;
1474 flag aSign;
1480 aSign = extractFloat32Sign( a );
1483 return packFloat64( aSign, 0x7FF, 0 );
1486 if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
1490 return packFloat64( aSign, aExp + 0x380, ( (bits64) aSig )<<29 );
1505 flag aSign;
1511 aSign = extractFloat32Sign( a );
1514 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
1517 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
1521 return packFloatx80( aSign, aExp + 0x3F80, ( (bits64) aSig )<<40 );
1538 flag aSign;
1544 aSign = extractFloat32Sign( a );
1547 return packFloat128( aSign, 0x7FFF, 0, 0 );
1550 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
1554 return packFloat128( aSign, aExp + 0x3F80, ( (bits64) aSig )<<25, 0 );
1570 flag aSign;
1586 aSign = extractFloat32Sign( a );
1590 return packFloat32( aSign, 0x7F, 0 );
1594 return aSign ? 0xBF800000 : 0;
1596 return aSign ? 0x80000000 : 0x3F800000;
1598 return packFloat32( aSign, 0, 0 );
1775 flag aSign, bSign;
1777 aSign = extractFloat32Sign( a );
1779 if ( aSign == bSign ) {
1780 return addFloat32Sigs( a, b, aSign );
1783 return subFloat32Sigs( a, b, aSign );
1796 flag aSign, bSign;
1798 aSign = extractFloat32Sign( a );
1800 if ( aSign == bSign ) {
1801 return subFloat32Sigs( a, b, aSign );
1804 return addFloat32Sigs( a, b, aSign );
1817 flag aSign, bSign, zSign;
1825 aSign = extractFloat32Sign( a );
1829 zSign = aSign ^ bSign;
1877 flag aSign, bSign, zSign;
1883 aSign = extractFloat32Sign( a );
1887 zSign = aSign ^ bSign;
1940 flag aSign, bSign __unused, zSign;
1950 aSign = extractFloat32Sign( a );
2028 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2043 flag aSign;
2050 aSign = extractFloat32Sign( a );
2053 if ( ! aSign ) return a;
2057 if ( aSign ) {
2120 flag aSign, bSign;
2128 aSign = extractFloat32Sign( a );
2130 if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
2131 return ( a == b ) || ( aSign ^ ( a < b ) );
2143 flag aSign, bSign;
2151 aSign = extractFloat32Sign( a );
2153 if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
2154 return ( a != b ) && ( aSign ^ ( a < b ) );
2188 flag aSign, bSign;
2198 aSign = extractFloat32Sign( a );
2200 if ( aSign != bSign ) return aSign || ( (bits32) ( ( a | b )<<1 ) == 0 );
2201 return ( a == b ) || ( aSign ^ ( a < b ) );
2214 flag aSign, bSign;
2224 aSign = extractFloat32Sign( a );
2226 if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
2227 return ( a != b ) && ( aSign ^ ( a < b ) );
2245 flag aSign;
2251 aSign = extractFloat64Sign( a );
2252 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2256 return roundAndPackInt32( aSign, aSig );
2273 flag aSign;
2280 aSign = extractFloat64Sign( a );
2282 if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
2294 if ( aSign ) z = - z;
2295 if ( ( z < 0 ) ^ aSign ) {
2298 return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
2320 flag aSign;
2326 aSign = extractFloat64Sign( a );
2332 if ( ! aSign
2346 return roundAndPackInt64( aSign, aSig, aSigExtra );
2353 flag aSign;
2359 aSign = extractFloat64Sign( a );
2361 if (aSign) {
2370 if ( ! aSign
2400 flag aSign;
2407 aSign = extractFloat64Sign( a );
2414 if ( ! aSign
2435 if ( aSign ) z = - z;
2450 flag aSign;
2457 aSign = extractFloat64Sign( a );
2460 return packFloat32( aSign, 0xFF, 0 );
2468 return roundAndPackFloat32( aSign, aExp, zSig );
2483 flag aSign;
2489 aSign = extractFloat64Sign( a );
2492 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2495 if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
2500 aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
2517 flag aSign;
2523 aSign = extractFloat64Sign( a );
2526 return packFloat128( aSign, 0x7FFF, 0, 0 );
2529 if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
2534 return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );
2550 flag aSign;
2566 aSign = extractFloat64Sign( a );
2570 return packFloat64( aSign, 0x3FF, 0 );
2574 return aSign ? LIT64( 0xBFF0000000000000 ) : 0;
2577 aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 );
2579 return packFloat64( aSign, 0, 0 );
2756 flag aSign, bSign;
2758 aSign = extractFloat64Sign( a );
2760 if ( aSign == bSign ) {
2761 return addFloat64Sigs( a, b, aSign );
2764 return subFloat64Sigs( a, b, aSign );
2777 flag aSign, bSign;
2779 aSign = extractFloat64Sign( a );
2781 if ( aSign == bSign ) {
2782 return subFloat64Sigs( a, b, aSign );
2785 return addFloat64Sigs( a, b, aSign );
2798 flag aSign, bSign, zSign;
2804 aSign = extractFloat64Sign( a );
2808 zSign = aSign ^ bSign;
2856 flag aSign, bSign, zSign;
2864 aSign = extractFloat64Sign( a );
2868 zSign = aSign ^ bSign;
2927 flag aSign, bSign __unused, zSign;
2935 aSign = extractFloat64Sign( a );
3000 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3012 flag aSign;
3019 aSign = extractFloat64Sign( a );
3022 if ( ! aSign ) return a;
3026 if ( aSign ) {
3086 flag aSign, bSign;
3094 aSign = extractFloat64Sign( a );
3096 if ( aSign != bSign ) return aSign || ( (bits64) ( ( a | b )<<1 ) == 0 );
3097 return ( a == b ) || ( aSign ^ ( a < b ) );
3109 flag aSign, bSign;
3117 aSign = extractFloat64Sign( a );
3119 if ( aSign != bSign ) return aSign && ( (bits64) ( ( a | b )<<1 ) != 0 );
3120 return ( a != b ) && ( aSign ^ ( a < b ) );
3154 flag aSign, bSign;
3164 aSign = extractFloat64Sign( a );
3166 if ( aSign != bSign ) return aSign || ( (bits64) ( ( a | b )<<1 ) == 0 );
3167 return ( a == b ) || ( aSign ^ ( a < b ) );
3180 flag aSign, bSign;
3190 aSign = extractFloat64Sign( a );
3192 if ( aSign != bSign ) return aSign && ( (bits64) ( ( a | b )<<1 ) != 0 );
3193 return ( a != b ) && ( aSign ^ ( a < b ) );
3212 flag aSign;
3218 aSign = extractFloatx80Sign( a );
3219 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3223 return roundAndPackInt32( aSign, aSig );
3239 flag aSign;
3246 aSign = extractFloatx80Sign( a );
3248 if ( ( aExp == 0x7FFF ) && (bits64) ( aSig<<1 ) ) aSign = 0;
3259 if ( aSign ) z = - z;
3260 if ( ( z < 0 ) ^ aSign ) {
3263 return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
3284 flag aSign;
3290 aSign = extractFloatx80Sign( a );
3295 if ( ! aSign
3308 return roundAndPackInt64( aSign, aSig, aSigExtra );
3324 flag aSign;
3331 aSign = extractFloatx80Sign( a );
3337 if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
3351 if ( aSign ) z = - z;
3365 flag aSign;
3371 aSign = extractFloatx80Sign( a );
3376 return packFloat32( aSign, 0xFF, 0 );
3380 return roundAndPackFloat32( aSign, aExp, aSig );
3393 flag aSign;
3399 aSign = extractFloatx80Sign( a );
3404 return packFloat64( aSign, 0x7FF, 0 );
3408 return roundAndPackFloat64( aSign, aExp, zSig );
3423 flag aSign;
3429 aSign = extractFloatx80Sign( a );
3434 return packFloat128( aSign, aExp, zSig0, zSig1 );
3449 flag aSign;
3468 aSign = extractFloatx80Sign( a );
3474 packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
3479 aSign ?
3484 aSign ? packFloatx80( 1, 0, 0 )
3487 return packFloatx80( aSign, 0, 0 );
3655 flag aSign, bSign;
3657 aSign = extractFloatx80Sign( a );
3659 if ( aSign == bSign ) {
3660 return addFloatx80Sigs( a, b, aSign );
3663 return subFloatx80Sigs( a, b, aSign );
3676 flag aSign, bSign;
3678 aSign = extractFloatx80Sign( a );
3680 if ( aSign == bSign ) {
3681 return subFloatx80Sigs( a, b, aSign );
3684 return addFloatx80Sigs( a, b, aSign );
3697 flag aSign, bSign, zSign;
3704 aSign = extractFloatx80Sign( a );
3708 zSign = aSign ^ bSign;
3756 flag aSign, bSign, zSign;
3764 aSign = extractFloatx80Sign( a );
3768 zSign = aSign ^ bSign;
3836 flag aSign, bSign, zSign;
3844 aSign = extractFloatx80Sign( a );
3874 zSign = aSign;
3933 flag aSign;
3941 aSign = extractFloatx80Sign( a );
3944 if ( ! aSign ) return a;
3947 if ( aSign ) {
4034 flag aSign, bSign;
4044 aSign = extractFloatx80Sign( a );
4046 if ( aSign != bSign ) {
4048 aSign
4053 aSign ? le128( b.high, b.low, a.high, a.low )
4067 flag aSign, bSign;
4077 aSign = extractFloatx80Sign( a );
4079 if ( aSign != bSign ) {
4081 aSign
4086 aSign ? lt128( b.high, b.low, a.high, a.low )
4127 flag aSign, bSign;
4140 aSign = extractFloatx80Sign( a );
4142 if ( aSign != bSign ) {
4144 aSign
4149 aSign ? le128( b.high, b.low, a.high, a.low )
4163 flag aSign, bSign;
4176 aSign = extractFloatx80Sign( a );
4178 if ( aSign != bSign ) {
4180 aSign
4185 aSign ? lt128( b.high, b.low, a.high, a.low )
4206 flag aSign;
4213 aSign = extractFloat128Sign( a );
4214 if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
4219 return roundAndPackInt32( aSign, aSig0 );
4235 flag aSign;
4243 aSign = extractFloat128Sign( a );
4246 if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
4258 if ( aSign ) z = - z;
4259 if ( ( z < 0 ) ^ aSign ) {
4262 return aSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
4283 flag aSign;
4290 aSign = extractFloat128Sign( a );
4296 if ( ! aSign
4310 return roundAndPackInt64( aSign, aSig0, aSig1 );
4326 flag aSign;
4334 aSign = extractFloat128Sign( a );
4346 if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
4370 if ( aSign ) z = - z;
4384 flag aSign;
4392 aSign = extractFloat128Sign( a );
4397 return packFloat32( aSign, 0xFF, 0 );
4406 return roundAndPackFloat32( aSign, aExp, zSig );
4419 flag aSign;
4426 aSign = extractFloat128Sign( a );
4431 return packFloat64( aSign, 0x7FF, 0 );
4439 return roundAndPackFloat64( aSign, aExp, aSig0 );
4454 flag aSign;
4461 aSign = extractFloat128Sign( a );
4466 return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
4469 if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
4476 return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 );
4491 flag aSign;
4536 aSign = extractFloat128Sign( a );
4543 return packFloat128( aSign, 0x3FFF, 0, 0 );
4548 aSign ? packFloat128( 1, 0x3FFF, 0, 0 )
4552 aSign ? packFloat128( 1, 0, 0, 0 )
4555 return packFloat128( aSign, 0, 0, 0 );
4755 flag aSign, bSign;
4757 aSign = extractFloat128Sign( a );
4759 if ( aSign == bSign ) {
4760 return addFloat128Sigs( a, b, aSign );
4763 return subFloat128Sigs( a, b, aSign );
4776 flag aSign, bSign;
4778 aSign = extractFloat128Sign( a );
4780 if ( aSign == bSign ) {
4781 return subFloat128Sigs( a, b, aSign );
4784 return addFloat128Sigs( a, b, aSign );
4797 flag aSign, bSign, zSign;
4805 aSign = extractFloat128Sign( a );
4810 zSign = aSign ^ bSign;
4861 flag aSign, bSign, zSign;
4870 aSign = extractFloat128Sign( a );
4875 zSign = aSign ^ bSign;
4945 flag aSign, bSign, zSign;
4955 aSign = extractFloat128Sign( a );
5043 normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 );
5055 flag aSign;
5064 aSign = extractFloat128Sign( a );
5067 if ( ! aSign ) return a;
5070 if ( aSign ) {
5154 flag aSign, bSign;
5164 aSign = extractFloat128Sign( a );
5166 if ( aSign != bSign ) {
5168 aSign
5173 aSign ? le128( b.high, b.low, a.high, a.low )
5186 flag aSign, bSign;
5196 aSign = extractFloat128Sign( a );
5198 if ( aSign != bSign ) {
5200 aSign
5205 aSign ? lt128( b.high, b.low, a.high, a.low )
5246 flag aSign, bSign;
5259 aSign = extractFloat128Sign( a );
5261 if ( aSign != bSign ) {
5263 aSign
5268 aSign ? le128( b.high, b.low, a.high, a.low )
5282 flag aSign, bSign;
5295 aSign = extractFloat128Sign( a );
5297 if ( aSign != bSign ) {
5299 aSign
5304 aSign ? lt128( b.high, b.low, a.high, a.low )
5336 flag aSign;
5343 aSign = extractFloat64Sign( a );
5345 if (aSign) {
5381 flag aSign;
5388 aSign = extractFloat32Sign( a );
5391 if (aSign) {
Indexes created Tue Oct 14 00:09:49 GMT 2025