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;
159 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
169 INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
171 return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;
176 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
197 static float32 roundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
213 if ( zSign ) {
228 return packFloat32( zSign, 0xFF, 0 ) - ( roundIncrement == 0 );
245 return packFloat32( zSign, zExp, zSig );
251 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
260 normalizeRoundAndPackFloat32( struct roundingData *roundData, flag zSign, int16 zExp, bits32 zSig )
265 return roundAndPackFloat32( roundData, zSign, zExp - shiftCount, zSig<<shiftCount );
320 Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
330 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
333 return ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig;
339 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
360 static float64 roundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
376 if ( zSign ) {
393 return packFloat64( zSign, 0x7FF, 0 ) - ( roundIncrement == 0 );
410 return packFloat64( zSign, zExp, zSig );
416 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
425 normalizeRoundAndPackFloat64( struct roundingData *roundData, flag zSign, int16 zExp, bits64 zSig )
430 return roundAndPackFloat64( roundData, zSign, zExp - shiftCount, zSig<<shiftCount );
496 Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
500 INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
505 z.high = ( ( (bits16) zSign )<<15 ) + zExp;
513 Takes an abstract floating-point value having sign `zSign', exponent `zExp',
538 struct roundingData *roundData, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
567 if ( zSign ) {
599 return packFloatx80( zSign, zExp, zSig0 );
614 return packFloatx80( zSign, zExp, zSig0 );
622 if ( zSign ) {
641 || ( zSign && ( roundingMode == float_round_up ) )
642 || ( ! zSign && ( roundingMode == float_round_down ) )
644 return packFloatx80( zSign, 0x7FFE, ~ roundMask );
646 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
662 if ( zSign ) {
674 return packFloatx80( zSign, zExp, zSig0 );
692 return packFloatx80( zSign, zExp, zSig0 );
697 Takes an abstract floating-point value having sign `zSign', exponent
707 struct roundingData *roundData, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
721 roundAndPackFloatx80( roundData, zSign, zExp, zSig0, zSig1 );
736 flag zSign;
740 zSign = ( a < 0 );
741 return normalizeRoundAndPackFloat32( roundData, zSign, 0x9C, zSign ? - a : a );
780 flag zSign;
786 zSign = ( a < 0 );
787 absA = zSign ? - a : a;
790 return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
995 floating-point values `a' and `b'. If `zSign' is true, the sum is negated
996 before being returned. `zSign' is ignored if the result is a NaN. The
1001 static float32 addFloat32Sigs( struct roundingData *roundData, float32 a, float32 b, flag zSign )
1031 return packFloat32( zSign, 0xFF, 0 );
1047 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1060 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1067 precision floating-point values `a' and `b'. If `zSign' is true, the
1068 difference is negated before being returned. `zSign' is ignored if the
1073 static float32 subFloat32Sigs( struct roundingData *roundData, float32 a, float32 b, flag zSign )
1103 return packFloat32( zSign ^ 1, 0xFF, 0 );
1116 zSign ^= 1;
1136 return normalizeRoundAndPackFloat32( roundData, zSign, zExp, zSig );
1193 flag aSign, bSign, zSign;
1205 zSign = aSign ^ bSign;
1214 return packFloat32( zSign, 0xFF, 0 );
1222 return packFloat32( zSign, 0xFF, 0 );
1225 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1229 if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
1241 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1254 flag aSign, bSign, zSign;
1264 zSign = aSign ^ bSign;
1272 return packFloat32( zSign, 0xFF, 0 );
1276 return packFloat32( zSign, 0, 0 );
1285 return packFloat32( zSign, 0xFF, 0 );
1290 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1308 return roundAndPackFloat32( roundData, zSign, zExp, zSig );
1321 flag aSign, bSign, zSign;
1409 zSign = ( (sbits32) aSig < 0 );
1410 if ( zSign ) aSig = - aSig;
1411 return normalizeRoundAndPackFloat32( roundData, aSign ^ zSign, bExp, aSig );
1891 floating-point values `a' and `b'. If `zSign' is true, the sum is negated
1892 before being returned. `zSign' is ignored if the result is a NaN. The
1897 static float64 addFloat64Sigs( struct roundingData *roundData, float64 a, float64 b, flag zSign )
1927 return packFloat64( zSign, 0x7FF, 0 );
1943 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
1956 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
1963 precision floating-point values `a' and `b'. If `zSign' is true, the
1964 difference is negated before being returned. `zSign' is ignored if the
1969 static float64 subFloat64Sigs( struct roundingData *roundData, float64 a, float64 b, flag zSign )
1999 return packFloat64( zSign ^ 1, 0x7FF, 0 );
2012 zSign ^= 1;
2032 return normalizeRoundAndPackFloat64( roundData, zSign, zExp, zSig );
2089 flag aSign, bSign, zSign;
2099 zSign = aSign ^ bSign;
2108 return packFloat64( zSign, 0x7FF, 0 );
2116 return packFloat64( zSign, 0x7FF, 0 );
2119 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2123 if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
2135 return roundAndPackFloat64( roundData, zSign, zExp, zSig0 );
2148 flag aSign, bSign, zSign;
2160 zSign = aSign ^ bSign;
2168 return packFloat64( zSign, 0x7FF, 0 );
2172 return packFloat64( zSign, 0, 0 );
2181 return packFloat64( zSign, 0x7FF, 0 );
2186 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2206 return roundAndPackFloat64( roundData, zSign, zExp, zSig );
2219 flag aSign, bSign, zSign;
2290 zSign = ( (sbits64) aSig < 0 );
2291 if ( zSign ) aSig = - aSig;
2292 return normalizeRoundAndPackFloat64( roundData, aSign ^ zSign, bExp, aSig );
2711 precision floating-point values `a' and `b'. If `zSign' is true, the sum is
2712 negated before being returned. `zSign' is ignored if the result is a NaN.
2717 static floatx80 addFloatx80Sigs( struct roundingData *roundData, floatx80 a, floatx80 b, flag zSign )
2740 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2773 roundData, zSign, zExp, zSig0, zSig1 );
2780 double-precision floating-point values `a' and `b'. If `zSign' is true,
2781 the difference is negated before being returned. `zSign' is ignored if the
2786 static floatx80 subFloatx80Sigs( struct roundingData *roundData, floatx80 a, floatx80 b, flag zSign )
2821 return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) );
2828 zSign ^= 1;
2843 roundData, zSign, zExp, zSig0, zSig1 );
2900 flag aSign, bSign, zSign;
2911 zSign = aSign ^ bSign;
2918 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2930 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2933 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
2937 if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
2948 roundData, zSign, zExp, zSig0, zSig1 );
2961 flag aSign, bSign, zSign;
2973 zSign = aSign ^ bSign;
2980 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
2984 return packFloatx80( zSign, 0, 0 );
2997 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3002 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3030 roundData, zSign, zExp, zSig0, zSig1 );
3043 flag aSign, bSign, zSign;
3082 zSign = aSign;
3125 zSign = ! zSign;
3130 roundData, zSign, bExp + expDiff, aSig0, aSig1 );