[LVI] Move LVILatticeVal class to separate header file (NFC).

[fhahn]

Summary

This allows sharing the lattice value code between LVI and SCCP (D36656).

It also adds a satisfiesPredicate function, used by D36656.

[fhahn]

Fix formatting issue

[sanjoy]

This isn't a "move" right, since you didn't delete the original?

[fhahn]

In D37591#863991, @sanjoy wrote:

This isn't a "move" right, since you didn't delete the original?

Err yes indeed, I did not upload the latest version of the diff :/ I'll upload the full diff tomorrow.

[fhahn]

Remove duplicated code

[sanjoy]

include/llvm/Analysis/ValueLattice.h

28

I think this should no longer be called LVILatticeVal, now that it is used outside LVI.

85

Since you're moving the code anyway, can you also run clang-format over this file?

180

Now that this lives outside LVI, we need to be clearer about what this actually does (modifies *this to approximate both *this and RHS).

234

This can also work for:

• ConstantExpr for ICMP_EQ.
• undefined

246

Why doesn't ConstantRange::makeSatisfyingICmpRegion work for ICMP_NE and ICMP_EQ?

Please also add a test case to unittests/ for this function.

[fhahn]

@sanjoy thank you very much for the review and sorry for taking a while to update the patch.

[fhahn]

include/llvm/Analysis/ValueLattice.h

28

Agreed, I named it to ValueLatticeVal, which is slightly longer.

246

ConstantRange::makeSatisfyingICmpRegion works on those cases too, thanks! I've added unit tests too

[sanjoy]

LGTM with nits

include/llvm/Analysis/ValueLattice.h

27

Let's call this ValueLatticeElement. It is a bit verbose, but I think it is to the point, and with auto the more verbose type name probably won't bite us as much.

176

Please elaborate on what "Merge" means in this context.

244

Is the LLVM_ATTRIBUTE_USED still needed?

[fhahn]

Thanks @sanjoy! Addressed nits

[fhahn]

include/llvm/Analysis/ValueLattice.h

244

Nope it is not I think. I've removed it.

include/llvm/Analysis/ValueLattice.h

+//===- ValueLattice.h - Value constraint analysis ---------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_VALUELATTICE_H
+#define LLVM_ANALYSIS_VALUELATTICE_H
+
+#include "llvm/IR/ConstantRange.h"
+#include "llvm/IR/Constants.h"
+//
+//===----------------------------------------------------------------------===//
+//                               ValueLatticeVal
+//===----------------------------------------------------------------------===//
+
+/// This class represents lattice values for constants.
+///
+/// FIXME: This is basically just for bringup, this can be made a lot more rich
+/// in the future.
+///
+
+namespace llvm {
+class ValueLatticeVal {
+  enum ValueLatticeValueTy {
+    /// This Value has no known value yet.  As a result, this implies the
+    /// producing instruction is dead.  Caution: We use this as the starting
+    /// state in our local meet rules.  In this usage, it's taken to mean
+    /// "nothing known yet".
+    undefined,
+
+    /// This Value has a specific constant value.  (For constant integers,
+    /// constantrange is used instead.  Integer typed constantexprs can appear
+    /// as constant.)
+    constant,
+
+    /// This Value is known to not have the specified value.  (For constant
+    /// integers, constantrange is used instead.  As above, integer typed
+    /// constantexprs can appear here.)
+    notconstant,
+
+    /// The Value falls within this range. (Used only for integer typed values.)
+    constantrange,
+
+    /// We can not precisely model the dynamic values this value might take.
+    overdefined
+  };
+
+  /// Val: This stores the current lattice value along with the Constant* for
+  /// the constant if this is a 'constant' or 'notconstant' value.
+  ValueLatticeValueTy Tag;
+  Constant *Val;
+  ConstantRange Range;
+
+public:
+  ValueLatticeVal() : Tag(undefined), Val(nullptr), Range(1, true) {}
+
+  static ValueLatticeVal get(Constant *C) {
+    ValueLatticeVal Res;
+    if (!isa<UndefValue>(C))
+      Res.markConstant(C);
+    return Res;
+  }
+  static ValueLatticeVal getNot(Constant *C) {
+    ValueLatticeVal Res;
+    if (!isa<UndefValue>(C))
+      Res.markNotConstant(C);
+    return Res;
+  }
+  static ValueLatticeVal getRange(ConstantRange CR) {
+    ValueLatticeVal Res;
+    Res.markConstantRange(std::move(CR));
+    return Res;
+  }
+  static ValueLatticeVal getOverdefined() {
+    ValueLatticeVal Res;
+    Res.markOverdefined();
+    return Res;
+  }
+
+  bool isUndefined() const { return Tag == undefined; }
+  bool isConstant() const { return Tag == constant; }
+  bool isNotConstant() const { return Tag == notconstant; }
+  bool isConstantRange() const { return Tag == constantrange; }
+  bool isOverdefined() const { return Tag == overdefined; }
+
+  Constant *getConstant() const {
+    assert(isConstant() && "Cannot get the constant of a non-constant!");
+    return Val;
+  }
+
+  Constant *getNotConstant() const {
+    assert(isNotConstant() && "Cannot get the constant of a non-notconstant!");
+    return Val;
+  }
+
+  const ConstantRange &getConstantRange() const {
+    assert(isConstantRange() &&
+           "Cannot get the constant-range of a non-constant-range!");
+    return Range;
+  }
+
+  Optional<APInt> asConstantInteger() const {
+    if (isConstant() && isa<ConstantInt>(Val)) {
+      return cast<ConstantInt>(Val)->getValue();
+    } else if (isConstantRange() && Range.isSingleElement()) {
+      return *Range.getSingleElement();
+    }
+    return None;
+  }
+
+private:
+  void markOverdefined() {
+    if (isOverdefined())
+      return;
+    Tag = overdefined;
+  }
+
+  void markConstant(Constant *V) {
+    assert(V && "Marking constant with NULL");
+    if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+      markConstantRange(ConstantRange(CI->getValue()));
+      return;
+    }
+    if (isa<UndefValue>(V))
+      return;
+
+    assert((!isConstant() || getConstant() == V) &&
+           "Marking constant with different value");
+    assert(isUndefined());
+    Tag = constant;
+    Val = V;
+  }
+
+  void markNotConstant(Constant *V) {
+    assert(V && "Marking constant with NULL");
+    if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
+      markConstantRange(ConstantRange(CI->getValue() + 1, CI->getValue()));
+      return;
+    }
+    if (isa<UndefValue>(V))
+      return;
+
+    assert((!isConstant() || getConstant() != V) &&
+           "Marking constant !constant with same value");
+    assert((!isNotConstant() || getNotConstant() == V) &&
+           "Marking !constant with different value");
+    assert(isUndefined() || isConstant());
+    Tag = notconstant;
+    Val = V;
+  }
+
+  void markConstantRange(ConstantRange NewR) {
+    if (isConstantRange()) {
+      if (NewR.isEmptySet())
+        markOverdefined();
+      else {
+        Range = std::move(NewR);
+      }
+      return;
+    }
+
+    assert(isUndefined());
+    if (NewR.isEmptySet())
+      markOverdefined();
+    else {
+      Tag = constantrange;
+      Range = std::move(NewR);
+    }
+  }
+
+public:
+  /// Merge the specified lattice value into this one, updating this
+  /// one and returning true if anything changed.
+  bool mergeIn(const ValueLatticeVal &RHS, const DataLayout &DL) {
+    if (RHS.isUndefined() || isOverdefined())
+      return false;
+    if (RHS.isOverdefined()) {
+      markOverdefined();
+      return true;
+    }
+
+    if (isUndefined()) {
+      *this = RHS;
+      return !RHS.isUndefined();
+    }
+
+    if (isConstant()) {
+      if (RHS.isConstant() && Val == RHS.Val)
+        return false;
+      markOverdefined();
+      return true;
+    }
+
+    if (isNotConstant()) {
+      if (RHS.isNotConstant() && Val == RHS.Val)
+        return false;
+      markOverdefined();
+      return true;
+    }
+
+    assert(isConstantRange() && "New ValueLattice type?");
+    if (!RHS.isConstantRange()) {
+      // We can get here if we've encountered a constantexpr of integer type
+      // and merge it with a constantrange.
+      markOverdefined();
+      return true;
+    }
+    ConstantRange NewR = Range.unionWith(RHS.getConstantRange());
+    if (NewR.isFullSet())
+      markOverdefined();
+    else
+      markConstantRange(std::move(NewR));
+    return true;
+  }
+
+  ConstantInt *getConstantInt() const {
+    assert(isConstant() && isa<ConstantInt>(getConstant()) &&
+           "No integer constant");
+    return cast<ConstantInt>(getConstant());
+  }
+
+  bool satisfiesPredicate(CmpInst::Predicate Pred,
+                          const ValueLatticeVal &Other) const {
+    // TODO: share with LVI getPredicateResult.
+
+    if (isConstant() && Other.isConstant() && Pred == CmpInst::FCMP_OEQ)
+      return getConstant() == Other.getConstant();
+
+    // Integer constants are represented as ConstantRanges with single
+    // elements.
+    if (!isConstantRange() || !Other.isConstantRange())
+      return false;
+
+    const auto &CR = getConstantRange();
+    const auto &OtherCR = Other.getConstantRange();
+    return ConstantRange::makeSatisfyingICmpRegion(Pred, OtherCR).contains(CR);
+  }
+};
+
+raw_ostream &operator<<(raw_ostream &OS,
+                        const ValueLatticeVal &Val) LLVM_ATTRIBUTE_USED;
+} // end namespace llvm
+#endif

lib/Analysis/CMakeLists.txt

add_llvm_library(LLVMAnalysis
   ScalarEvolutionNormalization.cpp
   SparsePropagation.cpp
   TargetLibraryInfo.cpp
   TargetTransformInfo.cpp
   Trace.cpp
   TypeBasedAliasAnalysis.cpp
   TypeMetadataUtils.cpp
   ScopedNoAliasAA.cpp
+  ValueLattice.cpp
   ValueTracking.cpp
   VectorUtils.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Analysis
 
   DEPENDS
   intrinsics_gen
   )

lib/Analysis/LazyValueInfo.cpp

 #include "llvm/Analysis/LazyValueInfo.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
