| //===- 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/ADT/APFloat.h" |
| #include "llvm/ADT/FloatingPointMode.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 NonNaN; |
| 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::NonNaN = |
| ConstantFPRange::getNonNaN(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); |
| } |
| |
| enum class SparseLevel { |
| Dense, |
| SpecialValuesWithAllPowerOfTwos, |
| SpecialValuesOnly, |
| }; |
| |
| template <typename Fn> |
| static void EnumerateConstantFPRangesImpl(Fn TestFn, SparseLevel Level, |
| 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 (Level != SparseLevel::Dense) { |
| 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; |
| if (Level == SparseLevel::SpecialValuesWithAllPowerOfTwos) { |
| // 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::getSmallestNormalized(Sem, /*Negative=*/true)); |
| 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, SparseLevel Level, |
| bool IgnoreSNaNs = false) { |
| EnumerateConstantFPRangesImpl(TestFn, Level, /*MayBeQNaN=*/false, |
| /*MayBeSNaN=*/false); |
| EnumerateConstantFPRangesImpl(TestFn, Level, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/false); |
| if (IgnoreSNaNs) |
| return; |
| EnumerateConstantFPRangesImpl(TestFn, Level, /*MayBeQNaN=*/false, |
| /*MayBeSNaN=*/true); |
| EnumerateConstantFPRangesImpl(TestFn, Level, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/true); |
| } |
| |
| template <typename Fn> |
| static void EnumerateTwoInterestingConstantFPRanges(Fn TestFn, |
| SparseLevel Level) { |
| EnumerateConstantFPRanges( |
| [&](const ConstantFPRange &CR1) { |
| EnumerateConstantFPRanges( |
| [&](const ConstantFPRange &CR2) { TestFn(CR1, CR2); }, Level, |
| /*IgnoreSNaNs=*/true); |
| }, |
| Level, /*IgnoreSNaNs=*/true); |
| } |
| |
| 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; }, |
| SparseLevel::Dense); |
| EXPECT_EQ(Expected, Count); |
| } |
| |
| TEST_F(ConstantFPRangeTest, Enumerate) { |
| constexpr unsigned NNaNValues = 2 * ((1 << 4) - 2 + 5); |
| constexpr unsigned Expected = 4 * ((NNaNValues + 1) * NNaNValues / 2 + 1); |
| unsigned Count = 0; |
| EnumerateConstantFPRanges([&](const ConstantFPRange &) { ++Count; }, |
| SparseLevel::SpecialValuesWithAllPowerOfTwos); |
| EXPECT_EQ(Expected, Count); |
| } |
| |
| TEST_F(ConstantFPRangeTest, EnumerateWithSpecialValuesOnly) { |
| constexpr unsigned NNaNValues = 2 * 5; |
| constexpr unsigned Expected = 4 * ((NNaNValues + 1) * NNaNValues / 2 + 1); |
| unsigned Count = 0; |
| EnumerateConstantFPRanges([&](const ConstantFPRange &) { ++Count; }, |
| SparseLevel::SpecialValuesOnly); |
| 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; |
| }, |
| SparseLevel::Dense); |
| #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 << ")"; |
| }, |
| SparseLevel::SpecialValuesWithAllPowerOfTwos); |
| } |
| #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 << ")"; |
| } |
| }, |
| SparseLevel::SpecialValuesWithAllPowerOfTwos); |
| } |
| #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); |
| } |
| } |
| |
| TEST_F(ConstantFPRangeTest, abs) { |
| EXPECT_EQ(Full.abs(), |
| ConstantFPRange(APFloat::getZero(Sem, /*Negative=*/false), |
| APFloat::getInf(Sem, /*Negative=*/false), |
| /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/true)); |
| EXPECT_EQ(Empty.abs(), Empty); |
| EXPECT_EQ(Zero.abs(), PosZero); |
| EXPECT_EQ(PosInf.abs(), PosInf); |
| EXPECT_EQ(NegInf.abs(), PosInf); |
| EXPECT_EQ(Some.abs(), SomePos); |
| EXPECT_EQ(SomeNeg.abs(), SomePos); |
| EXPECT_EQ(NaN.abs(), NaN); |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-2.0), APFloat(3.0)).abs(), |
| ConstantFPRange::getNonNaN(APFloat(0.0), APFloat(3.0))); |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(2.0)).abs(), |
| ConstantFPRange::getNonNaN(APFloat(0.0), APFloat(3.0))); |
| } |
| |
| TEST_F(ConstantFPRangeTest, negate) { |
| EXPECT_EQ(Full.negate(), Full); |
| EXPECT_EQ(Empty.negate(), Empty); |
| EXPECT_EQ(Zero.negate(), Zero); |
| EXPECT_EQ(PosInf.negate(), NegInf); |
| EXPECT_EQ(NegInf.negate(), PosInf); |
| EXPECT_EQ(Some.negate(), Some); |
| EXPECT_EQ(SomePos.negate(), SomeNeg); |
| EXPECT_EQ(SomeNeg.negate(), SomePos); |
| EXPECT_EQ(NaN.negate(), NaN); |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-2.0), APFloat(3.0)).negate(), |
| ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(2.0))); |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(2.0)).negate(), |
| ConstantFPRange::getNonNaN(APFloat(-2.0), APFloat(3.0))); |
| } |
| |
| TEST_F(ConstantFPRangeTest, getWithout) { |
| EXPECT_EQ(Full.getWithoutNaN(), NonNaN); |
| EXPECT_EQ(NaN.getWithoutNaN(), Empty); |
| |
| EXPECT_EQ(NaN.getWithoutInf(), NaN); |
| EXPECT_EQ(PosInf.getWithoutInf(), Empty); |
| EXPECT_EQ(NegInf.getWithoutInf(), Empty); |
| EXPECT_EQ(NonNaN.getWithoutInf(), Finite); |
| EXPECT_EQ(Zero.getWithoutInf(), Zero); |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat::getInf(Sem, /*Negative=*/true), |
| APFloat(3.0)) |
| .getWithoutInf(), |
| ConstantFPRange::getNonNaN( |
| APFloat::getLargest(Sem, /*Negative=*/true), APFloat(3.0))); |
| } |
| |
| TEST_F(ConstantFPRangeTest, cast) { |
| const fltSemantics &F16Sem = APFloat::IEEEhalf(); |
| const fltSemantics &BF16Sem = APFloat::BFloat(); |
| const fltSemantics &F32Sem = APFloat::IEEEsingle(); |
| const fltSemantics &F8NanOnlySem = APFloat::Float8E4M3FN(); |
| // normal -> normal (exact) |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(1.0), APFloat(2.0)).cast(F32Sem), |
| ConstantFPRange::getNonNaN(APFloat(1.0f), APFloat(2.0f))); |
| EXPECT_EQ( |
| ConstantFPRange::getNonNaN(APFloat(-2.0f), APFloat(-1.0f)).cast(Sem), |
| ConstantFPRange::getNonNaN(APFloat(-2.0), APFloat(-1.0))); |
| // normal -> normal (inexact) |
| EXPECT_EQ( |
| ConstantFPRange::getNonNaN(APFloat(3.141592653589793), |
| APFloat(6.283185307179586)) |
| .cast(F32Sem), |
| ConstantFPRange::getNonNaN(APFloat(3.14159274f), APFloat(6.28318548f))); |
| // normal -> subnormal |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-5e-8), APFloat(5e-8)) |
| .cast(F16Sem) |
| .classify(), |
| fcSubnormal | fcZero); |
| // normal -> zero |
| EXPECT_EQ(ConstantFPRange::getNonNaN( |
| APFloat::getSmallestNormalized(Sem, /*Negative=*/true), |
| APFloat::getSmallestNormalized(Sem, /*Negative=*/false)) |
| .cast(F32Sem) |
| .classify(), |
| fcZero); |
| // normal -> inf |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat(-65536.0), APFloat(65536.0)) |
| .cast(F16Sem), |
| ConstantFPRange::getNonNaN(F16Sem)); |
| // nan -> qnan |
| EXPECT_EQ( |
| ConstantFPRange::getNaNOnly(Sem, /*MayBeQNaN=*/true, /*MayBeSNaN=*/false) |
| .cast(F32Sem), |
| ConstantFPRange::getNaNOnly(F32Sem, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/false)); |
| EXPECT_EQ( |
| ConstantFPRange::getNaNOnly(Sem, /*MayBeQNaN=*/false, /*MayBeSNaN=*/true) |
| .cast(F32Sem), |
| ConstantFPRange::getNaNOnly(F32Sem, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/false)); |
| EXPECT_EQ( |
| ConstantFPRange::getNaNOnly(Sem, /*MayBeQNaN=*/true, /*MayBeSNaN=*/true) |
| .cast(F32Sem), |
| ConstantFPRange::getNaNOnly(F32Sem, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/false)); |
| // For BF16 -> F32, signaling bit is still lost. |
| EXPECT_EQ(ConstantFPRange::getNaNOnly(BF16Sem, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/true) |
| .cast(F32Sem), |
| ConstantFPRange::getNaNOnly(F32Sem, /*MayBeQNaN=*/true, |
| /*MayBeSNaN=*/false)); |
| // inf -> nan only (return full set for now) |
| EXPECT_EQ(ConstantFPRange::getNonNaN(APFloat::getInf(Sem, /*Negative=*/true), |
| APFloat::getInf(Sem, /*Negative=*/false)) |
| .cast(F8NanOnlySem), |
| ConstantFPRange::getFull(F8NanOnlySem)); |
| // other rounding modes |
| EXPECT_EQ( |
| ConstantFPRange::getNonNaN(APFloat::getSmallest(Sem, /*Negative=*/true), |
| APFloat::getSmallest(Sem, /*Negative=*/false)) |
| .cast(F32Sem, APFloat::rmTowardNegative), |
| ConstantFPRange::getNonNaN( |
| APFloat::getSmallest(F32Sem, /*Negative=*/true), |
| APFloat::getZero(F32Sem, /*Negative=*/false))); |
| EXPECT_EQ( |
| ConstantFPRange::getNonNaN(APFloat::getSmallest(Sem, /*Negative=*/true), |
| APFloat::getSmallest(Sem, /*Negative=*/false)) |
| .cast(F32Sem, APFloat::rmTowardPositive), |
| ConstantFPRange::getNonNaN( |
| APFloat::getZero(F32Sem, /*Negative=*/true), |
| APFloat::getSmallest(F32Sem, /*Negative=*/false))); |
| EXPECT_EQ( |
| ConstantFPRange::getNonNaN( |
| APFloat::getSmallestNormalized(Sem, /*Negative=*/true), |
| APFloat::getSmallestNormalized(Sem, /*Negative=*/false)) |
| .cast(F32Sem, APFloat::rmTowardZero), |
| ConstantFPRange::getNonNaN(APFloat::getZero(F32Sem, /*Negative=*/true), |
| APFloat::getZero(F32Sem, /*Negative=*/false))); |
| |
| EnumerateValuesInConstantFPRange( |
| ConstantFPRange::getFull(APFloat::Float8E4M3()), |
| [&](const APFloat &V) { |
| bool LosesInfo = false; |
| |
| APFloat DoubleV = V; |
| DoubleV.convert(Sem, APFloat::rmNearestTiesToEven, &LosesInfo); |
| ConstantFPRange DoubleCR = ConstantFPRange(V).cast(Sem); |
| EXPECT_TRUE(DoubleCR.contains(DoubleV)) |
| << "Casting " << V << " to double failed. " << DoubleCR |
| << " doesn't contain " << DoubleV; |
| |
| auto &FP4Sem = APFloat::Float4E2M1FN(); |
| APFloat FP4V = V; |
| FP4V.convert(FP4Sem, APFloat::rmNearestTiesToEven, &LosesInfo); |
| ConstantFPRange FP4CR = ConstantFPRange(V).cast(FP4Sem); |
| EXPECT_TRUE(FP4CR.contains(FP4V)) |
| << "Casting " << V << " to FP4E2M1FN failed. " << FP4CR |
| << " doesn't contain " << FP4V; |
| }, |
| /*IgnoreNaNPayload=*/true); |
| } |
| |
| TEST_F(ConstantFPRangeTest, add) { |
| EXPECT_EQ(Full.add(Full), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(Full.add(Empty), Empty); |
| EXPECT_EQ(Empty.add(Full), Empty); |
| EXPECT_EQ(Empty.add(Empty), Empty); |
| EXPECT_EQ(One.add(One), ConstantFPRange(APFloat(2.0))); |
| EXPECT_EQ(Some.add(Some), |
| ConstantFPRange::getNonNaN(APFloat(-6.0), APFloat(6.0))); |
| EXPECT_EQ(SomePos.add(SomeNeg), |
| ConstantFPRange::getNonNaN(APFloat(-3.0), APFloat(3.0))); |
| EXPECT_EQ(PosInf.add(PosInf), PosInf); |
| EXPECT_EQ(NegInf.add(NegInf), NegInf); |
| EXPECT_EQ(PosInf.add(Finite.unionWith(PosInf)), PosInf); |
| EXPECT_EQ(NegInf.add(Finite.unionWith(NegInf)), NegInf); |
| EXPECT_EQ(PosInf.add(Finite.unionWith(NegInf)), PosInf.unionWith(QNaN)); |
| EXPECT_EQ(NegInf.add(Finite.unionWith(PosInf)), NegInf.unionWith(QNaN)); |
| EXPECT_EQ(PosInf.add(NegInf), QNaN); |
| EXPECT_EQ(NegInf.add(PosInf), QNaN); |
| EXPECT_EQ(PosZero.add(NegZero), PosZero); |
| EXPECT_EQ(PosZero.add(Zero), PosZero); |
| EXPECT_EQ(NegZero.add(NegZero), NegZero); |
| EXPECT_EQ(NegZero.add(Zero), Zero); |
| EXPECT_EQ(NaN.add(NaN), QNaN); |
| EXPECT_EQ(NaN.add(Finite), QNaN); |
| EXPECT_EQ(NonNaN.unionWith(NaN).add(NonNaN), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(PosInf.unionWith(QNaN).add(PosInf), PosInf.unionWith(QNaN)); |
| EXPECT_EQ(PosInf.unionWith(NaN).add(ConstantFPRange(APFloat(24.0))), |
| PosInf.unionWith(QNaN)); |
| |
| #if defined(EXPENSIVE_CHECKS) |
| EnumerateTwoInterestingConstantFPRanges( |
| [](const ConstantFPRange &LHS, const ConstantFPRange &RHS) { |
| ConstantFPRange Res = LHS.add(RHS); |
| ConstantFPRange Expected = |
| ConstantFPRange::getEmpty(LHS.getSemantics()); |
| EnumerateValuesInConstantFPRange( |
| LHS, |
| [&](const APFloat &LHSC) { |
| EnumerateValuesInConstantFPRange( |
| RHS, |
| [&](const APFloat &RHSC) { |
| APFloat Sum = LHSC + RHSC; |
| EXPECT_TRUE(Res.contains(Sum)) |
| << "Wrong result for " << LHS << " + " << RHS |
| << ". The result " << Res << " should contain " << Sum; |
| if (!Expected.contains(Sum)) |
| Expected = Expected.unionWith(ConstantFPRange(Sum)); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| EXPECT_EQ(Res, Expected) |
| << "Suboptimal result for " << LHS << " + " << RHS << ". Expected " |
| << Expected << ", but got " << Res; |
| }, |
| SparseLevel::SpecialValuesOnly); |
| #endif |
| } |
| |
| TEST_F(ConstantFPRangeTest, sub) { |
| EXPECT_EQ(Full.sub(Full), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(Full.sub(Empty), Empty); |
| EXPECT_EQ(Empty.sub(Full), Empty); |
| EXPECT_EQ(Empty.sub(Empty), Empty); |
| EXPECT_EQ(One.sub(One), ConstantFPRange(APFloat(0.0))); |
| EXPECT_EQ(Some.sub(Some), |
| ConstantFPRange::getNonNaN(APFloat(-6.0), APFloat(6.0))); |
| EXPECT_EQ(SomePos.sub(SomeNeg), |
| ConstantFPRange::getNonNaN(APFloat(0.0), APFloat(6.0))); |
| EXPECT_EQ(PosInf.sub(NegInf), PosInf); |
| EXPECT_EQ(NegInf.sub(PosInf), NegInf); |
| EXPECT_EQ(PosInf.sub(Finite.unionWith(NegInf)), PosInf); |
| EXPECT_EQ(NegInf.sub(Finite.unionWith(PosInf)), NegInf); |
| EXPECT_EQ(PosInf.sub(Finite.unionWith(PosInf)), PosInf.unionWith(QNaN)); |
| EXPECT_EQ(NegInf.sub(Finite.unionWith(NegInf)), NegInf.unionWith(QNaN)); |
| EXPECT_EQ(PosInf.sub(PosInf), QNaN); |
| EXPECT_EQ(NegInf.sub(NegInf), QNaN); |
| EXPECT_EQ(PosZero.sub(NegZero), PosZero); |
| EXPECT_EQ(PosZero.sub(Zero), PosZero); |
| EXPECT_EQ(NegZero.sub(NegZero), PosZero); |
| EXPECT_EQ(NegZero.sub(PosZero), NegZero); |
| EXPECT_EQ(NegZero.sub(Zero), Zero); |
| EXPECT_EQ(NaN.sub(NaN), QNaN); |
| EXPECT_EQ(NaN.add(Finite), QNaN); |
| |
| #if defined(EXPENSIVE_CHECKS) |
| EnumerateTwoInterestingConstantFPRanges( |
| [](const ConstantFPRange &LHS, const ConstantFPRange &RHS) { |
| ConstantFPRange Res = LHS.sub(RHS); |
| ConstantFPRange Expected = |
| ConstantFPRange::getEmpty(LHS.getSemantics()); |
| EnumerateValuesInConstantFPRange( |
| LHS, |
| [&](const APFloat &LHSC) { |
| EnumerateValuesInConstantFPRange( |
| RHS, |
| [&](const APFloat &RHSC) { |
| APFloat Diff = LHSC - RHSC; |
| EXPECT_TRUE(Res.contains(Diff)) |
| << "Wrong result for " << LHS << " - " << RHS |
| << ". The result " << Res << " should contain " << Diff; |
| if (!Expected.contains(Diff)) |
| Expected = Expected.unionWith(ConstantFPRange(Diff)); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| EXPECT_EQ(Res, Expected) |
| << "Suboptimal result for " << LHS << " - " << RHS << ". Expected " |
| << Expected << ", but got " << Res; |
| }, |
| SparseLevel::SpecialValuesOnly); |
| #endif |
| } |
| |
| TEST_F(ConstantFPRangeTest, mul) { |
| EXPECT_EQ(Full.mul(Full), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(Full.mul(Empty), Empty); |
| EXPECT_EQ(Empty.mul(Full), Empty); |
| EXPECT_EQ(Empty.mul(Empty), Empty); |
| EXPECT_EQ(One.mul(One), ConstantFPRange(APFloat(1.0))); |
| EXPECT_EQ(Some.mul(Some), |
| ConstantFPRange::getNonNaN(APFloat(-9.0), APFloat(9.0))); |
| EXPECT_EQ(SomePos.mul(SomeNeg), |
| ConstantFPRange::getNonNaN(APFloat(-9.0), APFloat(-0.0))); |
| EXPECT_EQ(PosInf.mul(PosInf), PosInf); |
| EXPECT_EQ(NegInf.mul(NegInf), PosInf); |
| EXPECT_EQ(PosInf.mul(Finite), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(NegInf.mul(Finite), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(PosInf.mul(NegInf), NegInf); |
| EXPECT_EQ(NegInf.mul(PosInf), NegInf); |
| EXPECT_EQ(PosZero.mul(NegZero), NegZero); |
| EXPECT_EQ(PosZero.mul(Zero), Zero); |
| EXPECT_EQ(NegZero.mul(NegZero), PosZero); |
| EXPECT_EQ(NegZero.mul(Zero), Zero); |
| EXPECT_EQ(NaN.mul(NaN), QNaN); |
| EXPECT_EQ(NaN.mul(Finite), QNaN); |
| |
| #if defined(EXPENSIVE_CHECKS) |
| EnumerateTwoInterestingConstantFPRanges( |
| [](const ConstantFPRange &LHS, const ConstantFPRange &RHS) { |
| ConstantFPRange Res = LHS.mul(RHS); |
| ConstantFPRange Expected = |
| ConstantFPRange::getEmpty(LHS.getSemantics()); |
| EnumerateValuesInConstantFPRange( |
| LHS, |
| [&](const APFloat &LHSC) { |
| EnumerateValuesInConstantFPRange( |
| RHS, |
| [&](const APFloat &RHSC) { |
| APFloat Prod = LHSC * RHSC; |
| EXPECT_TRUE(Res.contains(Prod)) |
| << "Wrong result for " << LHS << " * " << RHS |
| << ". The result " << Res << " should contain " << Prod; |
| if (!Expected.contains(Prod)) |
| Expected = Expected.unionWith(ConstantFPRange(Prod)); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| EXPECT_EQ(Res, Expected) |
| << "Suboptimal result for " << LHS << " * " << RHS << ". Expected " |
| << Expected << ", but got " << Res; |
| }, |
| SparseLevel::SpecialValuesOnly); |
| #endif |
| } |
| |
| TEST_F(ConstantFPRangeTest, div) { |
| EXPECT_EQ(Full.div(Full), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(Full.div(Empty), Empty); |
| EXPECT_EQ(Empty.div(Full), Empty); |
| EXPECT_EQ(Empty.div(Empty), Empty); |
| EXPECT_EQ(One.div(One), ConstantFPRange(APFloat(1.0))); |
| EXPECT_EQ(Some.div(Some), NonNaN.unionWith(QNaN)); |
| EXPECT_EQ(SomePos.div(SomeNeg), |
| ConstantFPRange(APFloat::getInf(Sem, /*Negative=*/true), |
| APFloat::getZero(Sem, /*Negative=*/true), |
| /*MayBeQNaN=*/true, /*MayBeSNaN=*/false)); |
| EXPECT_EQ(PosInf.div(PosInf), QNaN); |
| EXPECT_EQ(NegInf.div(NegInf), QNaN); |
| EXPECT_EQ(PosInf.div(Finite), NonNaN); |
| EXPECT_EQ(NegInf.div(Finite), NonNaN); |
| EXPECT_EQ(PosInf.div(NegInf), QNaN); |
| EXPECT_EQ(NegInf.div(PosInf), QNaN); |
| EXPECT_EQ(Zero.div(Zero), QNaN); |
| EXPECT_EQ(SomePos.div(PosInf), PosZero); |
| EXPECT_EQ(SomeNeg.div(PosInf), NegZero); |
| EXPECT_EQ(PosInf.div(SomePos), PosInf); |
| EXPECT_EQ(NegInf.div(SomeNeg), PosInf); |
| EXPECT_EQ(NegInf.div(Some), NonNaN); |
| EXPECT_EQ(NaN.div(NaN), QNaN); |
| EXPECT_EQ(NaN.div(Finite), QNaN); |
| |
| #if defined(EXPENSIVE_CHECKS) |
| EnumerateTwoInterestingConstantFPRanges( |
| [](const ConstantFPRange &LHS, const ConstantFPRange &RHS) { |
| ConstantFPRange Res = LHS.div(RHS); |
| ConstantFPRange Expected = |
| ConstantFPRange::getEmpty(LHS.getSemantics()); |
| EnumerateValuesInConstantFPRange( |
| LHS, |
| [&](const APFloat &LHSC) { |
| EnumerateValuesInConstantFPRange( |
| RHS, |
| [&](const APFloat &RHSC) { |
| APFloat Val = LHSC / RHSC; |
| EXPECT_TRUE(Res.contains(Val)) |
| << "Wrong result for " << LHS << " / " << RHS |
| << ". The result " << Res << " should contain " << Val; |
| if (!Expected.contains(Val)) |
| Expected = Expected.unionWith(ConstantFPRange(Val)); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| EXPECT_EQ(Res, Expected) |
| << "Suboptimal result for " << LHS << " / " << RHS << ". Expected " |
| << Expected << ", but got " << Res; |
| }, |
| SparseLevel::SpecialValuesOnly); |
| #endif |
| } |
| |
| TEST_F(ConstantFPRangeTest, flushDenormals) { |
| const fltSemantics &FP8Sem = APFloat::Float8E4M3(); |
| APFloat NormalVal = APFloat::getSmallestNormalized(FP8Sem); |
| APFloat Subnormal1 = NormalVal; |
| Subnormal1.next(/*nextDown=*/true); |
| APFloat Subnormal2 = APFloat::getSmallest(FP8Sem); |
| APFloat ZeroVal = APFloat::getZero(FP8Sem); |
| APFloat EdgeValues[8] = {-NormalVal, -Subnormal1, -Subnormal2, -ZeroVal, |
| ZeroVal, Subnormal2, Subnormal1, NormalVal}; |
| constexpr DenormalMode::DenormalModeKind Modes[4] = { |
| DenormalMode::IEEE, DenormalMode::PreserveSign, |
| DenormalMode::PositiveZero, DenormalMode::Dynamic}; |
| for (uint32_t I = 0; I != 8; ++I) { |
| for (uint32_t J = I; J != 8; ++J) { |
| ConstantFPRange OriginCR = |
| ConstantFPRange::getNonNaN(EdgeValues[I], EdgeValues[J]); |
| for (auto Mode : Modes) { |
| StringRef ModeName = denormalModeKindName(Mode); |
| ConstantFPRange FlushedCR = OriginCR; |
| FlushedCR.flushDenormals(Mode); |
| |
| ConstantFPRange Expected = ConstantFPRange::getEmpty(FP8Sem); |
| auto CheckFlushedV = [&](const APFloat &V, const APFloat &FlushedV) { |
| EXPECT_TRUE(FlushedCR.contains(FlushedV)) |
| << "Wrong result for flushDenormal(" << V << ", " << ModeName |
| << "). The result " << FlushedCR << " should contain " |
| << FlushedV; |
| if (!Expected.contains(FlushedV)) |
| Expected = Expected.unionWith(ConstantFPRange(FlushedV)); |
| }; |
| EnumerateValuesInConstantFPRange( |
| OriginCR, |
| [&](const APFloat &V) { |
| if (V.isDenormal()) { |
| switch (Mode) { |
| case DenormalMode::IEEE: |
| break; |
| case DenormalMode::PreserveSign: |
| CheckFlushedV(V, APFloat::getZero(FP8Sem, V.isNegative())); |
| break; |
| case DenormalMode::PositiveZero: |
| CheckFlushedV(V, APFloat::getZero(FP8Sem)); |
| break; |
| case DenormalMode::Dynamic: |
| // PreserveSign |
| CheckFlushedV(V, APFloat::getZero(FP8Sem, V.isNegative())); |
| // PositiveZero |
| CheckFlushedV(V, APFloat::getZero(FP8Sem)); |
| break; |
| default: |
| llvm_unreachable("unknown denormal mode"); |
| } |
| } |
| // It is not mandated that flushing to zero occurs. |
| CheckFlushedV(V, V); |
| }, |
| /*IgnoreNaNPayload=*/true); |
| EXPECT_EQ(FlushedCR, Expected) |
| << "Suboptimal result for flushDenormal(" << OriginCR << ", " |
| << ModeName << "). Expected " << Expected << ", but got " |
| << FlushedCR; |
| } |
| } |
| } |
| } |
| |
| } // anonymous namespace |
