[llvm] 9f0194b - [ConstantRange] Add getEquivalentICmp() variant with offset (NFCI)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Sat Nov 6 13:59:54 PDT 2021
Author: Nikita Popov
Date: 2021-11-06T21:59:45+01:00
New Revision: 9f0194be4570469ce830e6d581d21c75650562c7
URL: https://github.com/llvm/llvm-project/commit/9f0194be4570469ce830e6d581d21c75650562c7
DIFF: https://github.com/llvm/llvm-project/commit/9f0194be4570469ce830e6d581d21c75650562c7.diff
LOG: [ConstantRange] Add getEquivalentICmp() variant with offset (NFCI)
Add a variant of getEquivalentICmp() that produces an optional
offset. This allows us to create an equivalent icmp for all ranges.
Use this in the with.overflow folding code, which was doing this
adjustment separately -- this clarifies that the fold will indeed
always apply.
Added:
Modified:
llvm/include/llvm/IR/ConstantRange.h
llvm/lib/IR/ConstantRange.cpp
llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
llvm/unittests/IR/ConstantRangeTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/IR/ConstantRange.h b/llvm/include/llvm/IR/ConstantRange.h
index b0db7ee713337..4ec20403c5ab8 100644
--- a/llvm/include/llvm/IR/ConstantRange.h
+++ b/llvm/include/llvm/IR/ConstantRange.h
@@ -189,6 +189,11 @@ class LLVM_NODISCARD ConstantRange {
/// successful.
bool getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS) const;
+ /// Set up \p Pred, \p RHS and \p Offset such that (V + Offset) Pred RHS
+ /// is true iff V is in the range. Prefers using Offset == 0 if possible.
+ void
+ getEquivalentICmp(CmpInst::Predicate &Pred, APInt &RHS, APInt &Offset) const;
+
/// Return the lower value for this range.
const APInt &getLower() const { return Lower; }
diff --git a/llvm/lib/IR/ConstantRange.cpp b/llvm/lib/IR/ConstantRange.cpp
index d37c96917459f..b01f5cf60c3c6 100644
--- a/llvm/lib/IR/ConstantRange.cpp
+++ b/llvm/lib/IR/ConstantRange.cpp
@@ -183,38 +183,41 @@ CmpInst::Predicate ConstantRange::getEquivalentPredWithFlippedSignedness(
return CmpInst::Predicate::BAD_ICMP_PREDICATE;
}
-bool ConstantRange::getEquivalentICmp(CmpInst::Predicate &Pred,
- APInt &RHS) const {
- bool Success = false;
-
+void ConstantRange::getEquivalentICmp(CmpInst::Predicate &Pred,
+ APInt &RHS, APInt &Offset) const {
+ Offset = APInt(getBitWidth(), 0);
if (isFullSet() || isEmptySet()) {
Pred = isEmptySet() ? CmpInst::ICMP_ULT : CmpInst::ICMP_UGE;
RHS = APInt(getBitWidth(), 0);
- Success = true;
} else if (auto *OnlyElt = getSingleElement()) {
Pred = CmpInst::ICMP_EQ;
RHS = *OnlyElt;
- Success = true;
} else if (auto *OnlyMissingElt = getSingleMissingElement()) {
Pred = CmpInst::ICMP_NE;
RHS = *OnlyMissingElt;
- Success = true;
} else if (getLower().isMinSignedValue() || getLower().isMinValue()) {
Pred =
getLower().isMinSignedValue() ? CmpInst::ICMP_SLT : CmpInst::ICMP_ULT;
RHS = getUpper();
- Success = true;
} else if (getUpper().isMinSignedValue() || getUpper().isMinValue()) {
Pred =
getUpper().isMinSignedValue() ? CmpInst::ICMP_SGE : CmpInst::ICMP_UGE;
RHS = getLower();
- Success = true;
+ } else {
+ Pred = CmpInst::ICMP_ULT;
+ RHS = getUpper() - getLower();
+ Offset = -getLower();
}
- assert((!Success || ConstantRange::makeExactICmpRegion(Pred, RHS) == *this) &&
+ assert(ConstantRange::makeExactICmpRegion(Pred, RHS) == add(Offset) &&
"Bad result!");
+}
- return Success;
+bool ConstantRange::getEquivalentICmp(CmpInst::Predicate &Pred,
+ APInt &RHS) const {
+ APInt Offset;
+ getEquivalentICmp(Pred, RHS, Offset);
+ return Offset.isZero();
}
bool ConstantRange::icmp(CmpInst::Predicate Pred,
diff --git a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
index 1b401566dad75..4892b06735eab 100644
--- a/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -3138,26 +3138,21 @@ Instruction *InstCombinerImpl::visitExtractValueInst(ExtractValueInst &EV) {
// checking for overflow.
const APInt *C;
if (match(WO->getRHS(), m_APInt(C))) {
- // Compute the no-wrap range [X,Y) for LHS given RHS=C, then
- // check for the inverted range using range offset trick (i.e.
- // use a subtract to shift the range to bottom of either the
- // signed or unsigned domain and then use a single compare to
- // check range membership).
+ // Compute the no-wrap range for LHS given RHS=C, then construct an
+ // equivalent icmp, potentially using an offset.
ConstantRange NWR =
ConstantRange::makeExactNoWrapRegion(WO->getBinaryOp(), *C,
WO->getNoWrapKind());
- APInt Min = WO->isSigned() ? NWR.getSignedMin() : NWR.getUnsignedMin();
- NWR = NWR.subtract(Min);
CmpInst::Predicate Pred;
- APInt NewRHSC;
- if (NWR.getEquivalentICmp(Pred, NewRHSC)) {
- auto *OpTy = WO->getRHS()->getType();
- auto *NewLHS = Builder.CreateSub(WO->getLHS(),
- ConstantInt::get(OpTy, Min));
- return new ICmpInst(ICmpInst::getInversePredicate(Pred), NewLHS,
- ConstantInt::get(OpTy, NewRHSC));
- }
+ APInt NewRHSC, Offset;
+ NWR.getEquivalentICmp(Pred, NewRHSC, Offset);
+ auto *OpTy = WO->getRHS()->getType();
+ auto *NewLHS = WO->getLHS();
+ if (Offset != 0)
+ NewLHS = Builder.CreateAdd(NewLHS, ConstantInt::get(OpTy, Offset));
+ return new ICmpInst(ICmpInst::getInversePredicate(Pred), NewLHS,
+ ConstantInt::get(OpTy, NewRHSC));
}
}
}
diff --git a/llvm/unittests/IR/ConstantRangeTest.cpp b/llvm/unittests/IR/ConstantRangeTest.cpp
index f88e9869bf24a..ac5c4455b526d 100644
--- a/llvm/unittests/IR/ConstantRangeTest.cpp
+++ b/llvm/unittests/IR/ConstantRangeTest.cpp
@@ -1972,6 +1972,23 @@ TEST(ConstantRange, GetEquivalentICmp) {
ConstantRange(APInt(32, -1)).inverse().getEquivalentICmp(Pred, RHS));
EXPECT_EQ(Pred, CmpInst::ICMP_NE);
EXPECT_EQ(RHS, APInt(32, -1));
+
+ EnumerateConstantRanges(4, [](const ConstantRange &CR) {
+ CmpInst::Predicate Pred;
+ APInt RHS, Offset;
+ CR.getEquivalentICmp(Pred, RHS, Offset);
+ ForeachNumInConstantRange(ConstantRange::getFull(4), [&](const APInt &N) {
+ bool Result = ICmpInst::compare(N + Offset, RHS, Pred);
+ EXPECT_EQ(CR.contains(N), Result);
+ });
+
+ if (CR.getEquivalentICmp(Pred, RHS)) {
+ ForeachNumInConstantRange(ConstantRange::getFull(4), [&](const APInt &N) {
+ bool Result = ICmpInst::compare(N, RHS, Pred);
+ EXPECT_EQ(CR.contains(N), Result);
+ });
+ }
+ });
}
#define EXPECT_MAY_OVERFLOW(op) \
More information about the llvm-commits
mailing list