+#include "llvm/Analysis/ValueLattice.h"
 #include "llvm/IR/AssemblyAnnotationWriter.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/ConstantRange.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
INITIALIZE_PASS_END(LazyValueInfoWrapperPass, "lazy-value-info",
                 "Lazy Value Information Analysis", false, true)
 
 namespace llvm {
   FunctionPass *createLazyValueInfoPass() { return new LazyValueInfoWrapperPass(); }
 }
 
 AnalysisKey LazyValueAnalysis::Key;
 
-//===----------------------------------------------------------------------===//
-//                               LVILatticeVal
-//===----------------------------------------------------------------------===//
-
-/// This is the information tracked by LazyValueInfo for each value.
-///
-/// FIXME: This is basically just for bringup, this can be made a lot more rich
-/// in the future.
-///
-namespace {
-class LVILatticeVal {
-  enum LatticeValueTy {
-    /// This Value has no known value yet.  As a result, this implies the
-    /// producing instruction is dead.  Caution: We use this as the starting
-    /// state in our local meet rules.  In this usage, it's taken to mean
-    /// "nothing known yet".
-    undefined,
-
-    /// This Value has a specific constant value.  (For constant integers,
-    /// constantrange is used instead.  Integer typed constantexprs can appear
-    /// as constant.) 
-    constant,
-
-    /// This Value is known to not have the specified value.  (For constant
-    /// integers, constantrange is used instead.  As above, integer typed
-    /// constantexprs can appear here.)
-    notconstant,
-
-    /// The Value falls within this range. (Used only for integer typed values.)
-    constantrange,
-
-    /// We can not precisely model the dynamic values this value might take.
-    overdefined
-  };
-
-  /// Val: This stores the current lattice value along with the Constant* for
-  /// the constant if this is a 'constant' or 'notconstant' value.
-  LatticeValueTy Tag;
-  Constant *Val;
-  ConstantRange Range;
-
-public:
-  LVILatticeVal() : Tag(undefined), Val(nullptr), Range(1, true) {}
-
-  static LVILatticeVal get(Constant *C) {
-    LVILatticeVal Res;
-    if (!isa<UndefValue>(C))
-      Res.markConstant(C);
-    return Res;
-  }
-  static LVILatticeVal getNot(Constant *C) {
-    LVILatticeVal Res;
-    if (!isa<UndefValue>(C))
-      Res.markNotConstant(C);
-    return Res;
-  }
-  static LVILatticeVal getRange(ConstantRange CR) {
-    LVILatticeVal Res;
-    Res.markConstantRange(std::move(CR));
-    return Res;
-  }
-  static LVILatticeVal getOverdefined() {
-    LVILatticeVal Res;
-    Res.markOverdefined();
-    return Res;
-  }
-
-  bool isUndefined() const     { return Tag == undefined; }
-  bool isConstant() const      { return Tag == constant; }
-  bool isNotConstant() const   { return Tag == notconstant; }
-  bool isConstantRange() const { return Tag == constantrange; }
-  bool isOverdefined() const   { return Tag == overdefined; }
-
-  Constant *getConstant() const {
-    assert(isConstant() && "Cannot get the constant of a non-constant!");
-    return Val;
-  }
-
-  Constant *getNotConstant() const {
-    assert(isNotConstant() && "Cannot get the constant of a non-notconstant!");
-    return Val;
-  }
-
-  const ConstantRange &getConstantRange() const {
-    assert(isConstantRange() &&
-           "Cannot get the constant-range of a non-constant-range!");
-    return Range;
-  }
-
-  Optional<APInt> asConstantInteger() const {
-    if (isConstant() && isa<ConstantInt>(Val)) {
-      return cast<ConstantInt>(Val)->getValue();
-    } else if (isConstantRange() && Range.isSingleElement()) {
-      return *Range.getSingleElement();
-    }
-    return None;
-  }
-
-private:
-  void markOverdefined() {
-    if (isOverdefined())
-      return;
-    Tag = overdefined;
-  }
-
-  void markConstant(Constant *V) {
-    assert(V && "Marking constant with NULL");
-    if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
-      markConstantRange(ConstantRange(CI->getValue()));
-      return;
-    }
-    if (isa<UndefValue>(V))
-      return;
-
-    assert((!isConstant() || getConstant() == V) &&
-           "Marking constant with different value");
-    assert(isUndefined());
-    Tag = constant;
-    Val = V;
-  }
-
-  void markNotConstant(Constant *V) {
-    assert(V && "Marking constant with NULL");
-    if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
-      markConstantRange(ConstantRange(CI->getValue()+1, CI->getValue()));
-      return;
-    }
-    if (isa<UndefValue>(V))
-      return;
-
-    assert((!isConstant() || getConstant() != V) &&
-           "Marking constant !constant with same value");
-    assert((!isNotConstant() || getNotConstant() == V) &&
-           "Marking !constant with different value");
-    assert(isUndefined() || isConstant());
-    Tag = notconstant;
-    Val = V;
-  }
-
-  void markConstantRange(ConstantRange NewR) {
-    if (isConstantRange()) {
-      if (NewR.isEmptySet())
-        markOverdefined();
-      else {
-        Range = std::move(NewR);
-      }
-      return;
-    }
-
-    assert(isUndefined());
-    if (NewR.isEmptySet())
-      markOverdefined();
-    else {
-      Tag = constantrange;
-      Range = std::move(NewR);
-    }
-  }
-
-public:
-
-  /// Merge the specified lattice value into this one, updating this
-  /// one and returning true if anything changed.
-  void mergeIn(const LVILatticeVal &RHS, const DataLayout &DL) {
-    if (RHS.isUndefined() || isOverdefined())
-      return;
-    if (RHS.isOverdefined()) {
-      markOverdefined();
-      return;
-    }
-
-    if (isUndefined()) {
-      *this = RHS;
-      return;
-    }
-
-    if (isConstant()) {
-      if (RHS.isConstant() && Val == RHS.Val)
-          return;
-      markOverdefined();
-      return;
-    }
-
-    if (isNotConstant()) {
-      if (RHS.isNotConstant() && Val == RHS.Val)
-          return;
-      markOverdefined();
-      return;
-    }
-
-    assert(isConstantRange() && "New LVILattice type?");
-    if (!RHS.isConstantRange()) {
-      // We can get here if we've encountered a constantexpr of integer type
-      // and merge it with a constantrange.
-      markOverdefined();
-      return;
-    }
-    ConstantRange NewR = Range.unionWith(RHS.getConstantRange());
-    if (NewR.isFullSet())
-      markOverdefined();
-    else
-      markConstantRange(std::move(NewR));
-  }
-};
-
-} // end anonymous namespace.
-
-namespace llvm {
-raw_ostream &operator<<(raw_ostream &OS, const LVILatticeVal &Val)
-    LLVM_ATTRIBUTE_USED;
-raw_ostream &operator<<(raw_ostream &OS, const LVILatticeVal &Val) {
-  if (Val.isUndefined())
-    return OS << "undefined";
-  if (Val.isOverdefined())
-    return OS << "overdefined";
-
-  if (Val.isNotConstant())
-    return OS << "notconstant<" << *Val.getNotConstant() << '>';
-  if (Val.isConstantRange())
-    return OS << "constantrange<" << Val.getConstantRange().getLower() << ", "
-              << Val.getConstantRange().getUpper() << '>';
-  return OS << "constant<" << *Val.getConstant() << '>';
-}
-}
-
 /// Returns true if this lattice value represents at most one possible value.
 /// This is as precise as any lattice value can get while still representing
 /// reachable code.
