From faf8d9472da1fdf294429007d70d9f00e607e9f9 Mon Sep 17 00:00:00 2001 From: Nikita Popov Date: Wed, 27 Mar 2019 18:19:33 +0000 Subject: [PATCH] [ConstantRange] Rename isWrappedSet() to isUpperWrapped() Split out from D59749. The current implementation of isWrappedSet() doesn't do what it says on the tin, and treats ranges like [X, Max] as wrapping, because they are represented as [X, 0) when using half-inclusive ranges. This also makes it inconsistent with the semantics of isSignWrappedSet(). This patch renames isWrappedSet() to isUpperWrapped(), in preparation for the introduction of a new isWrappedSet() method with corrected behavior. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@357107 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/ConstantRange.h | 9 ++++-- .../SelectionDAG/SelectionDAGBuilder.cpp | 2 +- lib/IR/ConstantRange.cpp | 32 +++++++++---------- unittests/IR/ConstantRangeTest.cpp | 10 +++--- 4 files changed, 28 insertions(+), 25 deletions(-) diff --git a/include/llvm/IR/ConstantRange.h b/include/llvm/IR/ConstantRange.h index 3ac853f3161..9612890000d 100644 --- a/include/llvm/IR/ConstantRange.h +++ b/include/llvm/IR/ConstantRange.h @@ -163,9 +163,12 @@ public: /// Return true if this set contains no members. bool isEmptySet() const; - /// Return true if this set wraps around the top of the range. - /// For example: [100, 8). - bool isWrappedSet() const; + /// Return true if the exclusive upper bound wraps around the unsigned + /// domain. Special cases: + /// * Empty set: Not wrapped. + /// * Full set: Not wrapped. + /// * [X, 0): Wrapped. + bool isUpperWrapped() const; /// Return true if this set wraps around the signed domain. Special cases: /// * Empty set: Not wrapped. diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 68994ae8e04..acd087a5083 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -8346,7 +8346,7 @@ SDValue SelectionDAGBuilder::lowerRangeToAssertZExt(SelectionDAG &DAG, return Op; ConstantRange CR = getConstantRangeFromMetadata(*Range); - if (CR.isFullSet() || CR.isEmptySet() || CR.isWrappedSet()) + if (CR.isFullSet() || CR.isEmptySet() || CR.isUpperWrapped()) return Op; APInt Lo = CR.getUnsignedMin(); diff --git a/lib/IR/ConstantRange.cpp b/lib/IR/ConstantRange.cpp index 0c2a3a86597..896a870bf90 100644 --- a/lib/IR/ConstantRange.cpp +++ b/lib/IR/ConstantRange.cpp @@ -344,7 +344,7 @@ bool ConstantRange::isEmptySet() const { return Lower == Upper && Lower.isMinValue(); } -bool ConstantRange::isWrappedSet() const { +bool ConstantRange::isUpperWrapped() const { return Lower.ugt(Upper); } @@ -382,13 +382,13 @@ ConstantRange::isSizeLargerThan(uint64_t MaxSize) const { } APInt ConstantRange::getUnsignedMax() const { - if (isFullSet() || isWrappedSet()) + if (isFullSet() || isUpperWrapped()) return APInt::getMaxValue(getBitWidth()); return getUpper() - 1; } APInt ConstantRange::getUnsignedMin() const { - if (isFullSet() || (isWrappedSet() && !getUpper().isNullValue())) + if (isFullSet() || (isUpperWrapped() && !getUpper().isNullValue())) return APInt::getMinValue(getBitWidth()); return getLower(); } @@ -409,7 +409,7 @@ bool ConstantRange::contains(const APInt &V) const { if (Lower == Upper) return isFullSet(); - if (!isWrappedSet()) + if (!isUpperWrapped()) return Lower.ule(V) && V.ult(Upper); return Lower.ule(V) || V.ult(Upper); } @@ -418,14 +418,14 @@ bool ConstantRange::contains(const ConstantRange &Other) const { if (isFullSet() || Other.isEmptySet()) return true; if (isEmptySet() || Other.isFullSet()) return false; - if (!isWrappedSet()) { - if (Other.isWrappedSet()) + if (!isUpperWrapped()) { + if (Other.isUpperWrapped()) return false; return Lower.ule(Other.getLower()) && Other.getUpper().ule(Upper); } - if (!Other.isWrappedSet()) + if (!Other.isUpperWrapped()) return Other.getUpper().ule(Upper) || Lower.ule(Other.getLower()); @@ -452,10 +452,10 @@ ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const { if ( isEmptySet() || CR.isFullSet()) return *this; if (CR.isEmptySet() || isFullSet()) return CR; - if (!isWrappedSet() && CR.isWrappedSet()) + if (!isUpperWrapped() && CR.isUpperWrapped()) return CR.intersectWith(*this); - if (!isWrappedSet() && !CR.isWrappedSet()) { + if (!isUpperWrapped() && !CR.isUpperWrapped()) { if (Lower.ult(CR.Lower)) { if (Upper.ule(CR.Lower)) return getEmpty(); @@ -474,7 +474,7 @@ ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const { return getEmpty(); } - if (isWrappedSet() && !CR.isWrappedSet()) { + if (isUpperWrapped() && !CR.isUpperWrapped()) { if (CR.Lower.ult(Upper)) { if (CR.Upper.ult(Upper)) return CR; @@ -525,9 +525,9 @@ ConstantRange ConstantRange::unionWith(const ConstantRange &CR) const { if ( isFullSet() || CR.isEmptySet()) return *this; if (CR.isFullSet() || isEmptySet()) return CR; - if (!isWrappedSet() && CR.isWrappedSet()) return CR.unionWith(*this); + if (!isUpperWrapped() && CR.isUpperWrapped()) return CR.unionWith(*this); - if (!isWrappedSet() && !CR.isWrappedSet()) { + if (!isUpperWrapped() && !CR.isUpperWrapped()) { if (CR.Upper.ult(Lower) || Upper.ult(CR.Lower)) { // If the two ranges are disjoint, find the smaller gap and bridge it. APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Upper; @@ -545,7 +545,7 @@ ConstantRange ConstantRange::unionWith(const ConstantRange &CR) const { return ConstantRange(std::move(L), std::move(U)); } - if (!CR.isWrappedSet()) { + if (!CR.isUpperWrapped()) { // ------U L----- and ------U L----- : this // L--U L--U : CR if (CR.Upper.ule(Upper) || CR.Lower.uge(Lower)) @@ -637,7 +637,7 @@ ConstantRange ConstantRange::zeroExtend(uint32_t DstTySize) const { unsigned SrcTySize = getBitWidth(); assert(SrcTySize < DstTySize && "Not a value extension"); - if (isFullSet() || isWrappedSet()) { + if (isFullSet() || isUpperWrapped()) { // Change into [0, 1 << src bit width) APInt LowerExt(DstTySize, 0); if (!Upper) // special case: [X, 0) -- not really wrapping around @@ -680,7 +680,7 @@ ConstantRange ConstantRange::truncate(uint32_t DstTySize) const { // Analyze wrapped sets in their two parts: [0, Upper) \/ [Lower, MaxValue] // We use the non-wrapped set code to analyze the [Lower, MaxValue) part, and // then we do the union with [MaxValue, Upper) - if (isWrappedSet()) { + if (isUpperWrapped()) { // If Upper is greater than or equal to MaxValue(DstTy), it covers the whole // truncated range. if (Upper.getActiveBits() > DstTySize || @@ -859,7 +859,7 @@ ConstantRange::multiply(const ConstantRange &Other) const { // from one positive number to another which is as good as we can generate. // In this case, skip the extra work of generating signed ranges which aren't // going to be better than this range. - if (!UR.isWrappedSet() && + if (!UR.isUpperWrapped() && (UR.getUpper().isNonNegative() || UR.getUpper().isMinSignedValue())) return UR; diff --git a/unittests/IR/ConstantRangeTest.cpp b/unittests/IR/ConstantRangeTest.cpp index c63c6cef7e1..0455df5fa5e 100644 --- a/unittests/IR/ConstantRangeTest.cpp +++ b/unittests/IR/ConstantRangeTest.cpp @@ -35,7 +35,7 @@ TEST_F(ConstantRangeTest, Basics) { EXPECT_TRUE(Full.isFullSet()); EXPECT_FALSE(Full.isEmptySet()); EXPECT_TRUE(Full.inverse().isEmptySet()); - EXPECT_FALSE(Full.isWrappedSet()); + EXPECT_FALSE(Full.isUpperWrapped()); EXPECT_TRUE(Full.contains(APInt(16, 0x0))); EXPECT_TRUE(Full.contains(APInt(16, 0x9))); EXPECT_TRUE(Full.contains(APInt(16, 0xa))); @@ -45,7 +45,7 @@ TEST_F(ConstantRangeTest, Basics) { EXPECT_FALSE(Empty.isFullSet()); EXPECT_TRUE(Empty.isEmptySet()); EXPECT_TRUE(Empty.inverse().isFullSet()); - EXPECT_FALSE(Empty.isWrappedSet()); + EXPECT_FALSE(Empty.isUpperWrapped()); EXPECT_FALSE(Empty.contains(APInt(16, 0x0))); EXPECT_FALSE(Empty.contains(APInt(16, 0x9))); EXPECT_FALSE(Empty.contains(APInt(16, 0xa))); @@ -54,7 +54,7 @@ TEST_F(ConstantRangeTest, Basics) { EXPECT_FALSE(One.isFullSet()); EXPECT_FALSE(One.isEmptySet()); - EXPECT_FALSE(One.isWrappedSet()); + EXPECT_FALSE(One.isUpperWrapped()); EXPECT_FALSE(One.contains(APInt(16, 0x0))); EXPECT_FALSE(One.contains(APInt(16, 0x9))); EXPECT_TRUE(One.contains(APInt(16, 0xa))); @@ -64,7 +64,7 @@ TEST_F(ConstantRangeTest, Basics) { EXPECT_FALSE(Some.isFullSet()); EXPECT_FALSE(Some.isEmptySet()); - EXPECT_FALSE(Some.isWrappedSet()); + EXPECT_FALSE(Some.isUpperWrapped()); EXPECT_FALSE(Some.contains(APInt(16, 0x0))); EXPECT_FALSE(Some.contains(APInt(16, 0x9))); EXPECT_TRUE(Some.contains(APInt(16, 0xa))); @@ -73,7 +73,7 @@ TEST_F(ConstantRangeTest, Basics) { EXPECT_FALSE(Wrap.isFullSet()); EXPECT_FALSE(Wrap.isEmptySet()); - EXPECT_TRUE(Wrap.isWrappedSet()); + EXPECT_TRUE(Wrap.isUpperWrapped()); EXPECT_TRUE(Wrap.contains(APInt(16, 0x0))); EXPECT_TRUE(Wrap.contains(APInt(16, 0x9))); EXPECT_FALSE(Wrap.contains(APInt(16, 0xa))); -- 2.50.1