Now that we're using ConstantRange to represent potential values, make use of that represenation to

create constraints from comparisons other than eq/neq.

llvm-svn: 110742

1 files changed, 35 insertions, 8 deletions

diff --git a/llvm/lib/Analysis/LazyValueInfo.cpp b/llvm/lib/Analysis/LazyValueInfo.cpp
index 7ec35cdcc5b..48778232002 100644
--- a/llvm/lib/Analysis/LazyValueInfo.cpp
+++ b/llvm/lib/Analysis/LazyValueInfo.cpp
@@ -91,6 +91,11 @@ public:
       Res.markNotConstant(C);
     return Res;
   }
+  static LVILatticeVal getRange(ConstantRange CR) {
+    LVILatticeVal Res;
+    Res.markConstantRange(CR);
+    return Res;
+  }
   
   bool isUndefined() const     { return Tag == undefined; }
   bool isConstant() const      { return Tag == constant; }
@@ -507,13 +512,35 @@ LVILatticeVal LVIQuery::getEdgeValue(BasicBlock *BBFrom, BasicBlock *BBTo) {
       // If the condition of the branch is an equality comparison, we may be
       // able to infer the value.
       if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition()))
-        if (ICI->isEquality() && ICI->getOperand(0) == Val &&
-            isa<Constant>(ICI->getOperand(1))) {
-          // We know that V has the RHS constant if this is a true SETEQ or
-          // false SETNE. 
-          if (isTrueDest == (ICI->getPredicate() == ICmpInst::ICMP_EQ))
-            return LVILatticeVal::get(cast<Constant>(ICI->getOperand(1)));
-          return LVILatticeVal::getNot(cast<Constant>(ICI->getOperand(1)));
+        if (ICI->getOperand(0) == Val && isa<Constant>(ICI->getOperand(1))) {
+          if (ICI->isEquality()) {
+            // We know that V has the RHS constant if this is a true SETEQ or
+            // false SETNE. 
+            if (isTrueDest == (ICI->getPredicate() == ICmpInst::ICMP_EQ))
+              return LVILatticeVal::get(cast<Constant>(ICI->getOperand(1)));
+            return LVILatticeVal::getNot(cast<Constant>(ICI->getOperand(1)));
+          } else if (ConstantInt *CI =
+                                   dyn_cast<ConstantInt>(ICI->getOperand(1))) {
+            
+            // Calculate the range of values that would satisfy the comparison.
+            ConstantRange CmpRange(CI->getValue(), CI->getValue()+1);
+            ConstantRange TrueValues =
+              ConstantRange::makeICmpRegion(ICI->getPredicate(), CmpRange);
+            
+            // If we're interested in the false dest, invert the condition.
+            if (!isTrueDest) TrueValues = TrueValues.inverse();
+            
+            // Figure out the possible values of the query BEFORE this branch.  
+            LVILatticeVal InBlock = getBlockValue(BBFrom);
+            if (!InBlock.isConstantRange()) return InBlock;
+            
+            // Find all potential values that satisfy both the input and output
+            // conditions.
+            ConstantRange PossibleValues =
+              TrueValues.intersectWith(InBlock.getConstantRange());
+            
+            return LVILatticeVal::getRange(PossibleValues);
+          }
         }
     }
   }
@@ -730,7 +757,7 @@ LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
     ConstantRange TrueValues = ConstantRange::makeICmpRegion(Pred, RHS);
     if (CR.intersectWith(TrueValues).isEmptySet())
       return False;
-    else if (CR.intersectWith(TrueValues) == CR)
+    else if (TrueValues.contains(CR))
       return True;
     
     return Unknown;