-static bool hasSingleValue(const LVILatticeVal &Val) {
+static bool hasSingleValue(const ValueLatticeVal &Val) {
   if (Val.isConstantRange() &&
       Val.getConstantRange().isSingleElement())
     // Integer constants are single element ranges
     return true;
   if (Val.isConstant())
     // Non integer constants
     return true;
   return false;
 }
 
 /// Combine two sets of facts about the same value into a single set of
 /// facts.  Note that this method is not suitable for merging facts along
 /// different paths in a CFG; that's what the mergeIn function is for.  This
 /// is for merging facts gathered about the same value at the same location
 /// through two independent means.
 /// Notes:
 /// * This method does not promise to return the most precise possible lattice
 ///   value implied by A and B.  It is allowed to return any lattice element
 ///   which is at least as strong as *either* A or B (unless our facts
 ///   conflict, see below).
 /// * Due to unreachable code, the intersection of two lattice values could be
 ///   contradictory.  If this happens, we return some valid lattice value so as
 ///   not confuse the rest of LVI.  Ideally, we'd always return Undefined, but
 ///   we do not make this guarantee.  TODO: This would be a useful enhancement.
-static LVILatticeVal intersect(const LVILatticeVal &A, const LVILatticeVal &B) {
+static ValueLatticeVal intersect(const ValueLatticeVal &A,
+                                 const ValueLatticeVal &B) {
   // Undefined is the strongest state.  It means the value is known to be along
   // an unreachable path.
   if (A.isUndefined())
     return A;
   if (B.isUndefined())
     return B;
 
   // If we gave up for one, but got a useable fact from the other, use it.
static ValueLatticeVal intersect(const ValueLatticeVal &A,
   }
 
   // Intersect two constant ranges
   ConstantRange Range =
     A.getConstantRange().intersectWith(B.getConstantRange());
   // Note: An empty range is implicitly converted to overdefined internally.
   // TODO: We could instead use Undefined here since we've proven a conflict
   // and thus know this path must be unreachable.
-  return LVILatticeVal::getRange(std::move(Range));
+  return ValueLatticeVal::getRange(std::move(Range));
 }
 
 //===----------------------------------------------------------------------===//
 //                          LazyValueInfoCache Decl
 //===----------------------------------------------------------------------===//
 
 namespace {
   /// A callback value handle updates the cache when values are erased.
class LazyValueInfoCache {
     /// This is all of the cached block information for exactly one Value*.
     /// The entries are sorted by the BasicBlock* of the
     /// entries, allowing us to do a lookup with a binary search.
     /// Over-defined lattice values are recorded in OverDefinedCache to reduce
     /// memory overhead.
     struct ValueCacheEntryTy {
       ValueCacheEntryTy(Value *V, LazyValueInfoCache *P) : Handle(V, P) {}
       LVIValueHandle Handle;
-      SmallDenseMap<PoisoningVH<BasicBlock>, LVILatticeVal, 4> BlockVals;
+      SmallDenseMap<PoisoningVH<BasicBlock>, ValueLatticeVal, 4> BlockVals;
     };
 
     /// This tracks, on a per-block basis, the set of values that are
     /// over-defined at the end of that block.
     typedef DenseMap<PoisoningVH<BasicBlock>, SmallPtrSet<Value *, 4>>
         OverDefinedCacheTy;
     /// Keep track of all blocks that we have ever seen, so we
     /// don't spend time removing unused blocks from our caches.
     DenseSet<PoisoningVH<BasicBlock> > SeenBlocks;
 
     /// This is all of the cached information for all values,
     /// mapped from Value* to key information.
     DenseMap<Value *, std::unique_ptr<ValueCacheEntryTy>> ValueCache;
     OverDefinedCacheTy OverDefinedCache;
 
 
   public:
-    void insertResult(Value *Val, BasicBlock *BB, const LVILatticeVal &Result) {
+    void insertResult(Value *Val, BasicBlock *BB,
+                      const ValueLatticeVal &Result) {
       SeenBlocks.insert(BB);
 
       // Insert over-defined values into their own cache to reduce memory
       // overhead.
       if (Result.isOverdefined())
         OverDefinedCache[BB].insert(Val);
       else {
         auto It = ValueCache.find_as(Val);
bool hasCachedValueInfo(Value *V, BasicBlock *BB) const {
 
       auto I = ValueCache.find_as(V);
       if (I == ValueCache.end())
         return false;
 
       return I->second->BlockVals.count(BB);
     }
 
-    LVILatticeVal getCachedValueInfo(Value *V, BasicBlock *BB) const {
+    ValueLatticeVal getCachedValueInfo(Value *V, BasicBlock *BB) const {
       if (isOverdefined(V, BB))
-        return LVILatticeVal::getOverdefined();
+        return ValueLatticeVal::getOverdefined();
 
       auto I = ValueCache.find_as(V);
       if (I == ValueCache.end())
-        return LVILatticeVal();
+        return ValueLatticeVal();
       auto BBI = I->second->BlockVals.find(BB);
       if (BBI == I->second->BlockVals.end())
-        return LVILatticeVal();
+        return ValueLatticeVal();
       return BBI->second;
     }
 
     /// clear - Empty the cache.
     void clear() {
       SeenBlocks.clear();
       ValueCache.clear();
       OverDefinedCache.clear();
bool pushBlockValue(const std::pair<BasicBlock *, Value *> &BV) {
       BlockValueStack.push_back(BV);
       return true;
     }
 
     AssumptionCache *AC;  ///< A pointer to the cache of @llvm.assume calls.
     const DataLayout &DL; ///< A mandatory DataLayout
     DominatorTree *DT;    ///< An optional DT pointer.
 
-  LVILatticeVal getBlockValue(Value *Val, BasicBlock *BB);
+  ValueLatticeVal getBlockValue(Value *Val, BasicBlock *BB);
   bool getEdgeValue(Value *V, BasicBlock *F, BasicBlock *T,
-                    LVILatticeVal &Result, Instruction *CxtI = nullptr);
+                    ValueLatticeVal &Result, Instruction *CxtI = nullptr);
   bool hasBlockValue(Value *Val, BasicBlock *BB);
 
   // These methods process one work item and may add more. A false value
   // returned means that the work item was not completely processed and must
   // be revisited after going through the new items.
   bool solveBlockValue(Value *Val, BasicBlock *BB);
-  bool solveBlockValueImpl(LVILatticeVal &Res, Value *Val, BasicBlock *BB);
-  bool solveBlockValueNonLocal(LVILatticeVal &BBLV, Value *Val, BasicBlock *BB);
-  bool solveBlockValuePHINode(LVILatticeVal &BBLV, PHINode *PN, BasicBlock *BB);
-  bool solveBlockValueSelect(LVILatticeVal &BBLV, SelectInst *S,
+  bool solveBlockValueImpl(ValueLatticeVal &Res, Value *Val, BasicBlock *BB);
+  bool solveBlockValueNonLocal(ValueLatticeVal &BBLV, Value *Val,
+                               BasicBlock *BB);
+  bool solveBlockValuePHINode(ValueLatticeVal &BBLV, PHINode *PN,
+                              BasicBlock *BB);
+  bool solveBlockValueSelect(ValueLatticeVal &BBLV, SelectInst *S,
                              BasicBlock *BB);
-  bool solveBlockValueBinaryOp(LVILatticeVal &BBLV, BinaryOperator *BBI,
+  bool solveBlockValueBinaryOp(ValueLatticeVal &BBLV, BinaryOperator *BBI,
                                BasicBlock *BB);
-  bool solveBlockValueCast(LVILatticeVal &BBLV, CastInst *CI,
+  bool solveBlockValueCast(ValueLatticeVal &BBLV, CastInst *CI,
                            BasicBlock *BB);
   void intersectAssumeOrGuardBlockValueConstantRange(Value *Val,
-                                                     LVILatticeVal &BBLV,
+                                                     ValueLatticeVal &BBLV,
                                                      Instruction *BBI);
 
   void solve();
 
   public:
     /// This is the query interface to determine the lattice
     /// value for the specified Value* at the end of the specified block.
-    LVILatticeVal getValueInBlock(Value *V, BasicBlock *BB,
+    ValueLatticeVal getValueInBlock(Value *V, BasicBlock *BB,
                                     Instruction *CxtI = nullptr);
 
     /// This is the query interface to determine the lattice
     /// value for the specified Value* at the specified instruction (generally
     /// from an assume intrinsic).
-    LVILatticeVal getValueAt(Value *V, Instruction *CxtI);
+    ValueLatticeVal getValueAt(Value *V, Instruction *CxtI);
 
     /// This is the query interface to determine the lattice
     /// value for the specified Value* that is true on the specified edge.
-    LVILatticeVal getValueOnEdge(Value *V, BasicBlock *FromBB,BasicBlock *ToBB,
+    ValueLatticeVal getValueOnEdge(Value *V, BasicBlock *FromBB,
+                                   BasicBlock *ToBB,
                                    Instruction *CxtI = nullptr);
 
     /// Complete flush all previously computed values
     void clear() {
       TheCache.clear();
     }
 
     /// Printing the LazyValueInfo Analysis.
     void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
while (!BlockValueStack.empty()) {
     // PredicateInfo is used in LVI or CVP, we should be able to make the
     // overdefined cache global, and remove this throttle.
     if (processedCount > MaxProcessedPerValue) {
       DEBUG(dbgs() << "Giving up on stack because we are getting too deep\n");
       // Fill in the original values
       while (!StartingStack.empty()) {
         std::pair<BasicBlock *, Value *> &e = StartingStack.back();
         TheCache.insertResult(e.second, e.first,
-                              LVILatticeVal::getOverdefined());
+                              ValueLatticeVal::getOverdefined());
         StartingStack.pop_back();
       }
       BlockValueSet.clear();
       BlockValueStack.clear();
       return;
     }
     std::pair<BasicBlock *, Value *> e = BlockValueStack.back();
     assert(BlockValueSet.count(e) && "Stack value should be in BlockValueSet!");

 bool LazyValueInfoImpl::hasBlockValue(Value *Val, BasicBlock *BB) {
   // If already a constant, there is nothing to compute.
   if (isa<Constant>(Val))
     return true;
 
   return TheCache.hasCachedValueInfo(Val, BB);
 }
 
-LVILatticeVal LazyValueInfoImpl::getBlockValue(Value *Val, BasicBlock *BB) {
+ValueLatticeVal LazyValueInfoImpl::getBlockValue(Value *Val, BasicBlock *BB) {
   // If already a constant, there is nothing to compute.
   if (Constant *VC = dyn_cast<Constant>(Val))
-    return LVILatticeVal::get(VC);
+    return ValueLatticeVal::get(VC);
 
   return TheCache.getCachedValueInfo(Val, BB);
 }
 
-static LVILatticeVal getFromRangeMetadata(Instruction *BBI) {
+static ValueLatticeVal getFromRangeMetadata(Instruction *BBI) {
   switch (BBI->getOpcode()) {
   default: break;
   case Instruction::Load:
   case Instruction::Call:
   case Instruction::Invoke:
     if (MDNode *Ranges = BBI->getMetadata(LLVMContext::MD_range))
       if (isa<IntegerType>(BBI->getType())) {
-        return LVILatticeVal::getRange(getConstantRangeFromMetadata(*Ranges));
+        return ValueLatticeVal::getRange(getConstantRangeFromMetadata(*Ranges));
       }
     break;
   };
   // Nothing known - will be intersected with other facts
-  return LVILatticeVal::getOverdefined();
+  return ValueLatticeVal::getOverdefined();
 }
 
 bool LazyValueInfoImpl::solveBlockValue(Value *Val, BasicBlock *BB) {
   if (isa<Constant>(Val))
     return true;
 
   if (TheCache.hasCachedValueInfo(Val, BB)) {
     // If we have a cached value, use that.
     DEBUG(dbgs() << "  reuse BB '" << BB->getName()
                  << "' val=" << TheCache.getCachedValueInfo(Val, BB) << '\n');
 
     // Since we're reusing a cached value, we don't need to update the
     // OverDefinedCache. The cache will have been properly updated whenever the
     // cached value was inserted.
     return true;
   }
 
   // Hold off inserting this value into the Cache in case we have to return
   // false and come back later.
-  LVILatticeVal Res;
+  ValueLatticeVal Res;
   if (!solveBlockValueImpl(Res, Val, BB))
     // Work pushed, will revisit
     return false;
 
   TheCache.insertResult(Val, BB, Res);
   return true;
 }
 
-bool LazyValueInfoImpl::solveBlockValueImpl(LVILatticeVal &Res,
+bool LazyValueInfoImpl::solveBlockValueImpl(ValueLatticeVal &Res,
                                             Value *Val, BasicBlock *BB) {
 
   Instruction *BBI = dyn_cast<Instruction>(Val);
   if (!BBI || BBI->getParent() != BB)
     return solveBlockValueNonLocal(Res, Val, BB);
 
   if (PHINode *PN = dyn_cast<PHINode>(BBI))
     return solveBlockValuePHINode(Res, PN, BB);
 
   if (auto *SI = dyn_cast<SelectInst>(BBI))
     return solveBlockValueSelect(Res, SI, BB);
 
   // If this value is a nonnull pointer, record it's range and bailout.  Note
   // that for all other pointer typed values, we terminate the search at the
   // definition.  We could easily extend this to look through geps, bitcasts,
   // and the like to prove non-nullness, but it's not clear that's worth it
   // compile time wise.  The context-insensitive value walk done inside
   // isKnownNonZero gets most of the profitable cases at much less expense.
   // This does mean that we have a sensativity to where the defining
   // instruction is placed, even if it could legally be hoisted much higher.
   // That is unfortunate.
   PointerType *PT = dyn_cast<PointerType>(BBI->getType());
   if (PT && isKnownNonZero(BBI, DL)) {
-    Res = LVILatticeVal::getNot(ConstantPointerNull::get(PT));
+    Res = ValueLatticeVal::getNot(ConstantPointerNull::get(PT));
     return true;
   }
   if (BBI->getType()->isIntegerTy()) {
     if (auto *CI = dyn_cast<CastInst>(BBI))
       return solveBlockValueCast(Res, CI, BB);
 
     BinaryOperator *BO = dyn_cast<BinaryOperator>(BBI);
     if (BO && isa<ConstantInt>(BO->getOperand(1)))
static bool isObjectDereferencedInBlock(Value *Val, BasicBlock *BB) {
   // inside InstructionDereferencesPointer either.
   if (UnderlyingVal == GetUnderlyingObject(UnderlyingVal, DL, 1))
     for (Instruction &I : *BB)
       if (InstructionDereferencesPointer(&I, UnderlyingVal))
         return true;
   return false;
 }
 
-bool LazyValueInfoImpl::solveBlockValueNonLocal(LVILatticeVal &BBLV,
+bool LazyValueInfoImpl::solveBlockValueNonLocal(ValueLatticeVal &BBLV,
                                                  Value *Val, BasicBlock *BB) {
-  LVILatticeVal Result;  // Start Undefined.
+  ValueLatticeVal Result;  // Start Undefined.
 
   // If this is the entry block, we must be asking about an argument.  The
   // value is overdefined.
   if (BB == &BB->getParent()->getEntryBlock()) {
     assert(isa<Argument>(Val) && "Unknown live-in to the entry block");
     // Before giving up, see if we can prove the pointer non-null local to
     // this particular block.
     if (Val->getType()->isPointerTy() &&
         (isKnownNonZero(Val, DL) || isObjectDereferencedInBlock(Val, BB))) {
       PointerType *PTy = cast<PointerType>(Val->getType());
-      Result = LVILatticeVal::getNot(ConstantPointerNull::get(PTy));
+      Result = ValueLatticeVal::getNot(ConstantPointerNull::get(PTy));
     } else {
-      Result = LVILatticeVal::getOverdefined();
+      Result = ValueLatticeVal::getOverdefined();
     }
     BBLV = Result;
     return true;
   }
 
   // Loop over all of our predecessors, merging what we know from them into
   // result.  If we encounter an unexplored predecessor, we eagerly explore it
   // in a depth first manner.  In practice, this has the effect of discovering
   // paths we can't analyze eagerly without spending compile times analyzing
   // other paths.  This heuristic benefits from the fact that predecessors are
   // frequently arranged such that dominating ones come first and we quickly
   // find a path to function entry.  TODO: We should consider explicitly
   // canonicalizing to make this true rather than relying on this happy
   // accident.  
   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
-    LVILatticeVal EdgeResult;
+    ValueLatticeVal EdgeResult;
     if (!getEdgeValue(Val, *PI, BB, EdgeResult))
       // Explore that input, then return here
       return false;
 
     Result.mergeIn(EdgeResult, DL);
 
     // If we hit overdefined, exit early.  The BlockVals entry is already set
     // to overdefined.
     if (Result.isOverdefined()) {
       DEBUG(dbgs() << " compute BB '" << BB->getName()
             << "' - overdefined because of pred (non local).\n");
       // Before giving up, see if we can prove the pointer non-null local to
       // this particular block.
       if (Val->getType()->isPointerTy() &&
           isObjectDereferencedInBlock(Val, BB)) {
         PointerType *PTy = cast<PointerType>(Val->getType());
-        Result = LVILatticeVal::getNot(ConstantPointerNull::get(PTy));
+        Result = ValueLatticeVal::getNot(ConstantPointerNull::get(PTy));
       }
 
       BBLV = Result;
       return true;
     }
   }
 
   // Return the merged value, which is more precise than 'overdefined'.
   assert(!Result.isOverdefined());
   BBLV = Result;
   return true;
 }
 
-bool LazyValueInfoImpl::solveBlockValuePHINode(LVILatticeVal &BBLV,
+bool LazyValueInfoImpl::solveBlockValuePHINode(ValueLatticeVal &BBLV,
                                                 PHINode *PN, BasicBlock *BB) {
-  LVILatticeVal Result;  // Start Undefined.
+  ValueLatticeVal Result;  // Start Undefined.
 
   // Loop over all of our predecessors, merging what we know from them into
   // result.  See the comment about the chosen traversal order in
   // solveBlockValueNonLocal; the same reasoning applies here.
   for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
     BasicBlock *PhiBB = PN->getIncomingBlock(i);
     Value *PhiVal = PN->getIncomingValue(i);
-    LVILatticeVal EdgeResult;
+    ValueLatticeVal EdgeResult;
     // Note that we can provide PN as the context value to getEdgeValue, even
     // though the results will be cached, because PN is the value being used as
     // the cache key in the caller.
     if (!getEdgeValue(PhiVal, PhiBB, BB, EdgeResult, PN))
       // Explore that input, then return here
       return false;
 
     Result.mergeIn(EdgeResult, DL);
bool LazyValueInfoImpl::solveBlockValuePHINode(ValueLatticeVal &BBLV,
   }
 
   // Return the merged value, which is more precise than 'overdefined'.
   assert(!Result.isOverdefined() && "Possible PHI in entry block?");
   BBLV = Result;
   return true;
 }
 
-static LVILatticeVal getValueFromCondition(Value *Val, Value *Cond,
+static ValueLatticeVal getValueFromCondition(Value *Val, Value *Cond,
                                            bool isTrueDest = true);
 
 // If we can determine a constraint on the value given conditions assumed by
 // the program, intersect those constraints with BBLV
 void LazyValueInfoImpl::intersectAssumeOrGuardBlockValueConstantRange(
-        Value *Val, LVILatticeVal &BBLV, Instruction *BBI) {
+        Value *Val, ValueLatticeVal &BBLV, Instruction *BBI) {
   BBI = BBI ? BBI : dyn_cast<Instruction>(Val);
   if (!BBI)
     return;
 
   for (auto &AssumeVH : AC->assumptionsFor(Val)) {
     if (!AssumeVH)
       continue;
     auto *I = cast<CallInst>(AssumeVH);
void LazyValueInfoImpl::intersectAssumeOrGuardBlockValueConstantRange(
   for (Instruction &I : make_range(BBI->getIterator().getReverse(),
                                    BBI->getParent()->rend())) {
     Value *Cond = nullptr;
     if (match(&I, m_Intrinsic<Intrinsic::experimental_guard>(m_Value(Cond))))
       BBLV = intersect(BBLV, getValueFromCondition(Val, Cond));
   }
 }
 
-bool LazyValueInfoImpl::solveBlockValueSelect(LVILatticeVal &BBLV,
+bool LazyValueInfoImpl::solveBlockValueSelect(ValueLatticeVal &BBLV,
                                                SelectInst *SI, BasicBlock *BB) {
 
   // Recurse on our inputs if needed
   if (!hasBlockValue(SI->getTrueValue(), BB)) {
     if (pushBlockValue(std::make_pair(BB, SI->getTrueValue())))
       return false;
-    BBLV = LVILatticeVal::getOverdefined();
+    BBLV = ValueLatticeVal::getOverdefined();
     return true;
   }
-  LVILatticeVal TrueVal = getBlockValue(SI->getTrueValue(), BB);
+  ValueLatticeVal TrueVal = getBlockValue(SI->getTrueValue(), BB);
   // If we hit overdefined, don't ask more queries.  We want to avoid poisoning
   // extra slots in the table if we can.
   if (TrueVal.isOverdefined()) {
-    BBLV = LVILatticeVal::getOverdefined();
+    BBLV = ValueLatticeVal::getOverdefined();
     return true;
   }
 
   if (!hasBlockValue(SI->getFalseValue(), BB)) {
     if (pushBlockValue(std::make_pair(BB, SI->getFalseValue())))
       return false;
-    BBLV = LVILatticeVal::getOverdefined();
+    BBLV = ValueLatticeVal::getOverdefined();
     return true;
   }
-  LVILatticeVal FalseVal = getBlockValue(SI->getFalseValue(), BB);
+  ValueLatticeVal FalseVal = getBlockValue(SI->getFalseValue(), BB);
   // If we hit overdefined, don't ask more queries.  We want to avoid poisoning
   // extra slots in the table if we can.
   if (FalseVal.isOverdefined()) {
-    BBLV = LVILatticeVal::getOverdefined();
+    BBLV = ValueLatticeVal::getOverdefined();
     return true;
   }
 
   if (TrueVal.isConstantRange() && FalseVal.isConstantRange()) {
     const ConstantRange &TrueCR = TrueVal.getConstantRange();
     const ConstantRange &FalseCR = FalseVal.getConstantRange();
     Value *LHS = nullptr;
     Value *RHS = nullptr;
if (SelectPatternResult::isMinOrMax(SPR.Flavor) &&
         case SPF_UMIN:                   /// Unsigned minimum
           return TrueCR.umin(FalseCR);
         case SPF_SMAX:                   /// Signed maximum
           return TrueCR.smax(FalseCR);
         case SPF_UMAX:                   /// Unsigned maximum
           return TrueCR.umax(FalseCR);
         };
       }();
-      BBLV = LVILatticeVal::getRange(ResultCR);
+      BBLV = ValueLatticeVal::getRange(ResultCR);
       return true;
     }
 
     // TODO: ABS, NABS from the SelectPatternResult
   }
 
   // Can we constrain the facts about the true and false values by using the
   // condition itself?  This shows up with idioms like e.g. select(a > 5, a, 5).
if (ConstantInt *CIBase = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
       ConstantInt *CIAdded;
       switch (Pred) {
       default: break;
       case ICmpInst::ICMP_EQ:
         if (match(SI->getFalseValue(), m_Add(m_Specific(A),
                                              m_ConstantInt(CIAdded)))) {
           auto ResNot = addConstants(CIBase, CIAdded);
           FalseVal = intersect(FalseVal,
-                               LVILatticeVal::getNot(ResNot));
+                               ValueLatticeVal::getNot(ResNot));
         }
         break;
       case ICmpInst::ICMP_NE:
         if (match(SI->getTrueValue(), m_Add(m_Specific(A),
                                             m_ConstantInt(CIAdded)))) {
           auto ResNot = addConstants(CIBase, CIAdded);
           TrueVal = intersect(TrueVal,
-                              LVILatticeVal::getNot(ResNot));
+                              ValueLatticeVal::getNot(ResNot));
         }
         break;
       };
     }
   }
 
-  LVILatticeVal Result;  // Start Undefined.
+  ValueLatticeVal Result;  // Start Undefined.
   Result.mergeIn(TrueVal, DL);
   Result.mergeIn(FalseVal, DL);
   BBLV = Result;
   return true;
 }
 
-bool LazyValueInfoImpl::solveBlockValueCast(LVILatticeVal &BBLV,
+bool LazyValueInfoImpl::solveBlockValueCast(ValueLatticeVal &BBLV,
                                             CastInst *CI,
                                             BasicBlock *BB) {
   if (!CI->getOperand(0)->getType()->isSized()) {
     // Without knowing how wide the input is, we can't analyze it in any useful
     // way.
-    BBLV = LVILatticeVal::getOverdefined();
+    BBLV = ValueLatticeVal::getOverdefined();
     return true;
   }
 
   // Filter out casts we don't know how to reason about before attempting to
   // recurse on our operand.  This can cut a long search short if we know we're
   // not going to be able to get any useful information anways.
   switch (CI->getOpcode()) {
   case Instruction::Trunc:
   case Instruction::SExt:
   case Instruction::ZExt:
   case Instruction::BitCast:
     break;
   default:
     // Unhandled instructions are overdefined.
     DEBUG(dbgs() << " compute BB '" << BB->getName()
                  << "' - overdefined (unknown cast).\n");
-    BBLV = LVILatticeVal::getOverdefined();
+    BBLV = ValueLatticeVal::getOverdefined();
     return true;
   }
 
   // Figure out the range of the LHS.  If that fails, we still apply the
   // transfer rule on the full set since we may be able to locally infer
   // interesting facts.
   if (!hasBlockValue(CI->getOperand(0), BB))
     if (pushBlockValue(std::make_pair(BB, CI->getOperand(0))))
       // More work to do before applying this transfer rule.
       return false;
 
   const unsigned OperandBitWidth =
     DL.getTypeSizeInBits(CI->getOperand(0)->getType());
   ConstantRange LHSRange = ConstantRange(OperandBitWidth);
   if (hasBlockValue(CI->getOperand(0), BB)) {
-    LVILatticeVal LHSVal = getBlockValue(CI->getOperand(0), BB);
+    ValueLatticeVal LHSVal = getBlockValue(CI->getOperand(0), BB);
     intersectAssumeOrGuardBlockValueConstantRange(CI->getOperand(0), LHSVal,
                                                   CI);
     if (LHSVal.isConstantRange())
       LHSRange = LHSVal.getConstantRange();
   }
 
   const unsigned ResultBitWidth = CI->getType()->getIntegerBitWidth();
 
   // NOTE: We're currently limited by the set of operations that ConstantRange
   // can evaluate symbolically.  Enhancing that set will allows us to analyze
   // more definitions.
-  BBLV = LVILatticeVal::getRange(LHSRange.castOp(CI->getOpcode(),
+  BBLV = ValueLatticeVal::getRange(LHSRange.castOp(CI->getOpcode(),
                                                    ResultBitWidth));
   return true;
 }
 
-bool LazyValueInfoImpl::solveBlockValueBinaryOp(LVILatticeVal &BBLV,
-                                                 BinaryOperator *BO,
-                                                 BasicBlock *BB) {
+bool LazyValueInfoImpl::solveBlockValueBinaryOp(ValueLatticeVal &BBLV,
 
   assert(BO->getOperand(0)->getType()->isSized() &&
          "all operands to binary operators are sized");
 
   // Filter out operators we don't know how to reason about before attempting to
   // recurse on our operand(s).  This can cut a long search short if we know
   // we're not going to be able to get any useful information anyways.
   switch (BO->getOpcode()) {
   case Instruction::Add:
   case Instruction::Sub:
   case Instruction::Mul:
   case Instruction::UDiv:
   case Instruction::Shl:
   case Instruction::LShr:
   case Instruction::And:
   case Instruction::Or:
     // continue into the code below
     break;
   default:
     // Unhandled instructions are overdefined.
     DEBUG(dbgs() << " compute BB '" << BB->getName()
                  << "' - overdefined (unknown binary operator).\n");
-    BBLV = LVILatticeVal::getOverdefined();
+    BBLV = ValueLatticeVal::getOverdefined();
     return true;
   };
 
   // Figure out the range of the LHS.  If that fails, use a conservative range,
   // but apply the transfer rule anyways.  This lets us pick up facts from
   // expressions like "and i32 (call i32 @foo()), 32"
   if (!hasBlockValue(BO->getOperand(0), BB))
     if (pushBlockValue(std::make_pair(BB, BO->getOperand(0))))
       // More work to do before applying this transfer rule.
       return false;
 
   const unsigned OperandBitWidth =
     DL.getTypeSizeInBits(BO->getOperand(0)->getType());
   ConstantRange LHSRange = ConstantRange(OperandBitWidth);
   if (hasBlockValue(BO->getOperand(0), BB)) {
-    LVILatticeVal LHSVal = getBlockValue(BO->getOperand(0), BB);
+    ValueLatticeVal LHSVal = getBlockValue(BO->getOperand(0), BB);
     intersectAssumeOrGuardBlockValueConstantRange(BO->getOperand(0), LHSVal,
                                                   BO);
     if (LHSVal.isConstantRange())
       LHSRange = LHSVal.getConstantRange();
   }
 
   ConstantInt *RHS = cast<ConstantInt>(BO->getOperand(1));
   ConstantRange RHSRange = ConstantRange(RHS->getValue());
 
   // NOTE: We're currently limited by the set of operations that ConstantRange
   // can evaluate symbolically.  Enhancing that set will allows us to analyze
   // more definitions.
   Instruction::BinaryOps BinOp = BO->getOpcode();
-  BBLV = LVILatticeVal::getRange(LHSRange.binaryOp(BinOp, RHSRange));
+  BBLV = ValueLatticeVal::getRange(LHSRange.binaryOp(BinOp, RHSRange));
   return true;
 }
 
-static LVILatticeVal getValueFromICmpCondition(Value *Val, ICmpInst *ICI,
+static ValueLatticeVal getValueFromICmpCondition(Value *Val, ICmpInst *ICI,
                                                bool isTrueDest) {
   Value *LHS = ICI->getOperand(0);
   Value *RHS = ICI->getOperand(1);
   CmpInst::Predicate Predicate = ICI->getPredicate();
 
   if (isa<Constant>(RHS)) {
     if (ICI->isEquality() && LHS == Val) {
       // We know that V has the RHS constant if this is a true SETEQ or
       // false SETNE.
       if (isTrueDest == (Predicate == ICmpInst::ICMP_EQ))
-        return LVILatticeVal::get(cast<Constant>(RHS));
+        return ValueLatticeVal::get(cast<Constant>(RHS));
       else
-        return LVILatticeVal::getNot(cast<Constant>(RHS));
+        return ValueLatticeVal::getNot(cast<Constant>(RHS));
     }
   }
 
   if (!Val->getType()->isIntegerTy())
-    return LVILatticeVal::getOverdefined();
+    return ValueLatticeVal::getOverdefined();
 
   // Use ConstantRange::makeAllowedICmpRegion in order to determine the possible
   // range of Val guaranteed by the condition. Recognize comparisons in the from
   // of:
   //  icmp <pred> Val, ...
   //  icmp <pred> (add Val, Offset), ...
   // The latter is the range checking idiom that InstCombine produces. Subtract
   // the offset from the allowed range for RHS in this case.
if (LHS == Val || Offset) {
     CmpInst::Predicate Pred =
             isTrueDest ? Predicate : CmpInst::getInversePredicate(Predicate);
     ConstantRange TrueValues =
             ConstantRange::makeAllowedICmpRegion(Pred, RHSRange);
 
     if (Offset) // Apply the offset from above.
       TrueValues = TrueValues.subtract(Offset->getValue());
 
-    return LVILatticeVal::getRange(std::move(TrueValues));
+    return ValueLatticeVal::getRange(std::move(TrueValues));
   }
 
-  return LVILatticeVal::getOverdefined();
+  return ValueLatticeVal::getOverdefined();
 }
 
-static LVILatticeVal
+static ValueLatticeVal
 getValueFromCondition(Value *Val, Value *Cond, bool isTrueDest,
-                      DenseMap<Value*, LVILatticeVal> &Visited);
+                      DenseMap<Value*, ValueLatticeVal> &Visited);
 
-static LVILatticeVal
+static ValueLatticeVal
 getValueFromConditionImpl(Value *Val, Value *Cond, bool isTrueDest,
-                          DenseMap<Value*, LVILatticeVal> &Visited) {
+                          DenseMap<Value*, ValueLatticeVal> &Visited) {
   if (ICmpInst *ICI = dyn_cast<ICmpInst>(Cond))
     return getValueFromICmpCondition(Val, ICI, isTrueDest);
 
   // Handle conditions in the form of (cond1 && cond2), we know that on the
   // true dest path both of the conditions hold. Similarly for conditions of
   // the form (cond1 || cond2), we know that on the false dest path neither
   // condition holds.
   BinaryOperator *BO = dyn_cast<BinaryOperator>(Cond);
   if (!BO || (isTrueDest && BO->getOpcode() != BinaryOperator::And) ||
              (!isTrueDest && BO->getOpcode() != BinaryOperator::Or))
-    return LVILatticeVal::getOverdefined();
+    return ValueLatticeVal::getOverdefined();
 
   auto RHS = getValueFromCondition(Val, BO->getOperand(0), isTrueDest, Visited);
   auto LHS = getValueFromCondition(Val, BO->getOperand(1), isTrueDest, Visited);
   return intersect(RHS, LHS);
 }
 
-static LVILatticeVal
+static ValueLatticeVal
 getValueFromCondition(Value *Val, Value *Cond, bool isTrueDest,
-                      DenseMap<Value*, LVILatticeVal> &Visited) {
+                      DenseMap<Value*, ValueLatticeVal> &Visited) {
   auto I = Visited.find(Cond);
   if (I != Visited.end())
     return I->second;
 
   auto Result = getValueFromConditionImpl(Val, Cond, isTrueDest, Visited);
   Visited[Cond] = Result;
   return Result;
 }
 
-LVILatticeVal getValueFromCondition(Value *Val, Value *Cond, bool isTrueDest) {
+ValueLatticeVal getValueFromCondition(Value *Val, Value *Cond,
+                                      bool isTrueDest) {
   assert(Cond && "precondition");
-  DenseMap<Value*, LVILatticeVal> Visited;
+  DenseMap<Value*, ValueLatticeVal> Visited;
   return getValueFromCondition(Val, Cond, isTrueDest, Visited);
 }
 
 // Return true if Usr has Op as an operand, otherwise false.
 static bool usesOperand(User *Usr, Value *Op) {
   return find(Usr->operands(), Op) != Usr->op_end();
 }
 
 // Return true if the instruction type of Val is supported by
 // constantFoldUser(). Currently CastInst and BinaryOperator only.  Call this
 // before calling constantFoldUser() to find out if it's even worth attempting
 // to call it.
 static bool isOperationFoldable(User *Usr) {
   return isa<CastInst>(Usr) || isa<BinaryOperator>(Usr);
 }
 
 // Check if Usr can be simplified to an integer constant when the value of one
 // of its operands Op is an integer constant OpConstVal. If so, return it as an
 // lattice value range with a single element or otherwise return an overdefined
 // lattice value.
-static LVILatticeVal constantFoldUser(User *Usr, Value *Op,
+static ValueLatticeVal constantFoldUser(User *Usr, Value *Op,
                                       const APInt &OpConstVal,
                                       const DataLayout &DL) {
   assert(isOperationFoldable(Usr) && "Precondition");
   Constant* OpConst = Constant::getIntegerValue(Op->getType(), OpConstVal);
   // Check if Usr can be simplified to a constant.
   if (auto *CI = dyn_cast<CastInst>(Usr)) {
     assert(CI->getOperand(0) == Op && "Operand 0 isn't Op");
     if (auto *C = dyn_cast_or_null<ConstantInt>(
             SimplifyCastInst(CI->getOpcode(), OpConst,
                              CI->getDestTy(), DL))) {
-      return LVILatticeVal::getRange(ConstantRange(C->getValue()));
+      return ValueLatticeVal::getRange(ConstantRange(C->getValue()));
     }
   } else if (auto *BO = dyn_cast<BinaryOperator>(Usr)) {
     bool Op0Match = BO->getOperand(0) == Op;
     bool Op1Match = BO->getOperand(1) == Op;
     assert((Op0Match || Op1Match) &&
            "Operand 0 nor Operand 1 isn't a match");
     Value *LHS = Op0Match ? OpConst : BO->getOperand(0);
     Value *RHS = Op1Match ? OpConst : BO->getOperand(1);
     if (auto *C = dyn_cast_or_null<ConstantInt>(
             SimplifyBinOp(BO->getOpcode(), LHS, RHS, DL))) {
-      return LVILatticeVal::getRange(ConstantRange(C->getValue()));
+      return ValueLatticeVal::getRange(ConstantRange(C->getValue()));
     }
   }
-  return LVILatticeVal::getOverdefined();
+  return ValueLatticeVal::getOverdefined();
 }
 
 /// \brief Compute the value of Val on the edge BBFrom -> BBTo. Returns false if
 /// Val is not constrained on the edge.  Result is unspecified if return value
 /// is false.
 static bool getEdgeValueLocal(Value *Val, BasicBlock *BBFrom,
-                              BasicBlock *BBTo, LVILatticeVal &Result) {
+                              BasicBlock *BBTo, ValueLatticeVal &Result) {
   // TODO: Handle more complex conditionals. If (v == 0 || v2 < 1) is false, we
   // know that v != 0.
   if (BranchInst *BI = dyn_cast<BranchInst>(BBFrom->getTerminator())) {
     // If this is a conditional branch and only one successor goes to BBTo, then
     // we may be able to infer something from the condition.
     if (BI->isConditional() &&
         BI->getSuccessor(0) != BI->getSuccessor(1)) {
       bool isTrueDest = BI->getSuccessor(0) == BBTo;
       assert(BI->getSuccessor(!isTrueDest) == BBTo &&
              "BBTo isn't a successor of BBFrom");
       Value *Condition = BI->getCondition();
 
       // If V is the condition of the branch itself, then we know exactly what
       // it is.
       if (Condition == Val) {
-        Result = LVILatticeVal::get(ConstantInt::get(
+        Result = ValueLatticeVal::get(ConstantInt::get(
                               Type::getInt1Ty(Val->getContext()), isTrueDest));
         return true;
       }
 
       // If the condition of the branch is an equality comparison, we may be
       // able to infer the value.
       Result = getValueFromCondition(Val, Condition, isTrueDest);
       if (!Result.isOverdefined())
if (BI->isConditional() &&
             // infer the value of Val.
             // eg.
             //    ; %Val is 94 on the edge to %then.
             //    %Val = add i8 %Op, 1
             //    %Condition = icmp eq i8 %Op, 93
             //    br i1 %Condition, label %then, label %else
             for (unsigned i = 0; i < Usr->getNumOperands(); ++i) {
               Value *Op = Usr->getOperand(i);
-              LVILatticeVal OpLatticeVal =
+              ValueLatticeVal OpLatticeVal =
                   getValueFromCondition(Op, Condition, isTrueDest);
               if (Optional<APInt> OpConst = OpLatticeVal.asConstantInteger()) {
                 Result = constantFoldUser(Usr, Op, OpConst.getValue(), DL);
                 break;
               }
             }
           }
         }
if (SwitchInst *SI = dyn_cast<SwitchInst>(BBFrom->getTerminator())) {
     ConstantRange EdgesVals(BitWidth, DefaultCase/*isFullSet*/);
 
     for (auto Case : SI->cases()) {
       APInt CaseValue = Case.getCaseValue()->getValue();
       ConstantRange EdgeVal(CaseValue);
       if (ValUsesConditionAndMayBeFoldable) {
         User *Usr = cast<User>(Val);
         const DataLayout &DL = BBTo->getModule()->getDataLayout();
-        LVILatticeVal EdgeLatticeVal =
+        ValueLatticeVal EdgeLatticeVal =
             constantFoldUser(Usr, Condition, CaseValue, DL);
         if (EdgeLatticeVal.isOverdefined())
           return false;
         EdgeVal = EdgeLatticeVal.getConstantRange();
       }
       if (DefaultCase) {
         // It is possible that the default destination is the destination of
         // some cases. We cannot perform difference for those cases.
         // We know Condition != CaseValue in BBTo.  In some cases we can use
         // this to infer Val == f(Condition) is != f(CaseValue).  For now, we
         // only do this when f is identity (i.e. Val == Condition), but we
         // should be able to do this for any injective f.
         if (Case.getCaseSuccessor() != BBTo && Condition == Val)
           EdgesVals = EdgesVals.difference(EdgeVal);
       } else if (Case.getCaseSuccessor() == BBTo)
         EdgesVals = EdgesVals.unionWith(EdgeVal);
     }
-    Result = LVILatticeVal::getRange(std::move(EdgesVals));
+    Result = ValueLatticeVal::getRange(std::move(EdgesVals));
     return true;
   }
   return false;
 }
 
 /// \brief Compute the value of Val on the edge BBFrom -> BBTo or the value at
 /// the basic block if the edge does not constrain Val.
 bool LazyValueInfoImpl::getEdgeValue(Value *Val, BasicBlock *BBFrom,
-                                     BasicBlock *BBTo, LVILatticeVal &Result,
+                                     BasicBlock *BBTo, ValueLatticeVal &Result,
                                      Instruction *CxtI) {
   // If already a constant, there is nothing to compute.
   if (Constant *VC = dyn_cast<Constant>(Val)) {
-    Result = LVILatticeVal::get(VC);
+    Result = ValueLatticeVal::get(VC);
     return true;
   }
 
-  LVILatticeVal LocalResult;
+  ValueLatticeVal LocalResult;
   if (!getEdgeValueLocal(Val, BBFrom, BBTo, LocalResult))
     // If we couldn't constrain the value on the edge, LocalResult doesn't
     // provide any information.
-    LocalResult = LVILatticeVal::getOverdefined();
+    LocalResult = ValueLatticeVal::getOverdefined();
 
   if (hasSingleValue(LocalResult)) {
     // Can't get any more precise here
     Result = LocalResult;
     return true;
   }
 
   if (!hasBlockValue(Val, BBFrom)) {
     if (pushBlockValue(std::make_pair(BBFrom, Val)))
       return false;
     // No new information.
     Result = LocalResult;
     return true;
   }
 
   // Try to intersect ranges of the BB and the constraint on the edge.
-  LVILatticeVal InBlock = getBlockValue(Val, BBFrom);
+  ValueLatticeVal InBlock = getBlockValue(Val, BBFrom);
   intersectAssumeOrGuardBlockValueConstantRange(Val, InBlock,
                                                 BBFrom->getTerminator());
   // We can use the context instruction (generically the ultimate instruction
   // the calling pass is trying to simplify) here, even though the result of
   // this function is generally cached when called from the solve* functions
   // (and that cached result might be used with queries using a different
   // context instruction), because when this function is called from the solve*
   // functions, the context instruction is not provided. When called from
   // LazyValueInfoImpl::getValueOnEdge, the context instruction is provided,
   // but then the result is not cached.
   intersectAssumeOrGuardBlockValueConstantRange(Val, InBlock, CxtI);
 
   Result = intersect(LocalResult, InBlock);
   return true;
 }
 
-LVILatticeVal LazyValueInfoImpl::getValueInBlock(Value *V, BasicBlock *BB,
+ValueLatticeVal LazyValueInfoImpl::getValueInBlock(Value *V, BasicBlock *BB,
                                                   Instruction *CxtI) {
   DEBUG(dbgs() << "LVI Getting block end value " << *V << " at '"
         << BB->getName() << "'\n");
 
   assert(BlockValueStack.empty() && BlockValueSet.empty());
   if (!hasBlockValue(V, BB)) {
     pushBlockValue(std::make_pair(BB, V));
     solve();
   }
-  LVILatticeVal Result = getBlockValue(V, BB);
+  ValueLatticeVal Result = getBlockValue(V, BB);
   intersectAssumeOrGuardBlockValueConstantRange(V, Result, CxtI);
 
   DEBUG(dbgs() << "  Result = " << Result << "\n");
   return Result;
 }
 
-LVILatticeVal LazyValueInfoImpl::getValueAt(Value *V, Instruction *CxtI) {
+ValueLatticeVal LazyValueInfoImpl::getValueAt(Value *V, Instruction *CxtI) {
   DEBUG(dbgs() << "LVI Getting value " << *V << " at '"
         << CxtI->getName() << "'\n");
 
   if (auto *C = dyn_cast<Constant>(V))
-    return LVILatticeVal::get(C);
+    return ValueLatticeVal::get(C);
 
-  LVILatticeVal Result = LVILatticeVal::getOverdefined();
+  ValueLatticeVal Result = ValueLatticeVal::getOverdefined();
   if (auto *I = dyn_cast<Instruction>(V))
     Result = getFromRangeMetadata(I);
   intersectAssumeOrGuardBlockValueConstantRange(V, Result, CxtI);
 
   DEBUG(dbgs() << "  Result = " << Result << "\n");
   return Result;
 }
 
-LVILatticeVal LazyValueInfoImpl::
+ValueLatticeVal LazyValueInfoImpl::
 getValueOnEdge(Value *V, BasicBlock *FromBB, BasicBlock *ToBB,
                Instruction *CxtI) {
   DEBUG(dbgs() << "LVI Getting edge value " << *V << " from '"
         << FromBB->getName() << "' to '" << ToBB->getName() << "'\n");
 
-  LVILatticeVal Result;
+  ValueLatticeVal Result;
   if (!getEdgeValue(V, FromBB, ToBB, Result, CxtI)) {
     solve();
     bool WasFastQuery = getEdgeValue(V, FromBB, ToBB, Result, CxtI);
     (void)WasFastQuery;
     assert(WasFastQuery && "More work to do after problem solved?");
   }
 
   DEBUG(dbgs() << "  Result = " << Result << "\n");
if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
       (DT && Inv.invalidate<DominatorTreeAnalysis>(F, PA)))
     return true;
 
   return false;
 }
 
 void LazyValueInfoWrapperPass::releaseMemory() { Info.releaseMemory(); }
 
-LazyValueInfo LazyValueAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
+LazyValueInfo LazyValueAnalysis::run(Function &F,
+                                     FunctionAnalysisManager &FAM) {
   auto &AC = FAM.getResult<AssumptionAnalysis>(F);
   auto &TLI = FAM.getResult<TargetLibraryAnalysis>(F);
   auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F);
 
   return LazyValueInfo(&AC, &F.getParent()->getDataLayout(), &TLI, DT);
 }
 
 /// Returns true if we can statically tell that this value will never be a

 
 Constant *LazyValueInfo::getConstant(Value *V, BasicBlock *BB,
                                      Instruction *CxtI) {
   // Bail out early if V is known not to be a Constant.
   if (isKnownNonConstant(V))
     return nullptr;
 
   const DataLayout &DL = BB->getModule()->getDataLayout();
-  LVILatticeVal Result =
+  ValueLatticeVal Result =
       getImpl(PImpl, AC, &DL, DT).getValueInBlock(V, BB, CxtI);
 
   if (Result.isConstant())
     return Result.getConstant();
   if (Result.isConstantRange()) {
     const ConstantRange &CR = Result.getConstantRange();
     if (const APInt *SingleVal = CR.getSingleElement())
       return ConstantInt::get(V->getContext(), *SingleVal);
   }
   return nullptr;
 }
 
 ConstantRange LazyValueInfo::getConstantRange(Value *V, BasicBlock *BB,
                                               Instruction *CxtI) {
   assert(V->getType()->isIntegerTy());
   unsigned Width = V->getType()->getIntegerBitWidth();
   const DataLayout &DL = BB->getModule()->getDataLayout();
-  LVILatticeVal Result =
+  ValueLatticeVal Result =
       getImpl(PImpl, AC, &DL, DT).getValueInBlock(V, BB, CxtI);
   if (Result.isUndefined())
     return ConstantRange(Width, /*isFullSet=*/false);
   if (Result.isConstantRange())
     return Result.getConstantRange();
   // We represent ConstantInt constants as constant ranges but other kinds
   // of integer constants, i.e. ConstantExpr will be tagged as constants
   assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&
          "ConstantInt value must be represented as constantrange");
   return ConstantRange(Width, /*isFullSet=*/true);
 }
 
 /// Determine whether the specified value is known to be a
 /// constant on the specified edge. Return null if not.
 Constant *LazyValueInfo::getConstantOnEdge(Value *V, BasicBlock *FromBB,
                                            BasicBlock *ToBB,
                                            Instruction *CxtI) {
   const DataLayout &DL = FromBB->getModule()->getDataLayout();
-  LVILatticeVal Result =
+  ValueLatticeVal Result =
       getImpl(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
 
   if (Result.isConstant())
     return Result.getConstant();
   if (Result.isConstantRange()) {
     const ConstantRange &CR = Result.getConstantRange();
     if (const APInt *SingleVal = CR.getSingleElement())
       return ConstantInt::get(V->getContext(), *SingleVal);
   }
   return nullptr;
 }
 
 ConstantRange LazyValueInfo::getConstantRangeOnEdge(Value *V,
                                                     BasicBlock *FromBB,
                                                     BasicBlock *ToBB,
                                                     Instruction *CxtI) {
   unsigned Width = V->getType()->getIntegerBitWidth();
   const DataLayout &DL = FromBB->getModule()->getDataLayout();
-  LVILatticeVal Result =
+  ValueLatticeVal Result =
       getImpl(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
 
   if (Result.isUndefined())
     return ConstantRange(Width, /*isFullSet=*/false);
   if (Result.isConstantRange())
     return Result.getConstantRange();
   // We represent ConstantInt constants as constant ranges but other kinds
   // of integer constants, i.e. ConstantExpr will be tagged as constants
   assert(!(Result.isConstant() && isa<ConstantInt>(Result.getConstant())) &&
          "ConstantInt value must be represented as constantrange");
   return ConstantRange(Width, /*isFullSet=*/true);
 }
 
 static LazyValueInfo::Tristate getPredicateResult(unsigned Pred, Constant *C,
-                                                  const LVILatticeVal &Val,
+                                                  const ValueLatticeVal &Val,
                                                   const DataLayout &DL,
                                                   TargetLibraryInfo *TLI) {
 
   // If we know the value is a constant, evaluate the conditional.
   Constant *Res = nullptr;
   if (Val.isConstant()) {
     Res = ConstantFoldCompareInstOperands(Pred, Val.getConstant(), C, DL, TLI);
     if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))

 
 /// Determine whether the specified value comparison with a constant is known to
 /// be true or false on the specified CFG edge. Pred is a CmpInst predicate.
 LazyValueInfo::Tristate
 LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
                                   BasicBlock *FromBB, BasicBlock *ToBB,
                                   Instruction *CxtI) {
   const DataLayout &DL = FromBB->getModule()->getDataLayout();
-  LVILatticeVal Result =
+  ValueLatticeVal Result =
       getImpl(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
 
   return getPredicateResult(Pred, C, Result, DL, TLI);
 }
 
 LazyValueInfo::Tristate
 LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C,
                               Instruction *CxtI) {
   // Is or is not NonNull are common predicates being queried. If
   // isKnownNonZero can tell us the result of the predicate, we can
   // return it quickly. But this is only a fastpath, and falling
   // through would still be correct.
   const DataLayout &DL = CxtI->getModule()->getDataLayout();
   if (V->getType()->isPointerTy() && C->isNullValue() &&
       isKnownNonZero(V->stripPointerCasts(), DL)) {
     if (Pred == ICmpInst::ICMP_EQ)
       return LazyValueInfo::False;
     else if (Pred == ICmpInst::ICMP_NE)
       return LazyValueInfo::True;
   }
-  LVILatticeVal Result = getImpl(PImpl, AC, &DL, DT).getValueAt(V, CxtI);
+  ValueLatticeVal Result = getImpl(PImpl, AC, &DL, DT).getValueAt(V, CxtI);
   Tristate Ret = getPredicateResult(Pred, C, Result, DL, TLI);
   if (Ret != Unknown)
     return Ret;
 
   // Note: The following bit of code is somewhat distinct from the rest of LVI;
   // LVI as a whole tries to compute a lattice value which is conservatively
   // correct at a given location.  In this case, we have a predicate which we
   // weren't able to prove about the merged result, and we're pushing that

 }
 
 // Print the LVI for the function arguments at the start of each basic block.
 void LazyValueInfoAnnotatedWriter::emitBasicBlockStartAnnot(
     const BasicBlock *BB, formatted_raw_ostream &OS) {
   // Find if there are latticevalues defined for arguments of the function.
   auto *F = BB->getParent();
   for (auto &Arg : F->args()) {
-    LVILatticeVal Result = LVIImpl->getValueInBlock(
+    ValueLatticeVal Result = LVIImpl->getValueInBlock(
         const_cast<Argument *>(&Arg), const_cast<BasicBlock *>(BB));
     if (Result.isUndefined())
       continue;
     OS << "; LatticeVal for: '" << Arg << "' is: " << Result << "\n";
   }
 }
 
 // This function prints the LVI analysis for the instruction I at the beginning
 // of various basic blocks. It relies on calculated values that are stored in
 // the LazyValueInfoCache, and in the absence of cached values, recalculte the
 // LazyValueInfo for `I`, and print that info.
 void LazyValueInfoAnnotatedWriter::emitInstructionAnnot(
     const Instruction *I, formatted_raw_ostream &OS) {
 
   auto *ParentBB = I->getParent();
   SmallPtrSet<const BasicBlock*, 16> BlocksContainingLVI;
   // We can generate (solve) LVI values only for blocks that are dominated by
   // the I's parent. However, to avoid generating LVI for all dominating blocks,
   // that contain redundant/uninteresting information, we print LVI for
   // blocks that may use this LVI information (such as immediate successor
   // blocks, and blocks that contain uses of `I`).
   auto printResult = [&](const BasicBlock *BB) {
     if (!BlocksContainingLVI.insert(BB).second)
       return;
-    LVILatticeVal Result = LVIImpl->getValueInBlock(
+    ValueLatticeVal Result = LVIImpl->getValueInBlock(
         const_cast<Instruction *>(I), const_cast<BasicBlock *>(BB));
       OS << "; LatticeVal for: '" << *I << "' in BB: '";
       BB->printAsOperand(OS, false);
       OS << "' is: " << Result << "\n";
   };
 
   printResult(ParentBB);
   // Print the LVI analysis results for the the immediate successor blocks, that

lib/Analysis/ValueLattice.cpp

+//===- ValueLattice.cpp - Value constraint analysis -------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/ValueLattice.h"
+
+namespace llvm {
+raw_ostream &operator<<(raw_ostream &OS, const ValueLatticeVal &Val) {
+  if (Val.isUndefined())
+    return OS << "undefined";
+  if (Val.isOverdefined())
+    return OS << "overdefined";
+
+  if (Val.isNotConstant())
+    return OS << "notconstant<" << *Val.getNotConstant() << ">";
+  if (Val.isConstantRange())
+    return OS << "constantrange<" << Val.getConstantRange().getLower() << ", "
+              << Val.getConstantRange().getUpper() << ">";
+  return OS << "constant<" << *Val.getConstant() << ">";
+}
+}  // end namespace llvm

unittests/Analysis/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Analysis
   AsmParser
   Core
   Support
   )
 
 add_llvm_unittest(AnalysisTests
   AliasAnalysisTest.cpp
   AliasSetTrackerTest.cpp
   BlockFrequencyInfoTest.cpp
   BranchProbabilityInfoTest.cpp
   CallGraphTest.cpp
   CFGTest.cpp
   CGSCCPassManagerTest.cpp
   GlobalsModRefTest.cpp
+  ValueLatticeTest.cpp
   LazyCallGraphTest.cpp
   LoopInfoTest.cpp
   MemoryBuiltinsTest.cpp
   MemorySSA.cpp
   OrderedBasicBlockTest.cpp
   ProfileSummaryInfoTest.cpp
   ScalarEvolutionTest.cpp
   TargetLibraryInfoTest.cpp
   TBAATest.cpp
   UnrollAnalyzer.cpp
   ValueTrackingTest.cpp
   )

unittests/Analysis/ValueLatticeTest.cpp

+//===- ValueLatticeTest.cpp - ScalarEvolution unit tests --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/ValueLattice.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/ConstantRange.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "gtest/gtest.h"
+
+namespace llvm {
+namespace {
+
+// We use this fixture to ensure that we clean up ScalarEvolution before
+// deleting the PassManager.
+class ValueLatticeTest : public testing::Test {
+protected:
+  LLVMContext Context;
+  Module M;
+
+  ValueLatticeTest() : M("", Context) {}
+};
+
+TEST_F(ValueLatticeTest, ValueLatticeGetters) {
+  auto I32Ty = IntegerType::get(Context, 32);
+  auto *C1 = ConstantInt::get(I32Ty, 1);
+
+  EXPECT_TRUE(ValueLatticeVal::get(C1).isConstantRange());
+  EXPECT_TRUE(ValueLatticeVal::getRange({C1->getValue()}).isConstantRange());
+  EXPECT_TRUE(ValueLatticeVal::getOverdefined().isOverdefined());
+
+  auto FloatTy = Type::getFloatTy(Context);
+  auto *C2 = ConstantFP::get(FloatTy, 1.1);
+  EXPECT_TRUE(ValueLatticeVal::get(C2).isConstant());
+  EXPECT_TRUE(ValueLatticeVal::getNot(C2).isNotConstant());
+}
+
+TEST_F(ValueLatticeTest, MergeIn) {
+  auto I32Ty = IntegerType::get(Context, 32);
+  auto *C1 = ConstantInt::get(I32Ty, 1);
+
+  // Merge to lattice values with equal integer constant.
+  auto LV1 = ValueLatticeVal::get(C1);
+  LV1.mergeIn(ValueLatticeVal::get(C1), M.getDataLayout());
+  EXPECT_TRUE(LV1.isConstantRange());
+  EXPECT_EQ(LV1.asConstantInteger().getValue().getLimitedValue(), 1U);
+
+  // Merge LV1 with different integer constant.
+  LV1.mergeIn(ValueLatticeVal::get(ConstantInt::get(I32Ty, 99)),
+              M.getDataLayout());
+  EXPECT_TRUE(LV1.isConstantRange());
+  EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
+  EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
+
+  // Merge LV1 in undefined value.
+  ValueLatticeVal LV2;
+  LV2.mergeIn(LV1, M.getDataLayout());
+  EXPECT_TRUE(LV1.isConstantRange());
+  EXPECT_EQ(LV1.getConstantRange().getLower().getLimitedValue(), 1U);
+  EXPECT_EQ(LV1.getConstantRange().getUpper().getLimitedValue(), 100U);
+  EXPECT_TRUE(LV2.isConstantRange());
+  EXPECT_EQ(LV2.getConstantRange().getLower().getLimitedValue(), 1U);
+  EXPECT_EQ(LV2.getConstantRange().getUpper().getLimitedValue(), 100U);
+
+  // Merge with overdefined.
+  LV1.mergeIn(ValueLatticeVal::getOverdefined(), M.getDataLayout());
+  EXPECT_TRUE(LV1.isOverdefined());
+}
+
+TEST_F(ValueLatticeTest, satisfiesPredicateIntegers) {
+  auto I32Ty = IntegerType::get(Context, 32);
+  auto *C1 = ConstantInt::get(I32Ty, 1);
+  auto LV1 = ValueLatticeVal::get(C1);
+
+  // Check satisfiesPredicate for equal integer constants.
+  EXPECT_TRUE(LV1.satisfiesPredicate(CmpInst::ICMP_EQ, LV1));
+  EXPECT_TRUE(LV1.satisfiesPredicate(CmpInst::ICMP_SGE, LV1));
+  EXPECT_TRUE(LV1.satisfiesPredicate(CmpInst::ICMP_SLE, LV1));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::ICMP_NE, LV1));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::ICMP_SLT, LV1));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::ICMP_SGT, LV1));
+
+  auto LV2 =
+      ValueLatticeVal::getRange({APInt(32, 10, true), APInt(32, 20, true)});
+  // Check satisfiesPredicate with distinct integer ranges.
+  EXPECT_TRUE(LV1.satisfiesPredicate(CmpInst::ICMP_SLT, LV2));
+  EXPECT_TRUE(LV1.satisfiesPredicate(CmpInst::ICMP_SLE, LV2));
+  EXPECT_TRUE(LV1.satisfiesPredicate(CmpInst::ICMP_NE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::ICMP_EQ, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::ICMP_SGE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::ICMP_SGT, LV2));
+
+  auto LV3 =
+      ValueLatticeVal::getRange({APInt(32, 15, true), APInt(32, 19, true)});
+  // Check satisfiesPredicate with a subset integer ranges.
+  EXPECT_FALSE(LV2.satisfiesPredicate(CmpInst::ICMP_SLT, LV3));
+  EXPECT_FALSE(LV2.satisfiesPredicate(CmpInst::ICMP_SLE, LV3));
+  EXPECT_FALSE(LV2.satisfiesPredicate(CmpInst::ICMP_NE, LV3));
+  EXPECT_FALSE(LV2.satisfiesPredicate(CmpInst::ICMP_EQ, LV3));
+  EXPECT_FALSE(LV2.satisfiesPredicate(CmpInst::ICMP_SGE, LV3));
+  EXPECT_FALSE(LV2.satisfiesPredicate(CmpInst::ICMP_SGT, LV3));
+
+  auto LV4 =
+      ValueLatticeVal::getRange({APInt(32, 15, true), APInt(32, 25, true)});
+  // Check satisfiesPredicate with overlapping integer ranges.
+  EXPECT_FALSE(LV3.satisfiesPredicate(CmpInst::ICMP_SLT, LV4));
+  EXPECT_FALSE(LV3.satisfiesPredicate(CmpInst::ICMP_SLE, LV4));
+  EXPECT_FALSE(LV3.satisfiesPredicate(CmpInst::ICMP_NE, LV4));
+  EXPECT_FALSE(LV3.satisfiesPredicate(CmpInst::ICMP_EQ, LV4));
+  EXPECT_FALSE(LV3.satisfiesPredicate(CmpInst::ICMP_SGE, LV4));
+  EXPECT_FALSE(LV3.satisfiesPredicate(CmpInst::ICMP_SGT, LV4));
+}
+
+TEST_F(ValueLatticeTest, satisfiesPredicateFloat) {
+  auto FloatTy = IntegerType::getFloatTy(Context);
+  auto *C1 = ConstantFP::get(FloatTy, 1.0);
+  auto LV1 = ValueLatticeVal::get(C1);
+  auto LV2 = ValueLatticeVal::get(C1);
+
+  // Check satisfiesPredicate for equal floating point constants.
+  EXPECT_TRUE(LV1.satisfiesPredicate(CmpInst::FCMP_OEQ, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OGE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OLE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_ONE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OLT, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OGT, LV2));
+
+  LV1.mergeIn(ValueLatticeVal::get(ConstantFP::get(FloatTy, 2.2)),
+              M.getDataLayout());
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OEQ, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OGE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OLE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_ONE, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OLT, LV2));
+  EXPECT_FALSE(LV1.satisfiesPredicate(CmpInst::FCMP_OGT, LV2));
+}
+
+} // end anonymous namespace
+} // end namespace llvm