Skip to content

[ConstantFPRange] Implement ConstantFPRange::makeSatisfyingFCmpRegion #110891

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Oct 8, 2024
Merged

[ConstantFPRange] Implement ConstantFPRange::makeSatisfyingFCmpRegion #110891

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
fba9d95
[ConstantFPRange] Implement `ConstantFPRange::makeSatisfyingFCmpRegion`
dtcxzyw Oct 2, 2024
c5045b5
[ConstantFPRange] Add unittests for fcmp. NFC.
dtcxzyw Oct 2, 2024
6e8377a
[ConstantFPRange] Guard exhaustive checks by EXPENSIVE_CHECKS
dtcxzyw Oct 8, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
44 changes: 42 additions & 2 deletions llvm/lib/IR/ConstantFPRange.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -221,8 +221,48 @@ ConstantFPRange::makeAllowedFCmpRegion(FCmpInst::Predicate Pred,
ConstantFPRange
ConstantFPRange::makeSatisfyingFCmpRegion(FCmpInst::Predicate Pred,
const ConstantFPRange &Other) {
// TODO
return getEmpty(Other.getSemantics());
if (Other.isEmptySet())
return getFull(Other.getSemantics());
if (Other.containsNaN() && FCmpInst::isOrdered(Pred))
return getEmpty(Other.getSemantics());
if (Other.isNaNOnly() && FCmpInst::isUnordered(Pred))
return getFull(Other.getSemantics());

switch (Pred) {
case FCmpInst::FCMP_TRUE:
return getFull(Other.getSemantics());
case FCmpInst::FCMP_FALSE:
return getEmpty(Other.getSemantics());
case FCmpInst::FCMP_ORD:
return getNonNaN(Other.getSemantics());
case FCmpInst::FCMP_UNO:
return getNaNOnly(Other.getSemantics(), /*MayBeQNaN=*/true,
/*MayBeSNaN=*/true);
case FCmpInst::FCMP_OEQ:
case FCmpInst::FCMP_UEQ:
return setNaNField(Other.isSingleElement(/*ExcludesNaN=*/true) ||
((Other.classify() & ~fcNan) == fcZero)
? extendZeroIfEqual(Other, Pred)
: getEmpty(Other.getSemantics()),
Pred);
case FCmpInst::FCMP_ONE:
case FCmpInst::FCMP_UNE:
return getEmpty(Other.getSemantics());
case FCmpInst::FCMP_OLT:
case FCmpInst::FCMP_OLE:
case FCmpInst::FCMP_ULT:
case FCmpInst::FCMP_ULE:
return setNaNField(
extendZeroIfEqual(makeLessThan(Other.getLower(), Pred), Pred), Pred);
case FCmpInst::FCMP_OGT:
case FCmpInst::FCMP_OGE:
case FCmpInst::FCMP_UGT:
case FCmpInst::FCMP_UGE:
return setNaNField(
extendZeroIfEqual(makeGreaterThan(Other.getUpper(), Pred), Pred), Pred);
default:
llvm_unreachable("Unexpected predicate");
}
}

std::optional<ConstantFPRange>
Expand Down
179 changes: 179 additions & 0 deletions llvm/unittests/IR/ConstantFPRangeTest.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -564,4 +564,183 @@ TEST_F(ConstantFPRangeTest, makeAllowedFCmpRegion) {
#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);
}
}
}
}
}

} // anonymous namespace
Loading