X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FConstantRange.cpp;h=1e2a6375c457985cbd523c2a003136ba3ce7c22e;hb=6551dcdd8a6a28e060a9d6562a381220597dcae3;hp=3475c444dc83e2b8c1da5c1c399b597db5ebaf2c;hpb=8d89281989908fb8cd6e64f503c076e5c2b214e3;p=oota-llvm.git

diff --git a/lib/Support/ConstantRange.cpp b/lib/Support/ConstantRange.cpp
index 3475c444dc8..1e2a6375c45 100644
--- a/lib/Support/ConstantRange.cpp
+++ b/lib/Support/ConstantRange.cpp
@@ -22,232 +22,214 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ConstantRange.h"
-#include "llvm/Constants.h"
-#include "llvm/Instruction.h"
-#include "llvm/Type.h"
 #include "llvm/Support/Streams.h"
 #include <ostream>
 using namespace llvm;
 
-static ConstantIntegral *Next(ConstantIntegral *CI) {
-  if (ConstantBool *CB = dyn_cast<ConstantBool>(CI))
-    return ConstantBool::get(!CB->getValue());
-
-  Constant *Result = ConstantExpr::getAdd(CI,
-                                          ConstantInt::get(CI->getType(), 1));
-  return cast<ConstantIntegral>(Result);
-}
-
-static bool LT(ConstantIntegral *A, ConstantIntegral *B) {
-  Constant *C = ConstantExpr::getSetLT(A, B);
-  assert(isa<ConstantBool>(C) && "Constant folding of integrals not impl??");
-  return cast<ConstantBool>(C)->getValue();
-}
-
-static bool LTE(ConstantIntegral *A, ConstantIntegral *B) {
-  Constant *C = ConstantExpr::getSetLE(A, B);
-  assert(isa<ConstantBool>(C) && "Constant folding of integrals not impl??");
-  return cast<ConstantBool>(C)->getValue();
-}
-
-static bool GT(ConstantIntegral *A, ConstantIntegral *B) { return LT(B, A); }
-
-static ConstantIntegral *Min(ConstantIntegral *A, ConstantIntegral *B) {
-  return LT(A, B) ? A : B;
-}
-static ConstantIntegral *Max(ConstantIntegral *A, ConstantIntegral *B) {
-  return GT(A, B) ? A : B;
-}
-
 /// Initialize a full (the default) or empty set for the specified type.
 ///
