[ConstantRange] Exclude full set from isSignWrappedSet()

[nikic]

Summary

Split off from D59749. This uses a simpler and more efficient implementation of isSignWrappedSet(), and considers full sets as non-wrapped, to be consistent with isWrappedSet(). Otherwise the behavior is unchanged.

There are currently only two users of this function and both already check for isFullSet() || isSignWrappedSet(), so this is not going to cause a change in overall behavior:

lib/IR/ConstantRange.cpp:  if (isFullSet() || isSignWrappedSet()) {
lib/Transforms/Scalar/Float2Int.cpp:        R.isFullSet() || R.isSignWrappedSet())

[lebedev.ri]

This LG.

llvm/trunk/include/llvm/IR/ConstantRange.h

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 this set wraps around the INT_MIN of
-  /// its bitwidth. For example: i8 [120, 140).
+  /// Return true if this set wraps around the signed domain. Special cases:
+  ///  * Empty set: Not wrapped.
+  ///  * Full set: Not wrapped.
+  ///  * [X, SignedMin) == [X, SignedMax]: Not wrapped.
   bool isSignWrappedSet() const;
 
   /// Return true if the specified value is in the set.
   bool contains(const APInt &Val) const;
 
   /// Return true if the other range is a subset of this one.
   bool contains(const ConstantRange &CR) const;
 

llvm/trunk/lib/IR/ConstantRange.cpp

bool ConstantRange::isEmptySet() const {
   return Lower == Upper && Lower.isMinValue();
 }
 
 bool ConstantRange::isWrappedSet() const {
   return Lower.ugt(Upper);
 }
 
 bool ConstantRange::isSignWrappedSet() const {
-  return contains(APInt::getSignedMaxValue(getBitWidth())) &&
-         contains(APInt::getSignedMinValue(getBitWidth()));
+  return Lower.sgt(Upper) && !Upper.isMinSignedValue();
 }
 
 APInt ConstantRange::getSetSize() const {
   if (isFullSet())
     return APInt::getOneBitSet(getBitWidth()+1, getBitWidth());
 
   // This is also correct for wrapped sets.
   return (Upper - Lower).zext(getBitWidth()+1);

llvm/trunk/unittests/IR/ConstantRangeTest.cpp

TEST_F(ConstantRangeTest, GetMinsAndMaxes) {
   EXPECT_EQ(Wrap.getSignedMin(), APInt(16, (uint64_t)INT16_MIN));
 
   // Found by Klee
   EXPECT_EQ(ConstantRange(APInt(4, 7), APInt(4, 0)).getSignedMax(),
             APInt(4, 7));
 }
 
 TEST_F(ConstantRangeTest, SignWrapped) {
-  EXPECT_TRUE(Full.isSignWrappedSet());
+  EXPECT_FALSE(Full.isSignWrappedSet());
   EXPECT_FALSE(Empty.isSignWrappedSet());
   EXPECT_FALSE(One.isSignWrappedSet());
   EXPECT_FALSE(Some.isSignWrappedSet());
   EXPECT_TRUE(Wrap.isSignWrappedSet());
 
   EXPECT_FALSE(ConstantRange(APInt(8, 127), APInt(8, 128)).isSignWrappedSet());
   EXPECT_TRUE(ConstantRange(APInt(8, 127), APInt(8, 129)).isSignWrappedSet());
   EXPECT_FALSE(ConstantRange(APInt(8, 128), APInt(8, 129)).isSignWrappedSet());