Lines Matching defs:zSign
62 input. If `zSign' is nonzero, the input is negated before being converted
70 static int32 roundAndPackInt32( struct roundingData *roundData, flag zSign, bits64 absZ )
86 if ( zSign ) {
98 if ( zSign ) z = - z;
99 if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
101 return zSign ? 0x80000000 : 0x7FFFFFFF;
167 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
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;
196 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
217 static float32 roundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
233 if ( zSign ) {
248 return packFloat32( zSign, 0xFF, 0 ) - ( roundIncrement == 0 );
265 return packFloat32( zSign, zExp, zSig );
271 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
280 normalizeRoundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
285 return roundAndPackFloat32( roundData, zSign, zExp - shiftCount, zSig<<shiftCount );
348 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
358 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
361 return ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig;
367 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
388 static float64 roundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
404 if ( zSign ) {
421 return packFloat64( zSign, 0x7FF, 0 ) - ( roundIncrement == 0 );
438 return packFloat64( zSign, zExp, zSig );
444 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
453 normalizeRoundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
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 )
533 z.high = ( ( (bits16) zSign )<<15 ) + zExp;
541 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
566 struct roundingData *roundData, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
595 if ( zSign ) {
627 return packFloatx80( zSign, zExp, zSig0 );
642 return packFloatx80( zSign, zExp, zSig0 );
650 if ( zSign ) {
669 || ( zSign && ( roundingMode == float_round_up ) )
670 || ( ! zSign && ( roundingMode == float_round_down ) )
672 return packFloatx80( zSign, 0x7FFE, ~ roundMask );
674 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
690 if ( zSign ) {
702 return packFloatx80( zSign, zExp, zSig0 );
720 return packFloatx80( zSign, zExp, zSig0 );
725 Takes an abstract floating-point value having sign `zSign', exponent
735 struct roundingData *roundData, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
749 roundAndPackFloatx80( roundData, zSign, zExp, zSig0, zSig1 );
764 flag zSign;
768 zSign = ( a < 0 );
769 return normalizeRoundAndPackFloat32( roundData, zSign, 0x9C, zSign ? - a : a );
808 flag zSign;
814 zSign = ( a < 0 );
815 absA = zSign ? - a : a;
818 return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
1023 floating-point values `a' and `b'. If `zSign' is true, the sum is negated
1024 before being returned. `zSign' is ignored if the result is a NaN. The
1029 static float32 addFloat32Sigs( struct roundingData *roundData, float32 a, float32 b, flag zSign )
1059 return packFloat32( zSign, 0xFF, 0 );
1075 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1088 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1095 precision floating-point values `a' and `b'. If `zSign' is true, the
1096 difference is negated before being returned. `zSign' is ignored if the
1101 static float32 subFloat32Sigs( struct roundingData *roundData, float32 a, float32 b, flag zSign )
1131 return packFloat32( zSign ^ 1, 0xFF, 0 );
1144 zSign ^= 1;
1164 return normalizeRoundAndPackFloat32( roundData, zSign, zExp, zSig );
1221 flag aSign, bSign, zSign;
1233 zSign = aSign ^ bSign;
1242 return packFloat32( zSign, 0xFF, 0 );
1250 return packFloat32( zSign, 0xFF, 0 );
1253 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1257 if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
1269 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1282 flag aSign, bSign, zSign;
1292 zSign = aSign ^ bSign;
1300 return packFloat32( zSign, 0xFF, 0 );
1304 return packFloat32( zSign, 0, 0 );
1313 return packFloat32( zSign, 0xFF, 0 );
1318 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1336 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1349 flag aSign, bSign, zSign;
1437 zSign = ( (sbits32) aSig < 0 );
1438 if ( zSign ) aSig = - aSig;
1439 return normalizeRoundAndPackFloat32( roundData, aSign ^ zSign, bExp, aSig );
1919 floating-point values `a' and `b'. If `zSign' is true, the sum is negated
1920 before being returned. `zSign' is ignored if the result is a NaN. The
1925 static float64 addFloat64Sigs( struct roundingData *roundData, float64 a, float64 b, flag zSign )
1955 return packFloat64( zSign, 0x7FF, 0 );
1971 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
1984 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
1991 precision floating-point values `a' and `b'. If `zSign' is true, the
1992 difference is negated before being returned. `zSign' is ignored if the
1997 static float64 subFloat64Sigs( struct roundingData *roundData, float64 a, float64 b, flag zSign )
2027 return packFloat64( zSign ^ 1, 0x7FF, 0 );
2040 zSign ^= 1;
2060 return normalizeRoundAndPackFloat64( roundData, zSign, zExp, zSig );
2117 flag aSign, bSign, zSign;
2127 zSign = aSign ^ bSign;
2136 return packFloat64( zSign, 0x7FF, 0 );
2144 return packFloat64( zSign, 0x7FF, 0 );
2147 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2151 if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
2163 return roundAndPackFloat64( roundData, zSign, zExp, zSig0 );
2176 flag aSign, bSign, zSign;
2188 zSign = aSign ^ bSign;
2196 return packFloat64( zSign, 0x7FF, 0 );
2200 return packFloat64( zSign, 0, 0 );
2209 return packFloat64( zSign, 0x7FF, 0 );
2214 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2234 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
2247 flag aSign, bSign, zSign;
2318 zSign = ( (sbits64) aSig < 0 );
2319 if ( zSign ) aSig = - aSig;
2320 return normalizeRoundAndPackFloat64( roundData, aSign ^ zSign, bExp, aSig );
2739 precision floating-point values `a' and `b'. If `zSign' is true, the sum is
2740 negated before being returned. `zSign' is ignored if the result is a NaN.
2745 static floatx80 addFloatx80Sigs( struct roundingData *roundData, floatx80 a, floatx80 b, flag zSign )
2768 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2801 roundData, zSign, zExp, zSig0, zSig1 );
2808 double-precision floating-point values `a' and `b'. If `zSign' is true,
2809 the difference is negated before being returned. `zSign' is ignored if the
2814 static floatx80 subFloatx80Sigs( struct roundingData *roundData, floatx80 a, floatx80 b, flag zSign )
2849 return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) );
2856 zSign ^= 1;
2871 roundData, zSign, zExp, zSig0, zSig1 );
2928 flag aSign, bSign, zSign;
2939 zSign = aSign ^ bSign;
2946 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2958 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2961 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2965 if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
2976 roundData, zSign, zExp, zSig0, zSig1 );
2989 flag aSign, bSign, zSign;
3001 zSign = aSign ^ bSign;
3008 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3012 return packFloatx80( zSign, 0, 0 );
3025 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3030 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3058 roundData, zSign, zExp, zSig0, zSig1 );
3071 flag aSign, bSign, zSign;
3110 zSign = aSign;
3153 zSign = ! zSign;
3158 roundData, zSign, bExp + expDiff, aSig0, aSig1 );