Lines Matching defs:zSign
97 | input. If `zSign' is 1, the input is negated before being converted to an
105 static int32 roundAndPackInt32( flag zSign, bits64 absZ )
121 if ( zSign ) {
133 if ( zSign ) z = - z;
134 if ( ( absZ>>32 ) || ( z && ( ( z < 0 ) ^ zSign ) ) ) {
136 return zSign ? (sbits32) 0x80000000 : 0x7FFFFFFF;
147 | If `zSign' is 1, the input is negated before being converted to an integer.
155 static int64 roundAndPackInt64( flag zSign, bits64 absZ0, bits64 absZ1 )
169 if ( zSign ) {
183 if ( zSign ) z = - z;
184 if ( z && ( ( z < 0 ) ^ zSign ) ) {
188 zSign ? (sbits64) LIT64( 0x8000000000000000 )
281 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
291 INLINE float32 packFloat32( flag zSign, int16 zExp, bits32 zSig )
294 return ( ( (bits32) zSign )<<31 ) + ( ( (bits32) zExp )<<23 ) + zSig;
299 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
320 static float32 roundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
336 if ( zSign ) {
351 return packFloat32( zSign, 0xFF, 0 ) - ( roundIncrement == 0 );
368 return packFloat32( zSign, zExp, zSig );
373 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
382 normalizeRoundAndPackFloat32( flag zSign, int16 zExp, bits32 zSig )
387 return roundAndPackFloat32( zSign, zExp - shiftCount, zSig<<shiftCount );
442 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into a
452 INLINE float64 packFloat64( flag zSign, int16 zExp, bits64 zSig )
455 return ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<52 ) + zSig;
460 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
481 static float64 roundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
497 if ( zSign ) {
512 return packFloat64( zSign, 0x7FF, 0 ) - ( roundIncrement == 0 );
529 return packFloat64( zSign, zExp, zSig );
534 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
543 normalizeRoundAndPackFloat64( flag zSign, int16 zExp, bits64 zSig )
548 return roundAndPackFloat64( zSign, zExp - shiftCount, zSig<<shiftCount );
609 | Packs the sign `zSign', exponent `zExp', and significand `zSig' into an
613 INLINE floatx80 packFloatx80( flag zSign, int32 zExp, bits64 zSig )
618 z.high = ( ( (bits16) zSign )<<15 ) + zExp;
624 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
649 int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
677 if ( zSign ) {
709 return packFloatx80( zSign, zExp, zSig0 );
724 return packFloatx80( zSign, zExp, zSig0 );
732 if ( zSign ) {
751 || ( zSign && ( roundingMode == float_round_up ) )
752 || ( ! zSign && ( roundingMode == float_round_down ) )
754 return packFloatx80( zSign, 0x7FFE, ~ roundMask );
756 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
772 if ( zSign ) {
785 return packFloatx80( zSign, zExp, zSig0 );
802 return packFloatx80( zSign, zExp, zSig0 );
807 | Takes an abstract floating-point value having sign `zSign', exponent
817 int8 roundingPrecision, flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1
831 roundAndPackFloatx80( roundingPrecision, zSign, zExp, zSig0, zSig1 );
928 | Packs the sign `zSign', the exponent `zExp', and the significand formed
931 | proper positions, the three fields `zSign', `zExp', and `zSig0' are simply
941 packFloat128( flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )
946 z.high = ( ( (bits64) zSign )<<63 ) + ( ( (bits64) zExp )<<48 ) + zSig0;
952 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
974 flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1, bits64 zSig2 )
987 if ( zSign ) {
1009 || ( zSign && ( roundingMode == float_round_up ) )
1010 || ( ! zSign && ( roundingMode == float_round_down ) )
1014 zSign,
1020 return packFloat128( zSign, 0x7FFF, 0, 0 );
1041 if ( zSign ) {
1058 return packFloat128( zSign, zExp, zSig0, zSig1 );
1063 | Takes an abstract floating-point value having sign `zSign', exponent `zExp',
1074 flag zSign, int32 zExp, bits64 zSig0, bits64 zSig1 )
1094 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
1108 flag zSign;
1112 zSign = ( a < 0 );
1113 return normalizeRoundAndPackFloat32( zSign, 0x9C, zSign ? - a : a );
1125 flag zSign;
1131 zSign = ( a < 0 );
1132 absA = zSign ? - a : a;
1135 return packFloat64( zSign, 0x432 - shiftCount, zSig<<shiftCount );
1150 flag zSign;
1156 zSign = ( a < 0 );
1157 absA = zSign ? - a : a;
1160 return packFloatx80( zSign, 0x403E - shiftCount, zSig<<shiftCount );
1176 flag zSign;
1182 zSign = ( a < 0 );
1183 absA = zSign ? - a : a;
1186 return packFloat128( zSign, 0x402E - shiftCount, zSig0<<shiftCount, 0 );
1201 flag zSign;
1206 zSign = ( a < 0 );
1207 absA = zSign ? - a : a;
1210 return packFloat32( zSign, 0x95 - shiftCount, absA<<shiftCount );
1220 return roundAndPackFloat32( zSign, 0x9C - shiftCount, absA );
1233 flag zSign;
1239 zSign = ( a < 0 );
1240 return normalizeRoundAndPackFloat64( zSign, 0x43C, zSign ? - a : a );
1255 flag zSign;
1260 zSign = ( a < 0 );
1261 absA = zSign ? - a : a;
1263 return packFloatx80( zSign, 0x403E - shiftCount, absA<<shiftCount );
1279 flag zSign;
1286 zSign = ( a < 0 );
1287 absA = zSign ? - a : a;
1300 return packFloat128( zSign, zExp, zSig0, zSig1 );
1623 | floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
1624 | before being returned. `zSign' is ignored if the result is a NaN.
1629 static float32 addFloat32Sigs( float32 a, float32 b, flag zSign )
1659 return packFloat32( zSign, 0xFF, 0 );
1675 if ( aExp == 0 ) return packFloat32( zSign, 0, ( aSig + bSig )>>6 );
1688 return roundAndPackFloat32( zSign, zExp, zSig );
1694 | precision floating-point values `a' and `b'. If `zSign' is 1, the
1695 | difference is negated before being returned. `zSign' is ignored if the
1700 static float32 subFloat32Sigs( float32 a, float32 b, flag zSign )
1730 return packFloat32( zSign ^ 1, 0xFF, 0 );
1743 zSign ^= 1;
1763 return normalizeRoundAndPackFloat32( zSign, zExp, zSig );
1817 flag aSign, bSign, zSign;
1829 zSign = aSign ^ bSign;
1838 return packFloat32( zSign, 0xFF, 0 );
1846 return packFloat32( zSign, 0xFF, 0 );
1849 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1853 if ( bSig == 0 ) return packFloat32( zSign, 0, 0 );
1865 return roundAndPackFloat32( zSign, zExp, zSig );
1877 flag aSign, bSign, zSign;
1887 zSign = aSign ^ bSign;
1895 return packFloat32( zSign, 0xFF, 0 );
1899 return packFloat32( zSign, 0, 0 );
1908 return packFloat32( zSign, 0xFF, 0 );
1913 if ( aSig == 0 ) return packFloat32( zSign, 0, 0 );
1927 return roundAndPackFloat32( zSign, zExp, zSig );
1940 flag aSign, bSign __unused, zSign;
2026 zSign = ( (sbits32) aSig < 0 );
2027 if ( zSign ) aSig = - aSig;
2028 return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig );
2604 | floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
2605 | before being returned. `zSign' is ignored if the result is a NaN.
2610 static float64 addFloat64Sigs( float64 a, float64 b, flag zSign )
2640 return packFloat64( zSign, 0x7FF, 0 );
2656 if ( aExp == 0 ) return packFloat64( zSign, 0, ( aSig + bSig )>>9 );
2669 return roundAndPackFloat64( zSign, zExp, zSig );
2675 | precision floating-point values `a' and `b'. If `zSign' is 1, the
2676 | difference is negated before being returned. `zSign' is ignored if the
2681 static float64 subFloat64Sigs( float64 a, float64 b, flag zSign )
2711 return packFloat64( zSign ^ 1, 0x7FF, 0 );
2724 zSign ^= 1;
2744 return normalizeRoundAndPackFloat64( zSign, zExp, zSig );
2798 flag aSign, bSign, zSign;
2808 zSign = aSign ^ bSign;
2817 return packFloat64( zSign, 0x7FF, 0 );
2825 return packFloat64( zSign, 0x7FF, 0 );
2828 zSign, 0, 0 );
2832 if ( bSig == 0 ) return packFloat64( zSign, 0, 0 );
2844 return roundAndPackFloat64( zSign, zExp, zSig0 );
2856 flag aSign, bSign, zSign;
2868 zSign = aSign ^ bSign;
2876 return packFloat64( zSign, 0x7FF, 0 );
2880 return packFloat64( zSign, 0, 0 );
2889 return packFloat64( zSign, 0x7FF, 0 );
2894 if ( aSig == 0 ) return packFloat64( zSign, 0, 0 );
2914 return roundAndPackFloat64( zSign, zExp, zSig );
2927 flag aSign, bSign __unused, zSign;
2998 zSign = ( (sbits64) aSig < 0 );
2999 if ( zSign ) aSig = - aSig;
3000 return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig );
3515 | precision floating-point values `a' and `b'. If `zSign' is 1, the sum is
3516 | negated before being returned. `zSign' is ignored if the result is a NaN.
3521 static floatx80 addFloatx80Sigs( floatx80 a, floatx80 b, flag zSign )
3544 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3575 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3581 | double-precision floating-point values `a' and `b'. If `zSign' is 1, the
3582 | difference is negated before being returned. `zSign' is ignored if the
3587 static floatx80 subFloatx80Sigs( floatx80 a, floatx80 b, flag zSign )
3621 return packFloatx80( zSign ^ 1, 0x7FFF, LIT64( 0x8000000000000000 ) );
3628 zSign ^= 1;
3643 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3697 flag aSign, bSign, zSign;
3708 zSign = aSign ^ bSign;
3715 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3726 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3729 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3733 if ( bSig == 0 ) return packFloatx80( zSign, 0, 0 );
3744 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3756 flag aSign, bSign, zSign;
3768 zSign = aSign ^ bSign;
3775 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3779 return packFloatx80( zSign, 0, 0 );
3791 return packFloatx80( zSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
3796 if ( aSig == 0 ) return packFloatx80( zSign, 0, 0 );
3824 floatx80_rounding_precision, zSign, zExp, zSig0, zSig1 );
3836 flag aSign, bSign, zSign;
3874 zSign = aSign;
3917 zSign = ! zSign;
3921 80, zSign, bExp + expDiff, aSig0, aSig1 );
4587 | floating-point values `a' and `b'. If `zSign' is 1, the sum is negated
4588 | before being returned. `zSign' is ignored if the result is a NaN.
4593 static float128 addFloat128Sigs( float128 a, float128 b, flag zSign )
4624 return packFloat128( zSign, 0x7FFF, 0, 0 );
4644 if ( aExp == 0 ) return packFloat128( zSign, 0, zSig0, zSig1 );
4659 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
4665 | precision floating-point values `a' and `b'. If `zSign' is 1, the
4666 | difference is negated before being returned. `zSign' is ignored if the
4671 static float128 subFloat128Sigs( float128 a, float128 b, flag zSign )
4710 return packFloat128( zSign ^ 1, 0x7FFF, 0, 0 );
4723 zSign ^= 1;
4743 return normalizeRoundAndPackFloat128( zSign, zExp - 14, zSig0, zSig1 );
4797 flag aSign, bSign, zSign;
4810 zSign = aSign ^ bSign;
4817 return packFloat128( zSign, 0x7FFF, 0, 0 );
4828 return packFloat128( zSign, 0x7FFF, 0, 0 );
4831 if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
4835 if ( ( bSig0 | bSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
4849 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
4861 flag aSign, bSign, zSign;
4875 zSign = aSign ^ bSign;
4882 return packFloat128( zSign, 0x7FFF, 0, 0 );
4886 return packFloat128( zSign, 0, 0, 0 );
4898 return packFloat128( zSign, 0x7FFF, 0, 0 );
4903 if ( ( aSig0 | aSig1 ) == 0 ) return packFloat128( zSign, 0, 0, 0 );
4933 return roundAndPackFloat128( zSign, zExp, zSig0, zSig1, zSig2 );
4945 flag aSign, bSign, zSign;
5040 zSign = ( (sbits64) aSig0 < 0 );
5041 if ( zSign ) sub128( 0, 0, aSig0, aSig1, &aSig0, &aSig1 );
5043 normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1 );
Indexes created Thu Nov 06 21:09:53 GMT 2025