[llvm] 052c38b - [APFloat] Properly implement DoubleAPFloat::convertToSignExtendedInteger
David Majnemer via llvm-commits
llvm-commits at lists.llvm.org
Sat Aug 9 23:43:33 PDT 2025
Author: David Majnemer
Date: 2025-08-09T23:23:01-07:00
New Revision: 052c38be824d9dabb1e8fb64c1c7c3908d786e83
URL: https://github.com/llvm/llvm-project/commit/052c38be824d9dabb1e8fb64c1c7c3908d786e83
DIFF: https://github.com/llvm/llvm-project/commit/052c38be824d9dabb1e8fb64c1c7c3908d786e83.diff
LOG: [APFloat] Properly implement DoubleAPFloat::convertToSignExtendedInteger
Use DoubleAPFloat::roundToIntegral to get a pair of APFloat values which
hold integral values. Then we sum the pair, taking care to make sure
that we handle edge cases like (hi=2^128, lo=-1) and ensuring that they
fit in an unsigned i128.
Added:
Modified:
llvm/include/llvm/ADT/APFloat.h
llvm/lib/Support/APFloat.cpp
llvm/unittests/ADT/APFloatTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/ADT/APFloat.h b/llvm/include/llvm/ADT/APFloat.h
index e1589544787cf..a67c05ef2d626 100644
--- a/llvm/include/llvm/ADT/APFloat.h
+++ b/llvm/include/llvm/ADT/APFloat.h
@@ -609,29 +609,10 @@ class IEEEFloat final {
/// return true.
LLVM_ABI bool getExactInverse(APFloat *inv) const;
- // If this is an exact power of two, return the exponent while ignoring the
- // sign bit. If it's not an exact power of 2, return INT_MIN
LLVM_ABI LLVM_READONLY int getExactLog2Abs() const;
- // If this is an exact power of two, return the exponent. If it's not an exact
- // power of 2, return INT_MIN
- LLVM_READONLY
- int getExactLog2() const {
- return isNegative() ? INT_MIN : getExactLog2Abs();
- }
-
- /// Returns the exponent of the internal representation of the APFloat.
- ///
- /// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)).
- /// For special APFloat values, this returns special error codes:
- ///
- /// NaN -> \c IEK_NaN
- /// 0 -> \c IEK_Zero
- /// Inf -> \c IEK_Inf
- ///
LLVM_ABI friend int ilogb(const IEEEFloat &Arg);
- /// Returns: X * 2^Exp for integral exponents.
LLVM_ABI friend IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode);
LLVM_ABI friend IEEEFloat frexp(const IEEEFloat &X, int &Exp, roundingMode);
@@ -806,7 +787,17 @@ class IEEEFloat final {
};
LLVM_ABI hash_code hash_value(const IEEEFloat &Arg);
+/// Returns the exponent of the internal representation of the APFloat.
+///
+/// Because the radix of APFloat is 2, this is equivalent to floor(log2(x)).
+/// For special APFloat values, this returns special error codes:
+///
+/// NaN -> \c IEK_NaN
+/// 0 -> \c IEK_Zero
+/// Inf -> \c IEK_Inf
+///
LLVM_ABI int ilogb(const IEEEFloat &Arg);
+/// Returns: X * 2^Exp for integral exponents.
LLVM_ABI IEEEFloat scalbn(IEEEFloat X, int Exp, roundingMode);
LLVM_ABI IEEEFloat frexp(const IEEEFloat &Val, int &Exp, roundingMode RM);
@@ -824,6 +815,9 @@ class DoubleAPFloat final {
opStatus addWithSpecial(const DoubleAPFloat &LHS, const DoubleAPFloat &RHS,
DoubleAPFloat &Out, roundingMode RM);
+ opStatus convertToSignExtendedInteger(MutableArrayRef<integerPart> Input,
+ unsigned int Width, bool IsSigned,
+ roundingMode RM, bool *IsExact) const;
public:
LLVM_ABI DoubleAPFloat(const fltSemantics &S);
@@ -904,9 +898,9 @@ class DoubleAPFloat final {
LLVM_ABI bool getExactInverse(APFloat *inv) const;
- LLVM_ABI LLVM_READONLY int getExactLog2() const;
LLVM_ABI LLVM_READONLY int getExactLog2Abs() const;
+ LLVM_ABI friend int ilogb(const DoubleAPFloat &X);
LLVM_ABI friend DoubleAPFloat scalbn(const DoubleAPFloat &X, int Exp,
roundingMode);
LLVM_ABI friend DoubleAPFloat frexp(const DoubleAPFloat &X, int &Exp,
@@ -1345,12 +1339,23 @@ class APFloat : public APFloatBase {
LLVM_ABI opStatus convert(const fltSemantics &ToSemantics, roundingMode RM,
bool *losesInfo);
+ // Convert a floating point number to an integer according to the
+ // rounding mode. We provide deterministic values in case of an invalid
+ // operation exception, namely zero for NaNs and the minimal or maximal value
+ // respectively for underflow or overflow.
+ // The *IsExact output tells whether the result is exact, in the sense that
+ // converting it back to the original floating point type produces the
+ // original value. This is almost equivalent to result==opOK, except for
+ // negative zeroes.
opStatus convertToInteger(MutableArrayRef<integerPart> Input,
unsigned int Width, bool IsSigned, roundingMode RM,
bool *IsExact) const {
APFLOAT_DISPATCH_ON_SEMANTICS(
convertToInteger(Input, Width, IsSigned, RM, IsExact));
}
+ // Same as convertToInteger(integerPart*, ...), except the result is returned
+ // in an APSInt, whose initial bit-width and signed-ness are used to determine
+ // the precision of the conversion.
LLVM_ABI opStatus convertToInteger(APSInt &Result, roundingMode RM,
bool *IsExact) const;
opStatus convertFromAPInt(const APInt &Input, bool IsSigned,
@@ -1509,18 +1514,28 @@ class APFloat : public APFloatBase {
APFLOAT_DISPATCH_ON_SEMANTICS(getExactInverse(inv));
}
+ // If this is an exact power of two, return the exponent while ignoring the
+ // sign bit. If it's not an exact power of 2, return INT_MIN
LLVM_READONLY
int getExactLog2Abs() const {
APFLOAT_DISPATCH_ON_SEMANTICS(getExactLog2Abs());
}
+ // If this is an exact power of two, return the exponent. If it's not an exact
+ // power of 2, return INT_MIN
LLVM_READONLY
int getExactLog2() const {
- APFLOAT_DISPATCH_ON_SEMANTICS(getExactLog2());
+ return isNegative() ? INT_MIN : getExactLog2Abs();
}
LLVM_ABI friend hash_code hash_value(const APFloat &Arg);
- friend int ilogb(const APFloat &Arg) { return ilogb(Arg.getIEEE()); }
+ friend int ilogb(const APFloat &Arg) {
+ if (APFloat::usesLayout<detail::IEEEFloat>(Arg.getSemantics()))
+ return ilogb(Arg.getIEEE());
+ if (APFloat::usesLayout<detail::DoubleAPFloat>(Arg.getSemantics()))
+ return ilogb(Arg.getIEEE());
+ llvm_unreachable("Unexpected semantics");
+ }
friend APFloat scalbn(APFloat X, int Exp, roundingMode RM);
friend APFloat frexp(const APFloat &X, int &Exp, roundingMode RM);
friend IEEEFloat;
diff --git a/llvm/lib/Support/APFloat.cpp b/llvm/lib/Support/APFloat.cpp
index 3d688a109cdee..6933e65cc1785 100644
--- a/llvm/lib/Support/APFloat.cpp
+++ b/llvm/lib/Support/APFloat.cpp
@@ -5519,13 +5519,127 @@ APFloat::opStatus DoubleAPFloat::next(bool nextDown) {
return opOK;
}
+APFloat::opStatus DoubleAPFloat::convertToSignExtendedInteger(
+ MutableArrayRef<integerPart> Input, unsigned int Width, bool IsSigned,
+ roundingMode RM, bool *IsExact) const {
+ assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
+
+ // If Hi is not finite, or Lo is zero, the value is entirely represented
+ // by Hi. Delegate to the simpler single-APFloat conversion.
+ if (!getFirst().isFiniteNonZero() || getSecond().isZero())
+ return getFirst().convertToInteger(Input, Width, IsSigned, RM, IsExact);
+
+ // First, round the full double-double value to an integral value. This
+ // simplifies the rest of the function, as we no longer need to consider
+ // fractional parts.
+ *IsExact = false;
+ DoubleAPFloat Integral = *this;
+ const opStatus RoundStatus = Integral.roundToIntegral(RM);
+ if (RoundStatus == opInvalidOp)
+ return RoundStatus;
+ const APFloat &IntegralHi = Integral.getFirst();
+ const APFloat &IntegralLo = Integral.getSecond();
+
+ // If rounding results in either component being zero, the sum is trivial.
+ // Delegate to the simpler single-APFloat conversion.
+ bool HiIsExact;
+ if (IntegralHi.isZero() || IntegralLo.isZero()) {
+ const opStatus HiStatus =
+ IntegralHi.convertToInteger(Input, Width, IsSigned, RM, &HiIsExact);
+ // The conversion from an integer-valued float to an APInt may fail if the
+ // result would be out of range. Regardless, taking this path is only
+ // possible if rounding occured during the initial `roundToIntegral`.
+ return HiStatus == opOK ? opInexact : HiStatus;
+ }
+
+ // A negative number cannot be represented by an unsigned integer.
+ // Since a double-double is canonical, if Hi is negative, the sum is negative.
+ if (!IsSigned && IntegralHi.isNegative())
+ return opInvalidOp;
+
+ // Handle the special boundary case where |Hi| is exactly the power of two
+ // that marks the edge of the integer's range (e.g., 2^63 for int64_t). In
+ // this situation, Hi itself won't fit, but the sum Hi + Lo might.
+ // `PositiveOverflowWidth` is the bit number for this boundary (N-1 for
+ // signed, N for unsigned).
+ bool LoIsExact;
+ const int HiExactLog2 = IntegralHi.getExactLog2Abs();
+ const unsigned PositiveOverflowWidth = IsSigned ? Width - 1 : Width;
+ if (HiExactLog2 >= 0 &&
+ static_cast<unsigned>(HiExactLog2) == PositiveOverflowWidth) {
+ // If Hi and Lo have the same sign, |Hi + Lo| > |Hi|, so the sum is
+ // guaranteed to overflow. E.g., for uint128_t, (2^128, 1) overflows.
+ if (IntegralHi.isNegative() == IntegralLo.isNegative())
+ return opInvalidOp;
+
+ // If the signs
diff er, the sum will fit. We can compute the result using
+ // properties of two's complement arithmetic without a wide intermediate
+ // integer. E.g., for uint128_t, (2^128, -1) should be 2^128 - 1.
+ [[maybe_unused]] opStatus LoStatus = IntegralLo.convertToInteger(
+ Input, Width, /*IsSigned=*/true, RM, &LoIsExact);
+ assert(LoStatus == opOK && "Unexpected failure");
+
+ // Adjust the bit pattern of Lo to account for Hi's value:
+ // - For unsigned (Hi=2^Width): `2^Width + Lo` in `Width`-bit
+ // arithmetic is equivalent to just `Lo`. The conversion of `Lo` above
+ // already produced the correct final bit pattern.
+ // - For signed (Hi=2^(Width-1)): The sum `2^(Width-1) + Lo` (where Lo<0)
+ // can be computed by taking the two's complement pattern for `Lo` and
+ // clearing the sign bit.
+ if (IsSigned && !IntegralHi.isNegative())
+ APInt::tcClearBit(Input.data(), PositiveOverflowWidth);
+ *IsExact = RoundStatus == opOK;
+ return RoundStatus;
+ }
+
+ // General case: Hi is not a power-of-two boundary, so we know it fits.
+ // Since we already rounded the full value, we now just need to convert the
+ // components to integers. The rounding mode should not matter.
+ [[maybe_unused]] opStatus HiStatus = IntegralHi.convertToInteger(
+ Input, Width, IsSigned, rmTowardZero, &HiIsExact);
+ assert(HiStatus == opOK && "Unexpected failure");
+
+ // Convert Lo into a temporary integer of the same width.
+ APSInt LoResult{Width, /*isUnsigned=*/!IsSigned};
+ [[maybe_unused]] opStatus LoStatus =
+ IntegralLo.convertToInteger(LoResult, rmTowardZero, &LoIsExact);
+ assert(LoStatus == opOK && "Unexpected failure");
+
+ // Add Lo to Hi. This addition is guaranteed not to overflow because of the
+ // double-double canonicalization rule (`|Lo| <= ulp(Hi)/2`). The only case
+ // where the sum could cross the integer type's boundary is when Hi is a
+ // power of two, which is handled by the special case block above.
+ APInt::tcAdd(Input.data(), LoResult.getRawData(), /*carry=*/0, Input.size());
+
+ *IsExact = RoundStatus == opOK;
+ return RoundStatus;
+}
+
APFloat::opStatus
DoubleAPFloat::convertToInteger(MutableArrayRef<integerPart> Input,
unsigned int Width, bool IsSigned,
roundingMode RM, bool *IsExact) const {
- assert(Semantics == &semPPCDoubleDouble && "Unexpected Semantics");
- return APFloat(semPPCDoubleDoubleLegacy, bitcastToAPInt())
- .convertToInteger(Input, Width, IsSigned, RM, IsExact);
+ opStatus FS =
+ convertToSignExtendedInteger(Input, Width, IsSigned, RM, IsExact);
+
+ if (FS == opInvalidOp) {
+ const unsigned DstPartsCount = partCountForBits(Width);
+ assert(DstPartsCount <= Parts.size() && "Integer too big");
+
+ unsigned Bits;
+ if (getCategory() == fcNaN)
+ Bits = 0;
+ else if (isNegative())
+ Bits = IsSigned;
+ else
+ Bits = Width - IsSigned;
+
+ tcSetLeastSignificantBits(Input.data(), DstPartsCount, Bits);
+ if (isNegative() && IsSigned)
+ APInt::tcShiftLeft(Input.data(), DstPartsCount, Width - 1);
+ }
+
+ return FS;
}
APFloat::opStatus DoubleAPFloat::convertFromAPInt(const APInt &Input,
@@ -5626,14 +5740,31 @@ bool DoubleAPFloat::getExactInverse(APFloat *inv) const {
return Ret;
}
-int DoubleAPFloat::getExactLog2() const {
- // TODO: Implement me
- return INT_MIN;
-}
-
int DoubleAPFloat::getExactLog2Abs() const {
- // TODO: Implement me
- return INT_MIN;
+ // In order for Hi + Lo to be a power of two, the following must be true:
+ // 1. Hi must be a power of two.
+ // 2. Lo must be zero.
+ if (getSecond().isNonZero())
+ return INT_MIN;
+ return getFirst().getExactLog2Abs();
+}
+
+int ilogb(const DoubleAPFloat& Arg) {
+ const APFloat& Hi = Arg.getFirst();
+ const APFloat& Lo = Arg.getSecond();
+ int IlogbResult = ilogb(Hi);
+ // Zero and non-finite values can delegate to ilogb(Hi).
+ if (Arg.getCategory() != fcNormal)
+ return IlogbResult;
+ // If Lo can't change the binade, we can delegate to ilogb(Hi).
+ if (Lo.isZero() ||
+ Hi.isNegative() == Lo.isNegative())
+ return IlogbResult;
+ if (Hi.getExactLog2Abs() == INT_MIN)
+ return IlogbResult;
+ // Numbers of the form 2^a - 2^b or -2^a + 2^b are almost powers of two but
+ // get nudged out of the binade by the low component.
+ return IlogbResult - 1;
}
DoubleAPFloat scalbn(const DoubleAPFloat &Arg, int Exp,
@@ -5749,10 +5880,6 @@ void APFloat::Profile(FoldingSetNodeID &NID) const {
NID.Add(bitcastToAPInt());
}
-/* Same as convertToInteger(integerPart*, ...), except the result is returned in
- an APSInt, whose initial bit-width and signed-ness are used to determine the
- precision of the conversion.
- */
APFloat::opStatus APFloat::convertToInteger(APSInt &result,
roundingMode rounding_mode,
bool *isExact) const {
diff --git a/llvm/unittests/ADT/APFloatTest.cpp b/llvm/unittests/ADT/APFloatTest.cpp
index a35594d4afed4..3fcd7ecc2eb2c 100644
--- a/llvm/unittests/ADT/APFloatTest.cpp
+++ b/llvm/unittests/ADT/APFloatTest.cpp
@@ -5799,6 +5799,359 @@ TEST_P(PPCDoubleDoubleRoundToIntegralValueTest,
}
}
+namespace PPCDoubleDoubleConvertToIntegerTestDetails {
+// Define the rounding modes for easier readability.
+static constexpr auto RNE = APFloat::rmNearestTiesToEven;
+static constexpr auto RNA = APFloat::rmNearestTiesToAway;
+static constexpr auto RTZ = APFloat::rmTowardZero;
+static constexpr auto RTP = APFloat::rmTowardPositive;
+static constexpr auto RTN = APFloat::rmTowardNegative;
+
+struct TestCase {
+ // Structure to hold the expected result of a conversion
+ struct ExpectedConversion {
+ // The expected integer value represented as a string (decimal).
+ // We use a string to easily represent arbitrary precision values in
+ // constexpr. The test runner should parse this into an APSInt matching the
+ // test configuration.
+ const char *ExpectedIntStr;
+ APFloat::opStatus Status;
+ };
+
+ DD Input;
+ unsigned IntegerWidth;
+ bool IsSigned;
+ // Array indexed by the rounding mode enum value.
+ std::array<ExpectedConversion, 5> Rounded = {};
+
+ // Helper to define the expected results for a specific rounding mode.
+ constexpr TestCase &with(APFloat::roundingMode RM, const char *ExpectedStr,
+ APFloat::opStatus Status) {
+ Rounded[static_cast<std::underlying_type_t<APFloat::roundingMode>>(RM)] = {
+ ExpectedStr,
+ Status,
+ };
+ return *this;
+ }
+
+ // Helper to define the same result for all rounding modes.
+ constexpr TestCase &withAll(const char *ExpectedStr,
+ APFloat::opStatus Status) {
+ return with(RNE, ExpectedStr, Status)
+ .with(RNA, ExpectedStr, Status)
+ .with(RTZ, ExpectedStr, Status)
+ .with(RTP, ExpectedStr, Status)
+ .with(RTN, ExpectedStr, Status);
+ }
+};
+
+auto testCases() {
+ // Define the status codes.
+ constexpr auto OK = llvm::APFloat::opOK;
+ constexpr auto Inexact = llvm::APFloat::opInexact;
+ // The API specifies opInvalidOp for out-of-range (overflow/underflow) and
+ // NaN.
+ constexpr auto Invalid = llvm::APFloat::opInvalidOp;
+
+ // Helper constants for constructing specific DD values.
+ constexpr double Infinity = std::numeric_limits<double>::infinity();
+ constexpr double NaN = std::numeric_limits<double>::quiet_NaN();
+ constexpr double DMAX = std::numeric_limits<double>::max();
+
+ // Powers of 2
+ constexpr double P53 = 0x1p53;
+ constexpr double P63 = 0x1p63;
+ constexpr double P64 = 0x1p64;
+ // 2^-100 (A very small delta demonstrating extended precision)
+ constexpr double PM100 = 0x1p-100;
+
+ static constexpr auto ConvertToIntegerTestCases = std::array{
+ // 1. Zeros, NaNs, and Infinities (Target: 64-bit Signed)
+ // INT64_MAX = 9223372036854775807
+ // INT64_MIN = -9223372036854775808
+
+ // Input: Positive Zero (0.0, 0.0)
+ TestCase{{0.0, 0.0}, 64, true}.withAll("0", OK),
+
+ // Input: Negative Zero (-0.0, 0.0)
+ TestCase{{-0.0, 0.0}, 64, true}.withAll("0", OK),
+
+ // Input: NaN. Expected behavior: Invalid, deterministic result of 0.
+ TestCase{{NaN, 0.0}, 64, true}.withAll("0", Invalid),
+
+ // Input: +Infinity. Expected behavior: Invalid, deterministic result of
+ // INT64_MAX.
+ TestCase{{Infinity, 0.0}, 64, true}.withAll("9223372036854775807",
+ Invalid),
+
+ // Input: -Infinity. Expected behavior: Invalid, deterministic result of
+ // INT64_MIN.
+ TestCase{{-Infinity, 0.0}, 64, true}.withAll("-9223372036854775808",
+ Invalid),
+
+ // 2. Basic Rounding and Tie-Breaking (Target: 32-bit Signed)
+
+ // Input: 2.5 (Tie, preceding integer is Even)
+ TestCase{{2.5, 0.0}, 32, true}
+ .with(RTZ, "2", Inexact)
+ .with(RTN, "2", Inexact)
+ .with(RTP, "3", Inexact)
+ .with(RNA, "3", Inexact)
+ .with(RNE, "2", Inexact),
+
+ // Input: 3.5 (Tie, preceding integer is Odd)
+ TestCase{{3.5, 0.0}, 32, true}
+ .with(RTZ, "3", Inexact)
+ .with(RTN, "3", Inexact)
+ .with(RTP, "4", Inexact)
+ .with(RNA, "4", Inexact)
+ .with(RNE, "4", Inexact),
+
+ // Input: -2.5 (Tie, preceding integer is Even)
+ TestCase{{-2.5, 0.0}, 32, true}
+ .with(RTZ, "-2", Inexact)
+ .with(RTN, "-3", Inexact)
+ .with(RTP, "-2", Inexact)
+ .with(RNA, "-3", Inexact)
+ .with(RNE, "-2", Inexact),
+
+ // 3. Double-Double Precision (The role of 'lo')
+ // Testing how extended precision affects rounding decisions.
+
+ // Input: 2.5 + Epsilon (Slightly above tie)
+ TestCase{{2.5, PM100}, 32, true}
+ .with(RTZ, "2", Inexact)
+ .with(RTN, "2", Inexact)
+ .with(RTP, "3", Inexact)
+ .with(RNA, "3", Inexact)
+ .with(RNE, "3", Inexact),
+
+ // Input: 2.5 - Epsilon (Slightly below tie)
+ TestCase{{2.5, -PM100}, 32, true}
+ .with(RTZ, "2", Inexact)
+ .with(RTN, "2", Inexact)
+ .with(RTP, "3", Inexact)
+ .with(RNA, "2", Inexact)
+ .with(RNE, "2", Inexact),
+
+ // Input: 1.0 + Epsilon (Just above 1.0, e.g., 1.00...1)
+ TestCase{{1.0, PM100}, 32, true}
+ .with(RTZ, "1", Inexact)
+ .with(RTN, "1", Inexact)
+ .with(RTP, "2", Inexact)
+ .with(RNA, "1", Inexact)
+ .with(RNE, "1", Inexact),
+
+ // Input: 1.0 - Epsilon (Just below 1.0, e.g. 0.999...)
+ TestCase{{1.0, -PM100}, 32, true}
+ .with(RTZ, "0", Inexact)
+ .with(RTN, "0", Inexact)
+ .with(RTP, "1", Inexact)
+ .with(RNA, "1", Inexact)
+ .with(RNE, "1", Inexact),
+
+ // Input: Large number tie-breaking (Crucial test for DD implementation)
+ // Input: 2^53 + 1.5.
+ // A standard double(2^53 + 1.5) rounds to 2^53 + 2.0.
+ // The DD representation must precisely hold 2^53 + 1.5.
+ // The canonical DD representation is {2^53 + 2.0, -0.5}.
+ // Value is 9007199254740993.5
+ TestCase{{P53 + 2.0, -0.5}, 64, true}
+ .with(RTZ, "9007199254740993", Inexact)
+ .with(RTN, "9007199254740993", Inexact)
+ .with(RTP, "9007199254740994", Inexact)
+ .with(RNA, "9007199254740994", Inexact)
+ .with(RNE, "9007199254740994", Inexact),
+
+ // 4. Overflow Boundaries (Signed)
+
+ // Input: Exactly INT64_MAX. (2^63 - 1)
+ // Represented precisely as (2^63, -1.0)
+ TestCase{{P63, -1.0}, 64, true}.withAll("9223372036854775807", OK),
+
+ // Input: INT64_MAX + 0.3.
+ // Represented as (2^63, -0.7)
+ TestCase{{P63, -0.7}, 64, true}
+ .with(RTZ, "9223372036854775807", Inexact)
+ .with(RTN, "9223372036854775807", Inexact)
+ .with(RNA, "9223372036854775807", Inexact)
+ .with(RNE, "9223372036854775807", Inexact)
+ .with(RTP, "9223372036854775807", Invalid),
+
+ // Input: INT64_MAX + 0.5 (Tie at the boundary)
+ // Represented as (2^63, -0.5). Target integers are MAX (odd) and 2^63
+ // (even).
+ TestCase{{P63, -0.5}, 64, true}
+ .with(RTZ, "9223372036854775807", Inexact)
+ .with(RTN, "9223372036854775807", Inexact)
+ .with(RTP, "9223372036854775807", Invalid)
+ .with(RNA, "9223372036854775807", Invalid)
+ .with(RNE, "9223372036854775807", Invalid),
+
+ // Input: 2^55 - 2^1 - 2^-52 to signed integer.
+ // Represented as (2^55 - 2^2, 2^1 - 2^-1).
+ TestCase{{0x1.fffffffffffffp+54, 0x1.8p0}, 56, true}
+ .with(RTZ, "36028797018963965", Inexact)
+ .with(RTN, "36028797018963965", Inexact)
+ .with(RTP, "36028797018963966", Inexact)
+ .with(RNA, "36028797018963966", Inexact)
+ .with(RNE, "36028797018963966", Inexact),
+
+ // Input: 2^55 - 2^1 - 2^-52 to signed integer.
+ // Represented as (2^55 - 2^2, 2^1 - 2^-52).
+ TestCase{{0x1.fffffffffffffp+54, 0x1.fffffffffffffp0}, 56, true}
+ .with(RTZ, "36028797018963965", Inexact)
+ .with(RTN, "36028797018963965", Inexact)
+ .with(RTP, "36028797018963966", Inexact)
+ .with(RNA, "36028797018963966", Inexact)
+ .with(RNE, "36028797018963966", Inexact),
+
+ // Input: Exactly 2^63 (One past INT64_MAX)
+ TestCase{{P63, 0.0}, 64, true}.withAll("9223372036854775807", Invalid),
+
+ // Input: Exactly INT64_MIN (-2^63)
+ TestCase{{-P63, 0.0}, 64, true}.withAll("-9223372036854775808", OK),
+
+ // Input: INT64_MIN - 0.5 (Tie at the lower boundary)
+ // Target integers are -2^63-1 (odd) and MIN (even).
+ TestCase{{-P63, -0.5}, 64, true}
+ .with(RTZ, "-9223372036854775808", Inexact)
+ .with(RTP, "-9223372036854775808", Inexact)
+ // RTN rounds down, causing overflow.
+ .with(RTN, "-9223372036854775808", Invalid)
+ // RNA rounds away (down), causing overflow.
+ .with(RNA, "-9223372036854775808", Invalid)
+ // RNE rounds to even (up to -2^63), which is OK.
+ .with(RNE, "-9223372036854775808", Inexact),
+
+ // 5. Overflow Boundaries (Unsigned)
+ // UINT64_MAX = 18446744073709551615 (2^64 - 1)
+
+ // Input: Exactly UINT64_MAX. (2^64 - 1)
+ // Represented precisely as (2^64, -1.0)
+ TestCase{{P64, -1.0}, 64, false}.withAll("18446744073709551615", OK),
+
+ // Input: UINT64_MAX + 0.5 (Tie at the boundary)
+ // Represented as (2^64, -0.5)
+ TestCase{{P64, -0.5}, 64, false}
+ .with(RTZ, "18446744073709551615", Inexact)
+ .with(RTN, "18446744073709551615", Inexact)
+ // RTP rounds up (2^64), causing overflow.
+ .with(RTP, "18446744073709551615", Invalid)
+ // RNA rounds away (up), causing overflow.
+ .with(RNA, "18446744073709551615", Invalid)
+ // RNE rounds to even (up to 2^64), causing overflow.
+ .with(RNE, "18446744073709551615", Invalid),
+
+ // Input: 2^55 - 2^1 - 2^-52 to unsigned integer.
+ // Represented as (2^55 - 2^2, 2^1 - 2^-1).
+ TestCase{{0x1.fffffffffffffp+54, 0x1.8p0}, 55, false}
+ .with(RTZ, "36028797018963965", Inexact)
+ .with(RTN, "36028797018963965", Inexact)
+ .with(RTP, "36028797018963966", Inexact)
+ .with(RNA, "36028797018963966", Inexact)
+ .with(RNE, "36028797018963966", Inexact),
+
+ // Input: 2^55 - 2^1 - 2^-52 to unsigned integer.
+ // Represented as (2^55 - 2^2, 2^1 - 2^-52).
+ TestCase{{0x1.fffffffffffffp+54, 0x1.fffffffffffffp0}, 55, false}
+ .with(RTZ, "36028797018963965", Inexact)
+ .with(RTN, "36028797018963965", Inexact)
+ .with(RTP, "36028797018963966", Inexact)
+ .with(RNA, "36028797018963966", Inexact)
+ .with(RNE, "36028797018963966", Inexact),
+
+ // Input: -0.3 (Slightly below zero)
+ TestCase{{-0.3, 0.0}, 64, false}
+ .with(RTZ, "0", Inexact)
+ .with(RTP, "0", Inexact)
+ .with(RNA, "0", Inexact)
+ .with(RNE, "0", Inexact)
+ .with(RTN, "0", Invalid),
+
+ // Input: -0.5 (Tie at zero)
+ TestCase{{-0.5, 0.0}, 64, false}
+ .with(RTZ, "0", Inexact)
+ .with(RTP, "0", Inexact)
+ // RNE rounds to even (0).
+ .with(RNE, "0", Inexact)
+ .with(RTN, "0", Invalid)
+ // RNA rounds away (-1), causing overflow.
+ .with(RNA, "0", Invalid),
+
+ // Input: -1.0 (Negative integer)
+ TestCase{{-1.0, 0.0}, 64, false}.withAll("0", Invalid),
+
+ // 6. High Precision Integers (Target: 128-bit Signed)
+ // INT128_MAX = 170141183460469231731687303715884105727
+
+ // Input: 2^100 (Exactly representable in DD)
+ // 2^100 = 1267650600228229401496703205376.0
+ TestCase{{1267650600228229401496703205376.0, 0.0}, 128, true}.withAll(
+ "1267650600228229401496703205376", OK),
+
+ // Input: DMAX. (Approx 1.8e308).
+ // This is vastly larger than INT128_MAX (Approx 1.7e38).
+ TestCase{{DMAX, 0.0}, 128, true}.withAll(
+ "170141183460469231731687303715884105727", Invalid),
+
+ // 7. Round to negative -0
+ TestCase{{-PM100, 0.0}, 32, true}
+ .with(RTZ, "0", Inexact)
+ .with(RTP, "0", Inexact)
+ .with(RNA, "0", Inexact)
+ .with(RNE, "0", Inexact)
+ .with(RTN, "-1", Inexact),
+ };
+ return ConvertToIntegerTestCases;
+}
+} // namespace PPCDoubleDoubleConvertToIntegerTestDetails
+
+class PPCDoubleDoubleConvertToIntegerValueTest
+ : public testing::Test,
+ public ::testing::WithParamInterface<
+ PPCDoubleDoubleConvertToIntegerTestDetails::TestCase> {};
+
+INSTANTIATE_TEST_SUITE_P(
+ PPCDoubleDoubleConvertToIntegerValueParamTests,
+ PPCDoubleDoubleConvertToIntegerValueTest,
+ ::testing::ValuesIn(
+ PPCDoubleDoubleConvertToIntegerTestDetails::testCases()));
+
+TEST_P(PPCDoubleDoubleConvertToIntegerValueTest,
+ PPCDoubleDoubleConvertToInteger) {
+ const PPCDoubleDoubleConvertToIntegerTestDetails::TestCase Params =
+ GetParam();
+ const APFloat Input = makeDoubleAPFloat(Params.Input);
+ EXPECT_FALSE(Input.isDenormal())
+ << Params.Input.Hi << " + " << Params.Input.Lo;
+
+ for (size_t I = 0, E = std::size(Params.Rounded); I != E; ++I) {
+ const auto RM = static_cast<APFloat::roundingMode>(I);
+ const auto &Expected = Params.Rounded[I];
+ APSInt ActualInteger(Params.IntegerWidth, /*isUnsigned=*/!Params.IsSigned);
+
+ APSInt ExpectedInteger{Expected.ExpectedIntStr};
+ EXPECT_LE(ExpectedInteger.getBitWidth(), Params.IntegerWidth);
+ ExpectedInteger = ExpectedInteger.extend(Params.IntegerWidth);
+ if (ExpectedInteger.isUnsigned() && Params.IsSigned) {
+ ExpectedInteger.setIsSigned(Params.IsSigned);
+ EXPECT_FALSE(ExpectedInteger.isNegative());
+ }
+
+ const bool NegativeUnderflow =
+ ExpectedInteger.isZero() && Input.isNegative();
+ const bool ExpectedIsExact =
+ Expected.Status == APFloat::opOK && !NegativeUnderflow;
+ bool ActualIsExact;
+ const auto ActualStatus =
+ Input.convertToInteger(ActualInteger, RM, &ActualIsExact);
+ EXPECT_EQ(ActualStatus, Expected.Status);
+ EXPECT_EQ(ActualIsExact, ExpectedIsExact);
+ EXPECT_EQ(ActualInteger, ExpectedInteger);
+ }
+}
+
TEST(APFloatTest, PPCDoubleDoubleCompare) {
using DataType =
std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>;
@@ -8259,13 +8612,8 @@ TEST(APFloatTest, getExactLog2) {
continue;
APFloat One(Semantics, "1.0");
-
- if (I == APFloat::S_PPCDoubleDouble) {
- // Not implemented
- EXPECT_EQ(INT_MIN, One.getExactLog2());
- EXPECT_EQ(INT_MIN, One.getExactLog2Abs());
- continue;
- }
+ APFloat Smallest = APFloat::getSmallest(Semantics);
+ APFloat Largest = APFloat::getLargest(Semantics);
int MinExp = APFloat::semanticsMinExponent(Semantics);
int MaxExp = APFloat::semanticsMaxExponent(Semantics);
@@ -8312,16 +8660,15 @@ TEST(APFloatTest, getExactLog2) {
EXPECT_EQ(INT_MIN, APFloat::getNaN(Semantics, true).getExactLog2Abs());
}
- EXPECT_EQ(INT_MIN,
- scalbn(One, MinExp - Precision - 1, APFloat::rmNearestTiesToEven)
- .getExactLog2());
- EXPECT_EQ(INT_MIN,
- scalbn(One, MinExp - Precision, APFloat::rmNearestTiesToEven)
- .getExactLog2());
-
EXPECT_EQ(
INT_MIN,
- scalbn(One, MaxExp + 1, APFloat::rmNearestTiesToEven).getExactLog2());
+ scalbn(Smallest, -2, APFloat::rmNearestTiesToEven).getExactLog2());
+ EXPECT_EQ(
+ INT_MIN,
+ scalbn(Smallest, -1, APFloat::rmNearestTiesToEven).getExactLog2());
+
+ EXPECT_EQ(INT_MIN,
+ scalbn(Largest, 1, APFloat::rmNearestTiesToEven).getExactLog2());
for (int i = MinExp - Precision + 1; i <= MaxExp; ++i) {
EXPECT_EQ(i, scalbn(One, i, APFloat::rmNearestTiesToEven).getExactLog2());
More information about the llvm-commits
mailing list