-ConstantRange::ConstantRange(const Type *Ty, bool Full) {
-  assert(Ty->isIntegral() &&
-         "Cannot make constant range of non-integral type!");
+ConstantRange::ConstantRange(uint32_t BitWidth, bool Full) :
+  Lower(BitWidth, 0), Upper(BitWidth, 0) {
   if (Full)
-    Lower = Upper = ConstantIntegral::getMaxValue(Ty);
+    Lower = Upper = APInt::getMaxValue(BitWidth);
   else
-    Lower = Upper = ConstantIntegral::getMinValue(Ty);
+    Lower = Upper = APInt::getMinValue(BitWidth);
 }
 
 /// Initialize a range to hold the single specified value.
 ///
-ConstantRange::ConstantRange(Constant *V)
-  : Lower(cast<ConstantIntegral>(V)), Upper(Next(cast<ConstantIntegral>(V))) {
+ConstantRange::ConstantRange(const APInt & V) : Lower(V), Upper(V + 1) { }
+
+ConstantRange::ConstantRange(const APInt &L, const APInt &U) :
+  Lower(L), Upper(U) {
+  assert(L.getBitWidth() == U.getBitWidth() && 
+         "ConstantRange with unequal bit widths");
+  assert((L != U || (L.isMaxValue() || L.isMinValue())) &&
+         "Lower == Upper, but they aren't min or max value!");
 }
 
-/// Initialize a range of values explicitly... this will assert out if
-/// Lower==Upper and Lower != Min or Max for its type (or if the two constants
-/// have different types)
-///
-ConstantRange::ConstantRange(Constant *L, Constant *U)
-  : Lower(cast<ConstantIntegral>(L)), Upper(cast<ConstantIntegral>(U)) {
-  assert(Lower->getType() == Upper->getType() &&
-         "Incompatible types for ConstantRange!");
-
-  // Make sure that if L & U are equal that they are either Min or Max...
-  assert((L != U || (L == ConstantIntegral::getMaxValue(L->getType()) ||
-                     L == ConstantIntegral::getMinValue(L->getType()))) &&
-         "Lower == Upper, but they aren't min or max for type!");
-}
-
-/// Initialize a set of values that all satisfy the condition with C.
-///
-ConstantRange::ConstantRange(unsigned SetCCOpcode, ConstantIntegral *C) {
-  switch (SetCCOpcode) {
-  default: assert(0 && "Invalid SetCC opcode to ConstantRange ctor!");
-  case Instruction::SetEQ: Lower = C; Upper = Next(C); return;
-  case Instruction::SetNE: Upper = C; Lower = Next(C); return;
-  case Instruction::SetLT:
-    Lower = ConstantIntegral::getMinValue(C->getType());
-    Upper = C;
-    return;
-  case Instruction::SetGT:
-    Lower = Next(C);
-    Upper = ConstantIntegral::getMinValue(C->getType());  // Min = Next(Max)
-    return;
-  case Instruction::SetLE:
-    Lower = ConstantIntegral::getMinValue(C->getType());
-    Upper = Next(C);
-    return;
-  case Instruction::SetGE:
-    Lower = C;
-    Upper = ConstantIntegral::getMinValue(C->getType());  // Min = Next(Max)
-    return;
-  }
-}
-
-/// getType - Return the LLVM data type of this range.
-///
-const Type *ConstantRange::getType() const { return Lower->getType(); }
-
 /// isFullSet - Return true if this set contains all of the elements possible
 /// for this data-type
 bool ConstantRange::isFullSet() const {
-  return Lower == Upper && Lower == ConstantIntegral::getMaxValue(getType());
+  return Lower == Upper && Lower.isMaxValue();
 }
 
 /// isEmptySet - Return true if this set contains no members.
 ///
 bool ConstantRange::isEmptySet() const {
-  return Lower == Upper && Lower == ConstantIntegral::getMinValue(getType());
+  return Lower == Upper && Lower.isMinValue();
 }
 
 /// isWrappedSet - Return true if this set wraps around the top of the range,
 /// for example: [100, 8)
 ///
 bool ConstantRange::isWrappedSet() const {
-  return GT(Lower, Upper);
-}
-
-
-/// getSingleElement - If this set contains a single element, return it,
-/// otherwise return null.
-ConstantIntegral *ConstantRange::getSingleElement() const {
-  if (Upper == Next(Lower))  // Is it a single element range?
-    return Lower;
-  return 0;
+  return Lower.ugt(Upper);
 }
 
 /// getSetSize - Return the number of elements in this set.
 ///
-uint64_t ConstantRange::getSetSize() const {
-  if (isEmptySet()) return 0;
-  if (getType() == Type::BoolTy) {
+APInt ConstantRange::getSetSize() const {
+  if (isEmptySet()) 
+    return APInt(getBitWidth(), 0);
+  if (getBitWidth() == 1) {
     if (Lower != Upper)  // One of T or F in the set...
-      return 1;
-    return 2;            // Must be full set...
+      return APInt(2, 1);
+    return APInt(2, 2);      // Must be full set...
   }
 
   // Simply subtract the bounds...
-  Constant *Result = ConstantExpr::getSub(Upper, Lower);
-  return cast<ConstantInt>(Result)->getZExtValue();
+  return Upper - Lower;
 }
 
-/// contains - Return true if the specified value is in the set.
+/// getUnsignedMax - Return the largest unsigned value contained in the
+/// ConstantRange.
+///
+APInt ConstantRange::getUnsignedMax() const {
+  if (isFullSet() || isWrappedSet())
+    return APInt::getMaxValue(getBitWidth());
+  else
+    return getUpper() - 1;
+}
+
+/// getUnsignedMin - Return the smallest unsigned value contained in the
+/// ConstantRange.
+///
+APInt ConstantRange::getUnsignedMin() const {
+  if (isFullSet() || (isWrappedSet() && getUpper() != 0))
+    return APInt::getMinValue(getBitWidth());
+  else
+    return getLower();
+}
+
+/// getSignedMax - Return the largest signed value contained in the
+/// ConstantRange.
 ///
-bool ConstantRange::contains(ConstantInt *Val) const {
-  if (Lower == Upper) {
-    if (isFullSet()) return true;
-    return false;
+APInt ConstantRange::getSignedMax() const {
+  APInt SignedMax(APInt::getSignedMaxValue(getBitWidth()));
+  if (!isWrappedSet()) {
+    if (getLower().slt(getUpper() - 1))
+      return getUpper() - 1;
+    else
+      return SignedMax;
+  } else {
+    if ((getUpper() - 1).slt(getLower())) {
+      if (getLower() != SignedMax)
+        return SignedMax;
+      else
+        return getUpper() - 1;
+    } else {
+      return getUpper() - 1;
+    }
   }
+}
 
-  if (!isWrappedSet())
-    return LTE(Lower, Val) && LT(Val, Upper);
-  return LTE(Lower, Val) || LT(Val, Upper);
+/// getSignedMin - Return the smallest signed value contained in the
+/// ConstantRange.
+///
+APInt ConstantRange::getSignedMin() const {
+  APInt SignedMin(APInt::getSignedMinValue(getBitWidth()));
+  if (!isWrappedSet()) {
+    if (getLower().slt(getUpper() - 1))
+      return getLower();
+    else
+      return SignedMin;
+  } else {
+    if ((getUpper() - 1).slt(getLower())) {
+      if (getUpper() != SignedMin)
+        return SignedMin;
+      else
+        return getLower();
+    } else {
+      return getLower();
+    }
+  }
 }
 
+/// contains - Return true if the specified value is in the set.
+///
+bool ConstantRange::contains(const APInt &V) const {
+  if (Lower == Upper)
+    return isFullSet();
 
+  if (!isWrappedSet())
+    return Lower.ule(V) && V.ult(Upper);
+  else
+    return Lower.ule(V) || V.ult(Upper);
+}
 
 /// subtract - Subtract the specified constant from the endpoints of this
 /// constant range.
-ConstantRange ConstantRange::subtract(ConstantInt *CI) const {
-  assert(CI->getType() == getType() && getType()->isInteger() &&
-         "Cannot subtract from different type range or non-integer!");
+ConstantRange ConstantRange::subtract(const APInt &Val) const {
+  assert(Val.getBitWidth() == getBitWidth() && "Wrong bit width");
   // If the set is empty or full, don't modify the endpoints.
-  if (Lower == Upper) return *this;
-  return ConstantRange(ConstantExpr::getSub(Lower, CI),
-                       ConstantExpr::getSub(Upper, CI));
+  if (Lower == Upper) 
+    return *this;
+  return ConstantRange(Lower - Val, Upper - Val);
 }
 
 
 // intersect1Wrapped - This helper function is used to intersect two ranges when
 // it is known that LHS is wrapped and RHS isn't.
 //
-static ConstantRange intersect1Wrapped(const ConstantRange &LHS,
-                                       const ConstantRange &RHS) {
+ConstantRange 
+ConstantRange::intersect1Wrapped(const ConstantRange &LHS,
+                                 const ConstantRange &RHS) {
   assert(LHS.isWrappedSet() && !RHS.isWrappedSet());
 
   // Check to see if we overlap on the Left side of RHS...
   //
-  if (LT(RHS.getLower(), LHS.getUpper())) {
+  if (RHS.Lower.ult(LHS.Upper)) {
     // We do overlap on the left side of RHS, see if we overlap on the right of
     // RHS...
-    if (GT(RHS.getUpper(), LHS.getLower())) {
+    if (RHS.Upper.ugt(LHS.Lower)) {
       // Ok, the result overlaps on both the left and right sides.  See if the
       // resultant interval will be smaller if we wrap or not...
       //
-      if (LHS.getSetSize() < RHS.getSetSize())
+      if (LHS.getSetSize().ult(RHS.getSetSize()))
         return LHS;
       else
         return RHS;
 
     } else {
       // No overlap on the right, just on the left.
-      return ConstantRange(RHS.getLower(), LHS.getUpper());
+      return ConstantRange(RHS.Lower, LHS.Upper);
     }
-
   } else {
     // We don't overlap on the left side of RHS, see if we overlap on the right
     // of RHS...
-    if (GT(RHS.getUpper(), LHS.getLower())) {
+    if (RHS.Upper.ugt(LHS.Lower)) {
       // Simple overlap...
-      return ConstantRange(LHS.getLower(), RHS.getUpper());
+      return ConstantRange(LHS.Lower, RHS.Upper);
     } else {
       // No overlap...
-      return ConstantRange(LHS.getType(), false);
+      return ConstantRange(LHS.getBitWidth(), false);
     }
   }
 }
 
-/// intersect - Return the range that results from the intersection of this
+/// intersectWith - Return the range that results from the intersection of this
 /// range with another range.
 ///
 ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const {
-  assert(getType() == CR.getType() && "ConstantRange types don't agree!");
+  assert(getBitWidth() == CR.getBitWidth() && 
+         "ConstantRange types don't agree!");
   // Handle common special cases
-  if (isEmptySet() || CR.isFullSet())  return *this;
-  if (isFullSet()  || CR.isEmptySet()) return CR;
+  if (isEmptySet() || CR.isFullSet())  
+    return *this;
+  if (isFullSet()  || CR.isEmptySet()) 
+    return CR;
 
   if (!isWrappedSet()) {
     if (!CR.isWrappedSet()) {
-      ConstantIntegral *L = Max(Lower, CR.Lower);
-      ConstantIntegral *U = Min(Upper, CR.Upper);
+      using namespace APIntOps;
+      APInt L = umax(Lower, CR.Lower);
+      APInt U = umin(Upper, CR.Upper);
 
-      if (LT(L, U))  // If range isn't empty...
+      if (L.ult(U)) // If range isn't empty...
         return ConstantRange(L, U);
       else
-        return ConstantRange(getType(), false);  // Otherwise, return empty set
+        return ConstantRange(getBitWidth(), false);// Otherwise, empty set
     } else
       return intersect1Wrapped(CR, *this);
   } else {   // We know "this" is wrapped...
@@ -255,78 +237,155 @@ ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const {
       return intersect1Wrapped(*this, CR);
     else {
       // Both ranges are wrapped...
-      ConstantIntegral *L = Max(Lower, CR.Lower);
-      ConstantIntegral *U = Min(Upper, CR.Upper);
+      using namespace APIntOps;
+      APInt L = umax(Lower, CR.Lower);
+      APInt U = umin(Upper, CR.Upper);
       return ConstantRange(L, U);
     }
   }
   return *this;
 }
 
-/// union - Return the range that results from the union of this range with
+/// unionWith - Return the range that results from the union of this range with
 /// another range.  The resultant range is guaranteed to include the elements of
-/// both sets, but may contain more.  For example, [3, 9) union [12,15) is [3,
-/// 15), which includes 9, 10, and 11, which were not included in either set
-/// before.
+/// both sets, but may contain more.  For example, [3, 9) union [12,15) is
+/// [3, 15), which includes 9, 10, and 11, which were not included in either
+/// set before.
 ///
 ConstantRange ConstantRange::unionWith(const ConstantRange &CR) const {
-  assert(getType() == CR.getType() && "ConstantRange types don't agree!");
+  assert(getBitWidth() == CR.getBitWidth() && 
+         "ConstantRange types don't agree!");
 
-  assert(0 && "Range union not implemented yet!");
+  if (   isFullSet() || CR.isEmptySet()) return *this;
+  if (CR.isFullSet() ||    isEmptySet()) return CR;
 
-  return *this;
+  if (!isWrappedSet() && CR.isWrappedSet()) return CR.unionWith(*this);
+
+  APInt L = Lower, U = Upper;
+
+  if (!isWrappedSet() && !CR.isWrappedSet()) {
+    if (CR.Lower.ult(L))
+      L = CR.Lower;
+
+    if (CR.Upper.ugt(U))
+      U = CR.Upper;
+  }
+
+  if (isWrappedSet() && !CR.isWrappedSet()) {
+    if ((CR.Lower.ult(Upper) && CR.Upper.ult(Upper)) ||
+        (CR.Lower.ugt(Lower) && CR.Upper.ugt(Lower))) {
+      return *this;
+    }
+
+    if (CR.Lower.ule(Upper) && Lower.ule(CR.Upper)) {
+      return ConstantRange(getBitWidth());
+    }
+
+    if (CR.Lower.ule(Upper) && CR.Upper.ule(Lower)) {
+      APInt d1 = CR.Upper - Upper, d2 = Lower - CR.Upper;
+      if (d1.ult(d2)) {
+        U = CR.Upper;
+      } else {
+        L = CR.Upper;
+      }
+    }
+
+    if (Upper.ult(CR.Lower) && CR.Upper.ult(Lower)) {
+      APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Upper;
+      if (d1.ult(d2)) {
+        U = CR.Lower + 1;
+      } else {
+        L = CR.Upper - 1;
+      }
+    }
+
+    if (Upper.ult(CR.Lower) && Lower.ult(CR.Upper)) {
+      APInt d1 = CR.Lower - Upper, d2 = Lower - CR.Lower;
+
+      if (d1.ult(d2)) {
+        U = CR.Lower + 1;
+      } else {
+        L = CR.Lower;
+      }
+    }
+  }
+
+  if (isWrappedSet() && CR.isWrappedSet()) {
+    if (Lower.ult(CR.Upper) || CR.Lower.ult(Upper))
+      return ConstantRange(getBitWidth());
+
+    if (CR.Upper.ugt(U)) {
+      U = CR.Upper;
+    }
+
+    if (CR.Lower.ult(L)) {
+      L = CR.Lower;
+    }
+
+    if (L == U) return ConstantRange(getBitWidth());
+  }
+
+  return ConstantRange(L, U);
 }
 
 /// zeroExtend - Return a new range in the specified integer type, which must
 /// be strictly larger than the current type.  The returned range will
-/// correspond to the possible range of values if the source range had been
+/// correspond to the possible range of values as if the source range had been
 /// zero extended.
-ConstantRange ConstantRange::zeroExtend(const Type *Ty) const {
-  assert(getLower()->getType()->getPrimitiveSize() < Ty->getPrimitiveSize() &&
-         "Not a value extension");
-  if (isFullSet()) {
+ConstantRange ConstantRange::zeroExtend(uint32_t DstTySize) const {
+  unsigned SrcTySize = getBitWidth();
+  assert(SrcTySize < DstTySize && "Not a value extension");
+  if (isFullSet())
     // Change a source full set into [0, 1 << 8*numbytes)
-    unsigned SrcTySize = getLower()->getType()->getPrimitiveSize();
-    return ConstantRange(Constant::getNullValue(Ty),
-                         ConstantInt::get(Ty, 1ULL << SrcTySize*8));
-  }
+    return ConstantRange(APInt(DstTySize,0), APInt(DstTySize,1).shl(SrcTySize));
 
-  Constant *Lower = getLower();
-  Constant *Upper = getUpper();
-  if (Lower->getType()->isInteger() && !Lower->getType()->isUnsigned()) {
-    // Ensure we are doing a ZERO extension even if the input range is signed.
-    Lower = ConstantExpr::getCast(Lower, Ty->getUnsignedVersion());
-    Upper = ConstantExpr::getCast(Upper, Ty->getUnsignedVersion());
+  APInt L = Lower; L.zext(DstTySize);
+  APInt U = Upper; U.zext(DstTySize);
+  return ConstantRange(L, U);
+}
+
+/// signExtend - Return a new range in the specified integer type, which must
+/// be strictly larger than the current type.  The returned range will
+/// correspond to the possible range of values as if the source range had been
+/// sign extended.
+ConstantRange ConstantRange::signExtend(uint32_t DstTySize) const {
+  unsigned SrcTySize = getBitWidth();
+  assert(SrcTySize < DstTySize && "Not a value extension");
+  if (isFullSet()) {
+    return ConstantRange(APInt::getHighBitsSet(DstTySize,DstTySize-SrcTySize+1),
+                         APInt::getLowBitsSet(DstTySize, SrcTySize-1));
   }
 
-  return ConstantRange(ConstantExpr::getCast(Lower, Ty),
-                       ConstantExpr::getCast(Upper, Ty));
+  APInt L = Lower; L.sext(DstTySize);
+  APInt U = Upper; U.sext(DstTySize);
+  return ConstantRange(L, U);
 }
 
 /// truncate - Return a new range in the specified integer type, which must be
 /// strictly smaller than the current type.  The returned range will
-/// correspond to the possible range of values if the source range had been
+/// correspond to the possible range of values as if the source range had been
 /// truncated to the specified type.
-ConstantRange ConstantRange::truncate(const Type *Ty) const {
-  assert(getLower()->getType()->getPrimitiveSize() > Ty->getPrimitiveSize() &&
-         "Not a value truncation");
-  uint64_t Size = 1ULL << Ty->getPrimitiveSize()*8;
-  if (isFullSet() || getSetSize() >= Size)
-    return ConstantRange(getType());
-
-  return ConstantRange(ConstantExpr::getCast(getLower(), Ty),
-                       ConstantExpr::getCast(getUpper(), Ty));
+ConstantRange ConstantRange::truncate(uint32_t DstTySize) const {
+  unsigned SrcTySize = getBitWidth();
+  assert(SrcTySize > DstTySize && "Not a value truncation");
+  APInt Size(APInt::getLowBitsSet(SrcTySize, DstTySize));
+  if (isFullSet() || getSetSize().ugt(Size))
+    return ConstantRange(DstTySize);
+
+  APInt L = Lower; L.trunc(DstTySize);
+  APInt U = Upper; U.trunc(DstTySize);
+  return ConstantRange(L, U);
 }
 
-
 /// print - Print out the bounds to a stream...
 ///
 void ConstantRange::print(std::ostream &OS) const {
-  OS << "[" << *Lower << "," << *Upper << " )";
+  OS << "[" << Lower.toStringSigned(10) << "," 
+            << Upper.toStringSigned(10) << " )";
 }
 
 /// dump - Allow printing from a debugger easily...
 ///
 void ConstantRange::dump() const {
-  print(llvm_cerr);
+  print(cerr);
 }