| //===- ConstantRangeTest.cpp - ConstantRange tests ------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/IR/ConstantFPRange.h" |
| #include "llvm/IR/Instructions.h" |
| #include "llvm/IR/Operator.h" |
| #include "gtest/gtest.h" |
| |
| using namespace llvm; |
| |
| namespace { |
| |
| class ConstantFPRangeTest : public ::testing::Test { |
| protected: |
| static const fltSemantics &Sem; |
| static ConstantFPRange Full; |
| static ConstantFPRange Empty; |
| static ConstantFPRange Finite; |
| static ConstantFPRange One; |
| static ConstantFPRange PosZero; |
| static ConstantFPRange NegZero; |
| static ConstantFPRange Zero; |
| static ConstantFPRange PosInf; |
| static ConstantFPRange NegInf; |
| static ConstantFPRange Denormal; |
| static ConstantFPRange NaN; |
| static ConstantFPRange SNaN; |
| static ConstantFPRange QNaN; |
| static ConstantFPRange Some; |
| static ConstantFPRange SomePos; |
| static ConstantFPRange SomeNeg; |
| }; |
| |
| const fltSemantics &ConstantFPRangeTest::Sem = APFloat::IEEEdouble(); |
| ConstantFPRange ConstantFPRangeTest::Full = |
| ConstantFPRange::getFull(APFloat::IEEEdouble()); |
| ConstantFPRange ConstantFPRangeTest::Empty = |
| ConstantFPRange::getEmpty(APFloat::IEEEdouble()); |
| ConstantFPRange ConstantFPRangeTest::Finite = |
| ConstantFPRange::getFinite(APFloat::IEEEdouble()); |
| ConstantFPRange ConstantFPRangeTest::One = ConstantFPRange(APFloat(1.0)); |
| ConstantFPRange ConstantFPRangeTest::PosZero = ConstantFPRange( |
| APFloat::getZero(APFloat::IEEEdouble(), /*Negative=*/false)); |
| ConstantFPRange ConstantFPRangeTest::NegZero = |
| ConstantFPRange(APFloat::getZero(APFloat::IEEEdouble(), /*Negative=*/true)); |
| ConstantFPRange ConstantFPRangeTest::Zero = ConstantFPRange::getNonNaN( |
| APFloat::getZero(APFloat::IEEEdouble(), /*Negative=*/true), |
| APFloat::getZero(APFloat::IEEEdouble(), /*Negative=*/false)); |
| ConstantFPRange ConstantFPRangeTest::Denormal = |
| ConstantFPRange(APFloat::getSmallest(APFloat::IEEEdouble())); |
| ConstantFPRange ConstantFPRangeTest::PosInf = |
| ConstantFPRange(APFloat::getInf(APFloat::IEEEdouble(), /*Negative=*/false)); |
| ConstantFPRange ConstantFPRangeTest::NegInf = |
| ConstantFPRange(APFloat::getInf(APFloat::IEEEdouble(), /*Negative=*/true)); |
| ConstantFPRange ConstantFPRangeTest::NaN = ConstantFPRange::getNaNOnly( |
| APFloat::IEEEdouble(), /*MayBeQNaN=*/true, /*MayBeSNaN=*/true); |
| ConstantFPRange ConstantFPRangeTest::SNaN = |
| ConstantFPRange(APFloat::getSNaN(APFloat::IEEEdouble())); |
| ConstantFPRange ConstantFPRangeTest::QNaN = |
| ConstantFPRange(APFloat::getQNaN(APFloat::IEEEdouble())); |
| ConstantFPRange ConstantFPRangeTest::Some = |
| ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(3.0)); |
| ConstantFPRange ConstantFPRangeTest::SomePos = ConstantFPRange::getNonNaN( |
| APFloat::getZero(APFloat::IEEEdouble(), /*Negative=*/false), APFloat(3.0)); |
| ConstantFPRange ConstantFPRangeTest::SomeNeg = ConstantFPRange::getNonNaN( |
| APFloat(-3.0), APFloat::getZero(APFloat::IEEEdouble(), /*Negative=*/true)); |
| |
| static void strictNext(APFloat &V) { |
| // Note: nextUp(+/-0) is smallest. |
| if (V.isNegZero()) |
| V = APFloat::getZero(V.getSemantics(), /*Negative=*/false); |
| else |
| V.next(/*nextDown=*/false); |
| } |
| |
| template <typename Fn> |
| static void EnumerateConstantFPRangesImpl(Fn TestFn, bool Exhaustive, |
| bool MayBeQNaN, bool MayBeSNaN) { |
| const fltSemantics &Sem = APFloat::Float8E4M3(); |
| APFloat PosInf = APFloat::getInf(Sem, /*Negative=*/false); |
| APFloat NegInf = APFloat::getInf(Sem, /*Negative=*/true); |
| TestFn(ConstantFPRange(PosInf, NegInf, MayBeQNaN, MayBeSNaN)); |
| |
| if (!Exhaustive) { |
| SmallVector<APFloat, 36> Values; |
| Values.push_back(APFloat::getInf(Sem, /*Negative=*/true)); |
| Values.push_back(APFloat::getLargest(Sem, /*Negative=*/true)); |
| unsigned BitWidth = APFloat::semanticsSizeInBits(Sem); |
| unsigned Exponents = APFloat::semanticsMaxExponent(Sem) - |
| APFloat::semanticsMinExponent(Sem) + 3; |
| unsigned MantissaBits = APFloat::semanticsPrecision(Sem) - 1; |
| // Add -2^(max exponent), -2^(max exponent-1), ..., -2^(min exponent) |
| for (unsigned M = Exponents - 2; M != 0; --M) |
| Values.push_back( |
| APFloat(Sem, APInt(BitWidth, (M + Exponents) << MantissaBits))); |
| Values.push_back(APFloat::getSmallest(Sem, /*Negative=*/true)); |
| Values.push_back(APFloat::getZero(Sem, /*Negative=*/true)); |
| size_t E = Values.size(); |
| for (size_t I = 1; I <= E; ++I) |
| Values.push_back(-Values[E - I]); |
| for (size_t I = 0; I != Values.size(); ++I) |
| for (size_t J = I; J != Values.size(); ++J) |
| TestFn(ConstantFPRange(Values[I], Values[J], MayBeQNaN, MayBeSNaN)); |
| return; |
| } |
| |
| auto Next = [&](APFloat &V) { |
| if (V.isPosInfinity()) |
| return false; |
| strictNext(V); |
| return true; |
| }; |
| |
| APFloat Lower = NegInf; |
| do { |
| APFloat Upper = Lower; |
| do { |
| TestFn(ConstantFPRange(Lower, Upper, MayBeQNaN, MayBeSNaN)); |
| } while (Next(Upper)); |
| } while (Next(Lower)); |
| } |
| |
| template <typename Fn> |
| static void EnumerateConstantFPRanges(Fn TestFn, bool Exhaustive) { |
| EnumerateConstantFPRangesImpl(TestFn, Exhaustive, /*MayBeQNaN=*/false, |
| /*MayBeSNaN=*/false); |
| EnumerateConstantFPRangesImpl(TestFn, Exhaustive, /*MayBeQNaN=*/false, |
| /*MayBeSNaN=*/true); |
| EnumerateConstantFPRangesImpl(TestFn, Exhaustive, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/false); |
| EnumerateConstantFPRangesImpl(TestFn, Exhaustive, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/true); |
| } |
| |
| template <typename Fn> |
| static void EnumerateTwoInterestingConstantFPRanges(Fn TestFn, |
| bool Exhaustive) { |
| EnumerateConstantFPRanges( |
| [&](const ConstantFPRange &CR1) { |
| EnumerateConstantFPRanges( |
| [&](const ConstantFPRange &CR2) { TestFn(CR1, CR2); }, Exhaustive); |
| }, |
| Exhaustive); |
| } |
| |
| template <typename Fn> |
| static void EnumerateValuesInConstantFPRange(const ConstantFPRange &CR, |
| Fn TestFn, bool IgnoreNaNPayload) { |
| const fltSemantics &Sem = CR.getSemantics(); |
| if (IgnoreNaNPayload) { |
| if (CR.containsSNaN()) { |
| TestFn(APFloat::getSNaN(Sem, false)); |
| TestFn(APFloat::getSNaN(Sem, true)); |
| } |
| if (CR.containsQNaN()) { |
| TestFn(APFloat::getQNaN(Sem, false)); |
| TestFn(APFloat::getQNaN(Sem, true)); |
| } |
| if (CR.isNaNOnly()) |
| return; |
| APFloat Lower = CR.getLower(); |
| const APFloat &Upper = CR.getUpper(); |
| auto Next = [&](APFloat &V) { |
| if (V.bitwiseIsEqual(Upper)) |
| return false; |
| strictNext(V); |
| return true; |
| }; |
| do |
| TestFn(Lower); |
| while (Next(Lower)); |
| } else { |
| unsigned Bits = APFloat::semanticsSizeInBits(Sem); |
| assert(Bits < 32 && "Too many bits"); |
| for (unsigned I = 0, E = (1U << Bits) - 1; I != E; ++I) { |
| APFloat V(Sem, APInt(Bits, I)); |
| if (CR.contains(V)) |
| TestFn(V); |
| } |
| } |
| } |
| |
| template <typename Fn> |
| static bool AnyOfValueInConstantFPRange(const ConstantFPRange &CR, Fn TestFn, |
| bool IgnoreNaNPayload) { |
| const fltSemantics &Sem = CR.getSemantics(); |
| if (IgnoreNaNPayload) { |
| if (CR.containsSNaN()) { |
| if (TestFn(APFloat::getSNaN(Sem, false))) |
| return true; |
| if (TestFn(APFloat::getSNaN(Sem, true))) |
| return true; |
| } |
| if (CR.containsQNaN()) { |
| if (TestFn(APFloat::getQNaN(Sem, false))) |
| return true; |
| if (TestFn(APFloat::getQNaN(Sem, true))) |
| return true; |
| } |
| if (CR.isNaNOnly()) |
| return false; |
| APFloat Lower = CR.getLower(); |
| const APFloat &Upper = CR.getUpper(); |
| auto Next = [&](APFloat &V) { |
| if (V.bitwiseIsEqual(Upper)) |
| return false; |
| strictNext(V); |
| return true; |
| }; |
| do { |
| if (TestFn(Lower)) |
| return true; |
| } while (Next(Lower)); |
| } else { |
| unsigned Bits = APFloat::semanticsSizeInBits(Sem); |
| assert(Bits < 32 && "Too many bits"); |
| for (unsigned I = 0, E = (1U << Bits) - 1; I != E; ++I) { |
| APFloat V(Sem, APInt(Bits, I)); |
| if (CR.contains(V) && TestFn(V)) |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| TEST_F(ConstantFPRangeTest, Basics) { |
| EXPECT_TRUE(Full.isFullSet()); |
| EXPECT_FALSE(Full.isEmptySet()); |
| EXPECT_TRUE(Full.contains(APFloat::getNaN(Sem))); |
| EXPECT_TRUE(Full.contains(APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_TRUE(Full.contains(APFloat::getInf(Sem, /*Negative=*/true))); |
| EXPECT_TRUE(Full.contains(APFloat::getZero(Sem, /*Negative=*/false))); |
| EXPECT_TRUE(Full.contains(APFloat::getZero(Sem, /*Negative=*/true))); |
| EXPECT_TRUE(Full.contains(APFloat::getSmallest(Sem))); |
| EXPECT_TRUE(Full.contains(APFloat(2.0))); |
| EXPECT_TRUE(Full.contains(Full)); |
| EXPECT_TRUE(Full.contains(Empty)); |
| EXPECT_TRUE(Full.contains(Finite)); |
| EXPECT_TRUE(Full.contains(Zero)); |
| EXPECT_TRUE(Full.contains(Some)); |
| |
| EXPECT_FALSE(Empty.isFullSet()); |
| EXPECT_TRUE(Empty.isEmptySet()); |
| EXPECT_FALSE(Empty.contains(APFloat::getNaN(Sem))); |
| EXPECT_FALSE(Empty.contains(APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_FALSE(Empty.contains(APFloat::getZero(Sem, /*Negative=*/true))); |
| EXPECT_FALSE(Empty.contains(APFloat(2.0))); |
| EXPECT_TRUE(Empty.contains(Empty)); |
| |
| EXPECT_FALSE(Finite.isFullSet()); |
| EXPECT_FALSE(Finite.isEmptySet()); |
| EXPECT_FALSE(Finite.contains(APFloat::getNaN(Sem))); |
| EXPECT_FALSE(Finite.contains(APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_FALSE(Finite.contains(APFloat::getInf(Sem, /*Negative=*/true))); |
| EXPECT_TRUE(Finite.contains(APFloat::getLargest(Sem, /*Negative=*/false))); |
| EXPECT_TRUE(Finite.contains(APFloat::getLargest(Sem, /*Negative=*/true))); |
| EXPECT_TRUE(Finite.contains(Finite)); |
| EXPECT_TRUE(Finite.contains(Some)); |
| EXPECT_TRUE(Finite.contains(Denormal)); |
| EXPECT_TRUE(Finite.contains(Zero)); |
| EXPECT_FALSE(Finite.contains(PosInf)); |
| EXPECT_FALSE(Finite.contains(NaN)); |
| |
| EXPECT_TRUE(One.contains(APFloat(1.0))); |
| EXPECT_FALSE(One.contains(APFloat(1.1))); |
| |
| EXPECT_TRUE(PosZero.contains(APFloat::getZero(Sem, /*Negative=*/false))); |
| EXPECT_FALSE(PosZero.contains(APFloat::getZero(Sem, /*Negative=*/true))); |
| EXPECT_TRUE(NegZero.contains(APFloat::getZero(Sem, /*Negative=*/true))); |
| EXPECT_FALSE(NegZero.contains(APFloat::getZero(Sem, /*Negative=*/false))); |
| EXPECT_TRUE(Zero.contains(PosZero)); |
| EXPECT_TRUE(Zero.contains(NegZero)); |
| EXPECT_TRUE(Denormal.contains(APFloat::getSmallest(Sem))); |
| EXPECT_FALSE(Denormal.contains(APFloat::getSmallestNormalized(Sem))); |
| EXPECT_TRUE(PosInf.contains(APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_TRUE(NegInf.contains(APFloat::getInf(Sem, /*Negative=*/true))); |
| EXPECT_TRUE(NaN.contains(APFloat::getQNaN(Sem))); |
| EXPECT_TRUE(NaN.contains(APFloat::getSNaN(Sem))); |
| EXPECT_TRUE(NaN.contains(SNaN)); |
| EXPECT_TRUE(NaN.contains(QNaN)); |
| |
| EXPECT_TRUE(Some.contains(APFloat(3.0))); |
| EXPECT_TRUE(Some.contains(APFloat(-3.0))); |
| EXPECT_FALSE(Some.contains(APFloat(4.0))); |
| APFloat Next1(3.0); |
| Next1.next(/*nextDown=*/true); |
| EXPECT_TRUE(Some.contains(Next1)); |
| APFloat Next2(3.0); |
| Next2.next(/*nextDown=*/false); |
| EXPECT_FALSE(Some.contains(Next2)); |
| EXPECT_TRUE(Some.contains(Zero)); |
| EXPECT_TRUE(Some.contains(Some)); |
| EXPECT_TRUE(Some.contains(One)); |
| EXPECT_FALSE(Some.contains(NaN)); |
| EXPECT_FALSE(Some.contains(PosInf)); |
| EXPECT_TRUE(SomePos.contains(APFloat(3.0))); |
| EXPECT_FALSE(SomeNeg.contains(APFloat(3.0))); |
| EXPECT_TRUE(SomeNeg.contains(APFloat(-3.0))); |
| EXPECT_FALSE(SomePos.contains(APFloat(-3.0))); |
| EXPECT_TRUE(Some.contains(SomePos)); |
| EXPECT_TRUE(Some.contains(SomeNeg)); |
| } |
| |
| TEST_F(ConstantFPRangeTest, Equality) { |
| EXPECT_EQ(Full, Full); |
| EXPECT_EQ(Empty, Empty); |
| EXPECT_EQ(One, One); |
| EXPECT_EQ(Some, Some); |
| EXPECT_NE(Full, Empty); |
| EXPECT_NE(Zero, PosZero); |
| EXPECT_NE(One, NaN); |
| EXPECT_NE(Some, One); |
| EXPECT_NE(SNaN, QNaN); |
| } |
| |
| TEST_F(ConstantFPRangeTest, SingleElement) { |
| EXPECT_EQ(Full.getSingleElement(), static_cast<APFloat *>(nullptr)); |
| EXPECT_EQ(Empty.getSingleElement(), static_cast<APFloat *>(nullptr)); |
| EXPECT_EQ(Finite.getSingleElement(), static_cast<APFloat *>(nullptr)); |
| EXPECT_EQ(Zero.getSingleElement(), static_cast<APFloat *>(nullptr)); |
| EXPECT_EQ(NaN.getSingleElement(), static_cast<APFloat *>(nullptr)); |
| EXPECT_EQ(SNaN.getSingleElement(), static_cast<APFloat *>(nullptr)); |
| EXPECT_EQ(QNaN.getSingleElement(), static_cast<APFloat *>(nullptr)); |
| |
| EXPECT_EQ(*One.getSingleElement(), APFloat(1.0)); |
| EXPECT_EQ(*PosZero.getSingleElement(), APFloat::getZero(Sem)); |
| EXPECT_EQ(*PosInf.getSingleElement(), APFloat::getInf(Sem)); |
| ConstantFPRange PosZeroOrNaN = PosZero.unionWith(NaN); |
| EXPECT_EQ(*PosZeroOrNaN.getSingleElement(/*ExcludesNaN=*/true), |
| APFloat::getZero(Sem)); |
| |
| EXPECT_FALSE(Full.isSingleElement()); |
| EXPECT_FALSE(Empty.isSingleElement()); |
| EXPECT_TRUE(One.isSingleElement()); |
| EXPECT_FALSE(Some.isSingleElement()); |
| EXPECT_FALSE(Zero.isSingleElement()); |
| EXPECT_TRUE(PosZeroOrNaN.isSingleElement(/*ExcludesNaN=*/true)); |
| } |
| |
| TEST_F(ConstantFPRangeTest, ExhaustivelyEnumerate) { |
| constexpr unsigned NNaNValues = (1 << 8) - 2 * ((1 << 3) - 1); |
| constexpr unsigned Expected = 4 * ((NNaNValues + 1) * NNaNValues / 2 + 1); |
| unsigned Count = 0; |
| EnumerateConstantFPRanges([&](const ConstantFPRange &) { ++Count; }, |
| /*Exhaustive=*/true); |
| EXPECT_EQ(Expected, Count); |
| } |
| |
| TEST_F(ConstantFPRangeTest, Enumerate) { |
| constexpr unsigned NNaNValues = 2 * ((1 << 4) - 2 + 4); |
| constexpr unsigned Expected = 4 * ((NNaNValues + 1) * NNaNValues / 2 + 1); |
| unsigned Count = 0; |
| EnumerateConstantFPRanges([&](const ConstantFPRange &) { ++Count; }, |
| /*Exhaustive=*/false); |
| EXPECT_EQ(Expected, Count); |
| } |
| |
| TEST_F(ConstantFPRangeTest, IntersectWith) { |
| EXPECT_EQ(Empty.intersectWith(Full), Empty); |
| EXPECT_EQ(Empty.intersectWith(Empty), Empty); |
| EXPECT_EQ(Empty.intersectWith(One), Empty); |
| EXPECT_EQ(Empty.intersectWith(Some), Empty); |
| EXPECT_EQ(Full.intersectWith(Full), Full); |
| EXPECT_EQ(Some.intersectWith(Some), Some); |
| EXPECT_EQ(Some.intersectWith(One), One); |
| EXPECT_EQ(Full.intersectWith(One), One); |
| EXPECT_EQ(Full.intersectWith(Some), Some); |
| EXPECT_EQ(Some.intersectWith(SomePos), SomePos); |
| EXPECT_EQ(Some.intersectWith(SomeNeg), SomeNeg); |
| EXPECT_EQ(NaN.intersectWith(Finite), Empty); |
| EXPECT_EQ(NaN.intersectWith(SNaN), SNaN); |
| EXPECT_EQ(NaN.intersectWith(QNaN), QNaN); |
| EXPECT_EQ(Finite.intersectWith(One), One); |
| EXPECT_EQ(Some.intersectWith(Zero), Zero); |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(4.0)) |
| .intersectWith( |
| ConstantFPRange::getNonNaN(APFloat(3.0), APFloat(6.0))), |
| ConstantFPRange::getNonNaN(APFloat(3.0), APFloat(4.0))); |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0)) |
| .intersectWith( |
| ConstantFPRange::getNonNaN(APFloat(5.0), APFloat(6.0))), |
| Empty); |
| } |
| |
| TEST_F(ConstantFPRangeTest, UnionWith) { |
| EXPECT_EQ(Empty.unionWith(Full), Full); |
| EXPECT_EQ(Empty.unionWith(Empty), Empty); |
| EXPECT_EQ(Empty.unionWith(One), One); |
| EXPECT_EQ(Empty.unionWith(Some), Some); |
| EXPECT_EQ(Full.unionWith(Full), Full); |
| EXPECT_EQ(Some.unionWith(Some), Some); |
| EXPECT_EQ(Some.unionWith(One), Some); |
| EXPECT_EQ(Full.unionWith(Some), Full); |
| EXPECT_EQ(Some.unionWith(SomePos), Some); |
| EXPECT_EQ(Some.unionWith(SomeNeg), Some); |
| EXPECT_EQ(Finite.unionWith(One), Finite); |
| EXPECT_EQ(Some.unionWith(Zero), Some); |
| EXPECT_EQ(Finite.unionWith(PosInf).unionWith(NegInf).unionWith(NaN), Full); |
| EXPECT_EQ(PosZero.unionWith(NegZero), Zero); |
| EXPECT_EQ(NaN.unionWith(SNaN), NaN); |
| EXPECT_EQ(NaN.unionWith(QNaN), NaN); |
| EXPECT_EQ(SNaN.unionWith(QNaN), NaN); |
| EXPECT_EQ( |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(4.0)) |
| .unionWith(ConstantFPRange::getNonNaN(APFloat(3.0), APFloat(6.0))), |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(6.0))); |
| EXPECT_EQ( |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0)) |
| .unionWith(ConstantFPRange::getNonNaN(APFloat(5.0), APFloat(6.0))), |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(6.0))); |
| } |
| |
| TEST_F(ConstantFPRangeTest, FPClassify) { |
| EXPECT_EQ(Empty.classify(), fcNone); |
| EXPECT_EQ(Full.classify(), fcAllFlags); |
| EXPECT_EQ(Finite.classify(), fcFinite); |
| EXPECT_EQ(Zero.classify(), fcZero); |
| EXPECT_EQ(NaN.classify(), fcNan); |
| EXPECT_EQ(SNaN.classify(), fcSNan); |
| EXPECT_EQ(QNaN.classify(), fcQNan); |
| EXPECT_EQ(One.classify(), fcPosNormal); |
| EXPECT_EQ(Some.classify(), fcFinite); |
| EXPECT_EQ(SomePos.classify(), fcPosFinite); |
| EXPECT_EQ(SomeNeg.classify(), fcNegFinite); |
| EXPECT_EQ(PosInf.classify(), fcPosInf); |
| EXPECT_EQ(NegInf.classify(), fcNegInf); |
| EXPECT_EQ(Finite.getSignBit(), std::nullopt); |
| EXPECT_EQ(PosZero.getSignBit(), false); |
| EXPECT_EQ(NegZero.getSignBit(), true); |
| EXPECT_EQ(SomePos.getSignBit(), false); |
| EXPECT_EQ(SomeNeg.getSignBit(), true); |
| |
| #if defined(EXPENSIVE_CHECKS) |
| EnumerateConstantFPRanges( |
| [](const ConstantFPRange &CR) { |
| unsigned Mask = fcNone; |
| bool HasPos = false, HasNeg = false; |
| EnumerateValuesInConstantFPRange( |
| CR, |
| [&](const APFloat &V) { |
| Mask |= V.classify(); |
| if (V.isNegative()) |
| HasNeg = true; |
| else |
| HasPos = true; |
| }, |
| /*IgnoreNaNPayload=*/true); |
| |
| std::optional<bool> SignBit = std::nullopt; |
| if (HasPos != HasNeg) |
| SignBit = HasNeg; |
| |
| EXPECT_EQ(SignBit, CR.getSignBit()) << CR; |
| EXPECT_EQ(Mask, CR.classify()) << CR; |
| }, |
| /*Exhaustive=*/true); |
| #endif |
| } |
| |
| TEST_F(ConstantFPRangeTest, Print) { |
| auto ToString = [](const ConstantFPRange &CR) { |
| std::string Str; |
| raw_string_ostream OS(Str); |
| CR.print(OS); |
| return Str; |
| }; |
| |
| EXPECT_EQ(ToString(Full), "full-set"); |
| EXPECT_EQ(ToString(Empty), "empty-set"); |
| EXPECT_EQ(ToString(NaN), "NaN"); |
| EXPECT_EQ(ToString(SNaN), "SNaN"); |
| EXPECT_EQ(ToString(QNaN), "QNaN"); |
| EXPECT_EQ(ToString(One), "[1, 1]"); |
| EXPECT_EQ(ToString(Some.unionWith(SNaN)), "[-3, 3] with SNaN"); |
| } |
| |
| #ifdef GTEST_HAS_DEATH_TEST |
| #ifndef NDEBUG |
| TEST_F(ConstantFPRangeTest, NonCanonicalEmptySet) { |
| EXPECT_DEATH((void)(ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(0.0))), |
| "Non-canonical form"); |
| } |
| TEST_F(ConstantFPRangeTest, MismatchedSemantics) { |
| EXPECT_DEATH((void)(ConstantFPRange::getNonNaN(APFloat(0.0), APFloat(1.0f))), |
| "Should only use the same semantics"); |
| EXPECT_DEATH((void)(One.contains(APFloat(1.0f))), |
| "Should only use the same semantics"); |
| ConstantFPRange OneF32 = ConstantFPRange(APFloat(1.0f)); |
| EXPECT_DEATH((void)(One.contains(OneF32)), |
| "Should only use the same semantics"); |
| EXPECT_DEATH((void)(One.intersectWith(OneF32)), |
| "Should only use the same semantics"); |
| EXPECT_DEATH((void)(One.unionWith(OneF32)), |
| "Should only use the same semantics"); |
| } |
| #endif |
| #endif |
| |
| TEST_F(ConstantFPRangeTest, makeAllowedFCmpRegion) { |
| EXPECT_EQ(ConstantFPRange::makeAllowedFCmpRegion( |
| FCmpInst::FCMP_OLE, |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0))), |
| ConstantFPRange::getNonNaN(APFloat::getInf(Sem, /*Negative=*/true), |
| APFloat(2.0))); |
| EXPECT_EQ( |
| ConstantFPRange::makeAllowedFCmpRegion( |
| FCmpInst::FCMP_OLT, |
| ConstantFPRange::getNonNaN(APFloat(1.0), |
| APFloat::getInf(Sem, /*Negative=*/false))), |
| ConstantFPRange::getNonNaN(APFloat::getInf(Sem, /*Negative=*/true), |
| APFloat::getLargest(Sem, /*Negative=*/false))); |
| EXPECT_EQ( |
| ConstantFPRange::makeAllowedFCmpRegion( |
| FCmpInst::FCMP_OGT, |
| ConstantFPRange::getNonNaN(APFloat::getZero(Sem, /*Negative=*/true), |
| APFloat(2.0))), |
| ConstantFPRange::getNonNaN(APFloat::getSmallest(Sem, /*Negative=*/false), |
| APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_EQ(ConstantFPRange::makeAllowedFCmpRegion( |
| FCmpInst::FCMP_OGE, |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0))), |
| ConstantFPRange::getNonNaN( |
| APFloat(1.0), APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_EQ(ConstantFPRange::makeAllowedFCmpRegion( |
| FCmpInst::FCMP_OEQ, |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0))), |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0))); |
| |
| #if defined(EXPENSIVE_CHECKS) |
| for (auto Pred : FCmpInst::predicates()) { |
| EnumerateConstantFPRanges( |
| [Pred](const ConstantFPRange &CR) { |
| ConstantFPRange Res = |
| ConstantFPRange::makeAllowedFCmpRegion(Pred, CR); |
| ConstantFPRange Optimal = |
| ConstantFPRange::getEmpty(CR.getSemantics()); |
| EnumerateValuesInConstantFPRange( |
| ConstantFPRange::getFull(CR.getSemantics()), |
| [&](const APFloat &V) { |
| if (AnyOfValueInConstantFPRange( |
| CR, |
| [&](const APFloat &U) { |
| return FCmpInst::compare(V, U, Pred); |
| }, |
| /*IgnoreNaNPayload=*/true)) |
| Optimal = Optimal.unionWith(ConstantFPRange(V)); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| |
| EXPECT_TRUE(Res.contains(Optimal)) |
| << "Wrong result for makeAllowedFCmpRegion(" << Pred << ", " << CR |
| << "). Expected " << Optimal << ", but got " << Res; |
| EXPECT_EQ(Res, Optimal) |
| << "Suboptimal result for makeAllowedFCmpRegion(" << Pred << ", " |
| << CR << ")"; |
| }, |
| /*Exhaustive=*/false); |
| } |
| #endif |
| } |
| |
| TEST_F(ConstantFPRangeTest, makeSatisfyingFCmpRegion) { |
| EXPECT_EQ(ConstantFPRange::makeSatisfyingFCmpRegion( |
| FCmpInst::FCMP_OLE, |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0))), |
| ConstantFPRange::getNonNaN(APFloat::getInf(Sem, /*Negative=*/true), |
| APFloat(1.0))); |
| EXPECT_EQ( |
| ConstantFPRange::makeSatisfyingFCmpRegion( |
| FCmpInst::FCMP_OLT, ConstantFPRange::getNonNaN( |
| APFloat::getSmallest(Sem, /*Negative=*/false), |
| APFloat::getInf(Sem, /*Negative=*/false))), |
| ConstantFPRange::getNonNaN(APFloat::getInf(Sem, /*Negative=*/true), |
| APFloat::getZero(Sem, /*Negative=*/false))); |
| EXPECT_EQ( |
| ConstantFPRange::makeSatisfyingFCmpRegion( |
| FCmpInst::FCMP_OGT, ConstantFPRange::getNonNaN( |
| APFloat::getZero(Sem, /*Negative=*/true), |
| APFloat::getZero(Sem, /*Negative=*/false))), |
| ConstantFPRange::getNonNaN(APFloat::getSmallest(Sem, /*Negative=*/false), |
| APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_EQ(ConstantFPRange::makeSatisfyingFCmpRegion( |
| FCmpInst::FCMP_OGE, |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0))), |
| ConstantFPRange::getNonNaN( |
| APFloat(2.0), APFloat::getInf(Sem, /*Negative=*/false))); |
| EXPECT_EQ(ConstantFPRange::makeSatisfyingFCmpRegion( |
| FCmpInst::FCMP_OEQ, |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0))), |
| ConstantFPRange::getEmpty(Sem)); |
| EXPECT_EQ(ConstantFPRange::makeSatisfyingFCmpRegion( |
| FCmpInst::FCMP_OEQ, |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(1.0))), |
| ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(1.0))); |
| |
| #if defined(EXPENSIVE_CHECKS) |
| for (auto Pred : FCmpInst::predicates()) { |
| EnumerateConstantFPRanges( |
| [Pred](const ConstantFPRange &CR) { |
| ConstantFPRange Res = |
| ConstantFPRange::makeSatisfyingFCmpRegion(Pred, CR); |
| // Super set of the optimal set excluding NaNs |
| ConstantFPRange SuperSet(CR.getSemantics()); |
| bool ContainsSNaN = false; |
| bool ContainsQNaN = false; |
| unsigned NonNaNValsInOptimalSet = 0; |
| EnumerateValuesInConstantFPRange( |
| ConstantFPRange::getFull(CR.getSemantics()), |
| [&](const APFloat &V) { |
| if (AnyOfValueInConstantFPRange( |
| CR, |
| [&](const APFloat &U) { |
| return !FCmpInst::compare(V, U, Pred); |
| }, |
| /*IgnoreNaNPayload=*/true)) { |
| EXPECT_FALSE(Res.contains(V)) |
| << "Wrong result for makeSatisfyingFCmpRegion(" << Pred |
| << ", " << CR << "). The result " << Res |
| << " should not contain " << V; |
| } else { |
| if (V.isNaN()) { |
| if (V.isSignaling()) |
| ContainsSNaN = true; |
| else |
| ContainsQNaN = true; |
| } else { |
| SuperSet = SuperSet.unionWith(ConstantFPRange(V)); |
| ++NonNaNValsInOptimalSet; |
| } |
| } |
| }, |
| /*IgnoreNaNPayload=*/true); |
| |
| // Check optimality |
| |
| // The usefullness of making the result optimal for one/une is |
| // questionable. |
| if (Pred == FCmpInst::FCMP_ONE || Pred == FCmpInst::FCMP_UNE) |
| return; |
| |
| EXPECT_FALSE(ContainsSNaN && !Res.containsSNaN()) |
| << "Suboptimal result for makeSatisfyingFCmpRegion(" << Pred |
| << ", " << CR << "), should contain SNaN, but got " << Res; |
| EXPECT_FALSE(ContainsQNaN && !Res.containsQNaN()) |
| << "Suboptimal result for makeSatisfyingFCmpRegion(" << Pred |
| << ", " << CR << "), should contain QNaN, but got " << Res; |
| |
| // We only care about the cases where the result is representable by |
| // ConstantFPRange. |
| unsigned NonNaNValsInSuperSet = 0; |
| EnumerateValuesInConstantFPRange( |
| SuperSet, |
| [&](const APFloat &V) { |
| if (!V.isNaN()) |
| ++NonNaNValsInSuperSet; |
| }, |
| /*IgnoreNaNPayload=*/true); |
| |
| if (NonNaNValsInSuperSet == NonNaNValsInOptimalSet) { |
| ConstantFPRange Optimal = |
| ConstantFPRange(SuperSet.getLower(), SuperSet.getUpper(), |
| ContainsQNaN, ContainsSNaN); |
| EXPECT_EQ(Res, Optimal) |
| << "Suboptimal result for makeSatisfyingFCmpRegion(" << Pred |
| << ", " << CR << ")"; |
| } |
| }, |
| /*Exhaustive=*/false); |
| } |
| #endif |
| } |
| |
| TEST_F(ConstantFPRangeTest, fcmp) { |
| std::vector<ConstantFPRange> InterestingRanges; |
| const fltSemantics &Sem = APFloat::Float8E4M3(); |
| auto FpImm = [&](double V) { |
| bool ignored; |
| APFloat APF(V); |
| APF.convert(Sem, APFloat::rmNearestTiesToEven, &ignored); |
| return APF; |
| }; |
| |
| InterestingRanges.push_back(ConstantFPRange::getEmpty(Sem)); |
| InterestingRanges.push_back(ConstantFPRange::getFull(Sem)); |
| InterestingRanges.push_back(ConstantFPRange::getFinite(Sem)); |
| InterestingRanges.push_back(ConstantFPRange(FpImm(1.0))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getZero(Sem, /*Negative=*/false))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getZero(Sem, /*Negative=*/true))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getInf(Sem, /*Negative=*/false))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getInf(Sem, /*Negative=*/true))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getSmallest(Sem, /*Negative=*/false))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getSmallest(Sem, /*Negative=*/true))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getLargest(Sem, /*Negative=*/false))); |
| InterestingRanges.push_back( |
| ConstantFPRange(APFloat::getLargest(Sem, /*Negative=*/true))); |
| InterestingRanges.push_back( |
| ConstantFPRange::getNaNOnly(Sem, /*MayBeQNaN=*/true, /*MayBeSNaN=*/true)); |
| InterestingRanges.push_back( |
| ConstantFPRange::getNonNaN(FpImm(0.0), FpImm(1.0))); |
| InterestingRanges.push_back( |
| ConstantFPRange::getNonNaN(FpImm(2.0), FpImm(3.0))); |
| InterestingRanges.push_back( |
| ConstantFPRange::getNonNaN(FpImm(-1.0), FpImm(1.0))); |
| InterestingRanges.push_back( |
| ConstantFPRange::getNonNaN(FpImm(-1.0), FpImm(-0.0))); |
| InterestingRanges.push_back(ConstantFPRange::getNonNaN( |
| APFloat::getInf(Sem, /*Negative=*/true), FpImm(-1.0))); |
| InterestingRanges.push_back(ConstantFPRange::getNonNaN( |
| FpImm(1.0), APFloat::getInf(Sem, /*Negative=*/false))); |
| |
| for (auto &LHS : InterestingRanges) { |
| for (auto &RHS : InterestingRanges) { |
| for (auto Pred : FCmpInst::predicates()) { |
| if (LHS.fcmp(Pred, RHS)) { |
| EnumerateValuesInConstantFPRange( |
| LHS, |
| [&](const APFloat &LHSC) { |
| EnumerateValuesInConstantFPRange( |
| RHS, |
| [&](const APFloat &RHSC) { |
| EXPECT_TRUE(FCmpInst::compare(LHSC, RHSC, Pred)) |
| << LHS << " " << Pred << " " << RHS |
| << " doesn't hold"; |
| }, |
| /*IgnoreNaNPayload=*/true); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| } |
| } |
| } |
| } |
| } |
| |
| TEST_F(ConstantFPRangeTest, makeExactFCmpRegion) { |
| for (auto Pred : FCmpInst::predicates()) { |
| EnumerateValuesInConstantFPRange( |
| ConstantFPRange::getFull(APFloat::Float8E4M3()), |
| [Pred](const APFloat &V) { |
| std::optional<ConstantFPRange> Res = |
| ConstantFPRange::makeExactFCmpRegion(Pred, V); |
| ConstantFPRange Allowed = |
| ConstantFPRange::makeAllowedFCmpRegion(Pred, ConstantFPRange(V)); |
| ConstantFPRange Satisfying = |
| ConstantFPRange::makeSatisfyingFCmpRegion(Pred, |
| ConstantFPRange(V)); |
| if (Allowed == Satisfying) |
| EXPECT_EQ(Res, Allowed) << "Wrong result for makeExactFCmpRegion(" |
| << Pred << ", " << V << ")."; |
| else |
| EXPECT_FALSE(Res.has_value()) |
| << "Wrong result for makeExactFCmpRegion(" << Pred << ", " << V |
| << ")."; |
| }, |
| /*IgnoreNaNPayload=*/true); |
| } |
| } |
| |
| } // anonymous namespace |
