Implement assumption bounds.

Author: yukatan1701

include/tsar/Analysis/Memory/DefinedMemory.h

@@ -472,6 +472,14 @@ class ReachDFFwk : private bcl::Uncopyable {
   /// This covers IN and OUT value for a must/may reach definition analysis.
   typedef DFValue<ReachDFFwk, DefinitionInfo> ReachSet;
 
+  typedef llvm::Optional<int64_t> AssumptionBound;
+  struct AssumptionBounds {
+    AssumptionBound Lower = llvm::None;
+    AssumptionBound Upper = llvm::None;
+  };
+
+  typedef llvm::DenseMap<llvm::Value *, AssumptionBounds> AssumptionMap;
+
   /// This represents results of reach definition analysis results.
   typedef llvm::DenseMap<DFNode *,
     std::tuple<std::unique_ptr<DefUseSet>, std::unique_ptr<ReachSet>>,
@@ -495,8 +503,9 @@ class ReachDFFwk : private bcl::Uncopyable {
       const llvm::DataLayout &DL, llvm::AssumptionCache &AC,
       const GlobalOptions &GO, DefinedMemoryInfo &DefInfo) :
     mAliasTree(&AT), mTLI(&TLI), mRegionInfo(&DFI),
-    mDT(&DT), mDI(&DI), mSE(&SE), mDL(&DL), mAC(&AC), mGO(&GO),
-    mDefInfo(&DefInfo) {}
+    mDT(&DT), mDI(&DI), mSE(&SE), mDL(&DL), mGO(&GO), mDefInfo(&DefInfo) {
+      initializeAssumptions(AC);
+    }
 
   /// Creates data-flow framework.
   ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
@@ -506,8 +515,10 @@ class ReachDFFwk : private bcl::Uncopyable {
       const GlobalOptions &GO, DefinedMemoryInfo &DefInfo,
       InterprocDefUseInfo &InterprocDUInfo) :
     mAliasTree(&AT), mTLI(&TLI), mRegionInfo(&DFI), mDT(&DT),
-    mDI(&DI), mSE(&SE), mDL(&DL), mAC(&AC), mGO(&GO), mDefInfo(&DefInfo),
-    mInterprocDUInfo(&InterprocDUInfo) {}
+    mDI(&DI), mSE(&SE), mDL(&DL), mGO(&GO), mDefInfo(&DefInfo),
+    mInterprocDUInfo(&InterprocDUInfo) {
+      initializeAssumptions(AC);
+    }
 
   /// Creates data-flow framework.
   ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
@@ -516,8 +527,9 @@ class ReachDFFwk : private bcl::Uncopyable {
       llvm::AssumptionCache &AC, const GlobalOptions &GO,
       DefinedMemoryInfo &DefInfo, InterprocDefUseInfo &InterprocDUInfo) :
     mAliasTree(&AT), mTLI(&TLI), mDT(&DT), mDI(&DI), mSE(&SE), mDL(&DL),
-    mAC(&AC), mGO(&GO), mDefInfo(&DefInfo),
-    mInterprocDUInfo(&InterprocDUInfo) {}
+    mGO(&GO), mDefInfo(&DefInfo), mInterprocDUInfo(&InterprocDUInfo) {
+      initializeAssumptions(AC);
+    }
 
   /// Return results of interprocedural analysis or nullptr.
   InterprocDefUseInfo * getInterprocDefUseInfo() noexcept {
@@ -557,8 +569,8 @@ class ReachDFFwk : private bcl::Uncopyable {
   const llvm::DataLayout & getDataLayout() const noexcept { return *mDL; }
 
   /// Returns assumption cache.
-  llvm::AssumptionCache & getAssumptionCache() const noexcept {
-    return *mAC;
+  const AssumptionMap & getAssumptionMap() const noexcept {
+    return mAM;
   }
 
   /// Returns global options.
@@ -568,6 +580,8 @@ class ReachDFFwk : private bcl::Uncopyable {
   /// in a data-flow graph of an outer region.
   void collapse(DFRegion *R);
 private:
+  void initializeAssumptions(llvm::AssumptionCache &AC);
+
   AliasTree *mAliasTree;
   llvm::TargetLibraryInfo *mTLI;
   const llvm::DominatorTree *mDT;
@@ -577,7 +591,7 @@ class ReachDFFwk : private bcl::Uncopyable {
   const DelinearizeInfo *mDI;
   llvm::ScalarEvolution *mSE;
   const llvm::DataLayout *mDL;
-  llvm::AssumptionCache *mAC;
+  AssumptionMap mAM;
   const GlobalOptions *mGO;
 };
 

lib/Analysis/Memory/DefinedMemory.cpp

@@ -796,6 +796,82 @@ void initializeTransferEndLog(const DefinitionInfo &Out, bool HasChanges,
 #endif
 }
 
+void ReachDFFwk::initializeAssumptions(AssumptionCache &AC) {
+  auto IsRelational = [](CmpInst::Predicate Pred) {
+    return Pred == CmpInst::Predicate::ICMP_UGE ||
+            Pred == CmpInst::Predicate::ICMP_SGE ||
+            Pred == CmpInst::Predicate::ICMP_UGT ||
+            Pred == CmpInst::Predicate::ICMP_SGT ||
+            Pred == CmpInst::Predicate::ICMP_ULE ||
+            Pred == CmpInst::Predicate::ICMP_SLE ||
+            Pred == CmpInst::Predicate::ICMP_ULT ||
+            Pred == CmpInst::Predicate::ICMP_SLT;
+  };
+  // C > V
+  auto UpdateBound = [](ConstantInt *C, Value *V, CmpInst::Predicate Pred,
+                        AssumptionBounds &Bounds) {
+    auto CV = C->getSExtValue();
+    switch (Pred)
+    {
+    case CmpInst::Predicate::ICMP_UGE:
+    case CmpInst::Predicate::ICMP_SGE:
+      Bounds.Upper = Bounds.Upper ? std::max(CV, *Bounds.Upper) : CV;
+      break;
+    case CmpInst::Predicate::ICMP_UGT:
+    case CmpInst::Predicate::ICMP_SGT:
+      Bounds.Upper = Bounds.Upper ? std::max(CV - 1, *Bounds.Upper) :
+                                              CV - 1;
+      break;
+    case CmpInst::Predicate::ICMP_ULE:
+    case CmpInst::Predicate::ICMP_SLE:
+      Bounds.Lower = Bounds.Lower ? std::min(CV, *Bounds.Lower) : CV;
+      break;
+    case CmpInst::Predicate::ICMP_ULT:
+    case CmpInst::Predicate::ICMP_SLT:
+      Bounds.Lower = Bounds.Lower ? std::min(CV + 1, *Bounds.Lower) :
+                                              CV + 1;
+      break;
+    default:
+      llvm_unreachable("Predicate must be relational!");
+    }
+  };
+  for (auto &AssumeVH : AC.assumptions()) {
+    if (!AssumeVH)
+      continue;
+    if (auto *I = dyn_cast<CallInst>(AssumeVH.Assume)) {
+      //LLVM_DEBUG(dbgs() << "[ASSUME] CallInst: "; I->dump());
+      auto *CI = dyn_cast<CmpInst>(I->getArgOperand(0));
+      if (CI && CI->isIntPredicate() && IsRelational(CI->getPredicate())) {
+        //LLVM_DEBUG(dbgs() << "[ASSUME] CmpInst: "; CI->dump());
+        assert(CI->getNumOperands() == 2 &&
+            "Number of operands for CmpInst must be 2!");
+        auto *Op0 = CI->getOperand(0);
+        auto *Op1 = CI->getOperand(1);
+        auto *C0 = dyn_cast<ConstantInt>(Op0);
+        auto *C1 = dyn_cast<ConstantInt>(Op1);
+        if (C0 && !C1) {
+          AssumptionBounds &Bounds = mAM.insert(
+              std::make_pair(Op1, AssumptionBounds())).first->second;
+          UpdateBound(C0, Op1, CI->getPredicate(), Bounds);
+        } else if (!C0 && C1) {
+          AssumptionBounds &Bounds = mAM.insert(
+              std::make_pair(Op0, AssumptionBounds())).first->second;
+          UpdateBound(C1, Op0, CI->getSwappedPredicate(), Bounds);
+        }
+      }
+    }
+  }
+  LLVM_DEBUG(
+    dbgs() << "[ASSUME] Bounds: ";
+    for (auto &Pair : mAM) {
+      dbgs() << "<";
+      Pair.first->print(dbgs(), true);
+      dbgs() << ", [" << Pair.second.Lower << ", " << Pair.second.Upper << "]> ";
+    }
+    dbgs() << "\n";
+  );
+};
+
 void DataFlowTraits<ReachDFFwk*>::initialize(
   DFNode *N, ReachDFFwk *DFF, GraphType) {
   assert(N && "Node must not be null!");
@@ -1213,6 +1289,7 @@ void ReachDFFwk::collapse(DFRegion *R) {
       LLVM_DEBUG(printLocInfo("[COLLAPSE] Collapse Use location: ", Loc));
       distribute(aggregate(R, N, Loc, this), Loc, OwnUses, OtherUses);
     }
+    LLVM_DEBUG(dbgs() << "[COLLAPSE] MustReachIn:\n"; MustReachIn.dump(&getDomTree()));
     LocationSet NewUses;
     for (auto &Loc : OwnUses) {
       SmallVector<MemoryLocationRange, 4> UseDiff;

lib/Support/SCEVUtils.cpp

@@ -654,7 +654,7 @@ const SCEV *subtractSCEVAndCast(const SCEV *LHS,
     auto LC = dyn_cast<SCEVConstant>(InnerLHS);
     auto RC = dyn_cast<SCEVConstant>(InnerRHS);
     if (LC && RC) {
-      llvm_unreachable("Subtract constant SCEVs with different cast.");
+      llvm_unreachable("Subtract constant SCEVs with a different cast.");
     } else if (LC && !RC) {
       return restoreCasts(TQRHS, SE->getMinusSCEV(InnerLHS, InnerRHS), SE);
     } else if (!LC && RC) {
@@ -677,7 +677,7 @@ const SCEV *addSCEVAndCast(const SCEV *LHS,
     auto LC = dyn_cast<SCEVConstant>(LHS);
     auto RC = dyn_cast<SCEVConstant>(RHS);
     if (LC && RC) {
-      llvm_unreachable("Add constant SCEVs with different cast.");
+      llvm_unreachable("Add constant SCEVs with a different cast.");
     } else if (LC && !RC) {
       return restoreCasts(TQRHS, SE->getAddExpr(InnerLHS, InnerRHS), SE);
     } else if (!LC && RC) {