Lines Matching refs:zSig
167 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
170 together to form the result. This means that any integer portion of `zSig'
173 than the desired result exponent whenever `zSig' is a complete, normalized
177 INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
186 : "g" (f), "g" (zSign), "g" (zExp), "g" (zSig)
190 return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;
197 and significand `zSig', and returns the proper single-precision floating-
207 The input significand `zSig' has its binary point between bits 30
209 significand must be normalized or smaller. If `zSig' is not normalized,
211 and it must not require rounding. In the usual case that `zSig' is
217 static float32 roundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
241 roundBits = zSig & 0x7F;
245 && ( (sbits32) ( zSig + roundIncrement ) < 0 ) )
254 || ( zSig + roundIncrement < 0x80000000 );
255 shift32RightJamming( zSig, - zExp, &zSig );
257 roundBits = zSig & 0x7F;
262 zSig = ( zSig + roundIncrement )>>7;
263 zSig &= ~ ( ( ( roundBits ^ 0x40 ) == 0 ) & roundNearestEven );
264 if ( zSig == 0 ) zExp = 0;
265 return packFloat32( zSign, zExp, zSig );
272 and significand `zSig', and returns the proper single-precision floating-
274 `roundAndPackFloat32' except that `zSig' does not have to be normalized in
280 normalizeRoundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
284 shiftCount = countLeadingZeros32( zSig ) - 1;
285 return roundAndPackFloat32( roundData, zSign, zExp - shiftCount, zSig<<shiftCount );
348 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
351 together to form the result. This means that any integer portion of `zSig'
354 than the desired result exponent whenever `zSig' is a complete, normalized
358 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
361 return ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig;
368 and significand `zSig', and returns the proper double-precision floating-
378 The input significand `zSig' has its binary point between bits 62
380 significand must be normalized or smaller. If `zSig' is not normalized,
382 and it must not require rounding. In the usual case that `zSig' is
388 static float64 roundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
412 roundBits = zSig & 0x3FF;
416 && ( (sbits64) ( zSig + roundIncrement ) < 0 ) )
427 || ( zSig + roundIncrement < LIT64( 0x8000000000000000 ) );
428 shift64RightJamming( zSig, - zExp, &zSig );
430 roundBits = zSig & 0x3FF;
435 zSig = ( zSig + roundIncrement )>>10;
436 zSig &= ~ ( ( ( roundBits ^ 0x200 ) == 0 ) & roundNearestEven );
437 if ( zSig == 0 ) zExp = 0;
438 return packFloat64( zSign, zExp, zSig );
445 and significand `zSig', and returns the proper double-precision floating-
447 `roundAndPackFloat64' except that `zSig' does not have to be normalized in
453 normalizeRoundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
457 shiftCount = countLeadingZeros64( zSig ) - 1;
458 return roundAndPackFloat64( roundData, zSign, zExp - shiftCount, zSig<<shiftCount );
524 Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
528 INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
532 z.low = zSig;
785 bits64 zSig;
791 zSig = absA;
792 return packFloat64( aSign, 0x432 - shiftCount, zSig<<shiftCount );
811 bits64 zSig;
817 zSig = absA;
818 return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
840 bits64 zSig;
848 zSig = aSig;
849 zSig <<= 32;
850 if ( 0 < shiftCount ) shift64RightJamming( zSig, shiftCount, &zSig );
851 return roundAndPackInt32( roundData, aSign, zSig );
1032 bits32 aSig, bSig, zSig;
1076 zSig = 0x40000000 + aSig + bSig;
1081 zSig = ( aSig + bSig )<<1;
1083 if ( (sbits32) zSig < 0 ) {
1084 zSig = aSig + bSig;
1088 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1104 bits32 aSig, bSig, zSig;
1142 zSig = bSig - aSig;
1160 zSig = aSig - bSig;
1164 return normalizeRoundAndPackFloat32( roundData, zSign, zExp, zSig );
1225 bits32 zSig;
1264 zSig = zSig64;
1265 if ( 0 <= (sbits32) ( zSig<<1 ) ) {
1266 zSig <<= 1;
1269 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1284 bits32 aSig, bSig, zSig;
1331 zSig = tmp;
1333 if ( ( zSig & 0x3F ) == 0 ) {
1334 zSig |= ( ( (bits64) bSig ) * zSig != ( (bits64) aSig )<<32 );
1336 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1454 bits32 aSig, zSig;
1477 zSig = estimateSqrt32( aExp, aSig ) + 2;
1478 if ( ( zSig & 0x7F ) <= 5 ) {
1479 if ( zSig < 2 ) {
1480 zSig = 0xFFFFFFFF;
1484 term = ( (bits64) zSig ) * zSig;
1487 --zSig;
1488 rem += ( ( (bits64) zSig )<<1 ) | 1;
1490 zSig |= ( rem != 0 );
1493 shift32RightJamming( zSig, 1, &zSig );
1494 return roundAndPackFloat32( roundData, 0, zExp, zSig );
1801 bits32 zSig;
1811 zSig = aSig;
1812 if ( aExp || zSig ) {
1813 zSig |= 0x40000000;
1816 return roundAndPackFloat32( roundData, aSign, aExp, zSig );
1928 bits64 aSig, bSig, zSig;
1972 zSig = LIT64( 0x4000000000000000 ) + aSig + bSig;
1977 zSig = ( aSig + bSig )<<1;
1979 if ( (sbits64) zSig < 0 ) {
1980 zSig = aSig + bSig;
1984 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
2000 bits64 aSig, bSig, zSig;
2038 zSig = bSig - aSig;
2056 zSig = aSig - bSig;
2060 return normalizeRoundAndPackFloat64( roundData, zSign, zExp, zSig );
2178 bits64 aSig, bSig, zSig;
2224 zSig = estimateDiv128To64( aSig, 0, bSig );
2225 if ( ( zSig & 0x1FF ) <= 2 ) {
2226 mul64To128( bSig, zSig, &term0, &term1 );
2229 --zSig;
2232 zSig |= ( rem1 != 0 );
2234 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
2335 bits64 aSig, zSig;
2359 zSig = estimateSqrt32( aExp, aSig>>21 );
2360 zSig <<= 31;
2362 zSig = estimateDiv128To64( aSig, 0, zSig ) + zSig + 2;
2363 if ( ( zSig & 0x3FF ) <= 5 ) {
2364 if ( zSig < 2 ) {
2365 zSig = LIT64( 0xFFFFFFFFFFFFFFFF );
2369 mul64To128( zSig, zSig, &term0, &term1 );
2372 --zSig;
2373 shortShift128Left( 0, zSig, 1, &term0, &term1 );
2377 zSig |= ( ( rem0 | rem1 ) != 0 );
2380 shift64RightJamming( zSig, 1, &zSig );
2381 return roundAndPackFloat64( roundData, 0, zExp, zSig );
2645 bits64 aSig, zSig;
2656 shift64RightJamming( aSig, 1, &zSig );
2658 return roundAndPackFloat64( roundData, aSign, aExp, zSig );