[TSAR, Memory, Interproc] Add finding the range of the array in memory.

Author: yukatan1701

include/tsar/Analysis/Memory/DefinedMemory.h

@@ -36,6 +36,8 @@
 #include "tsar/ADT/DataFlow.h"
 #include "tsar/ADT/DenseMapTraits.h"
 #include "tsar/Analysis/DFRegionInfo.h"
+#include "llvm/Analysis/ScalarEvolution.h"
+#include "tsar/Analysis/Memory/Delinearization.h"
 #include "tsar/Analysis/Memory/DFMemoryLocation.h"
 #include "tsar/Analysis/Memory/MemoryLocationRange.h"
 #include "tsar/Analysis/Memory/Passes.h"
@@ -365,6 +367,14 @@ class ReachDFFwk : private bcl::Uncopyable {
       bcl::tagged<std::unique_ptr<DefUseSet>, DefUseSet>>> InterprocDefUseInfo;
 
   /// Creates data-flow framework.
+  ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
+      const llvm::DominatorTree *DT, DefinedMemoryInfo &DefInfo,
+      const DelinearizeInfo &DI, llvm::ScalarEvolution &SE,
+      const llvm::DataLayout &DL) :
+    mAliasTree(&AT), mTLI(&TLI), mDT(DT), mDefInfo(&DefInfo), mDI(&DI),
+    mSE(&SE), mDL(&DL) {}
+
+    /// Creates data-flow framework.
   ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
       const llvm::DominatorTree *DT, DefinedMemoryInfo &DefInfo) :
     mAliasTree(&AT), mTLI(&TLI), mDT(DT), mDefInfo(&DefInfo) {}
@@ -376,6 +386,14 @@ class ReachDFFwk : private bcl::Uncopyable {
     mAliasTree(&AT), mTLI(&TLI), mDT(DT), mDefInfo(&DefInfo),
     mInterprocDUInfo(&InterprocDUInfo) {}
 
+  /// Creates data-flow framework.
+  ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
+      const llvm::DominatorTree *DT, DefinedMemoryInfo &DefInfo,
+      const DelinearizeInfo &DI, llvm::ScalarEvolution &SE,
+      const llvm::DataLayout &DL, InterprocDefUseInfo &InterprocDUInfo) :
+    mAliasTree(&AT), mTLI(&TLI), mDT(DT), mDefInfo(&DefInfo),
+    mDI(&DI), mSE(&SE), mDL(&DL), mInterprocDUInfo(&InterprocDUInfo) {}
+
   /// Return results of interprocedural analysis or nullptr.
   InterprocDefUseInfo * getInterprocDefUseInfo() noexcept {
     return mInterprocDUInfo;
@@ -401,16 +419,27 @@ class ReachDFFwk : private bcl::Uncopyable {
   /// Returns dominator tree if it is available or nullptr.
   const llvm::DominatorTree * getDomTree() const noexcept { return mDT; }
 
+  /// Returns delinearize info.
+  const DelinearizeInfo * getDelinearizeInfo() const noexcept { return mDI; }
+
+  /// Returns scalar evolution.
+  llvm::ScalarEvolution * getScalarEvolution() const noexcept { return mSE; }
+
+  /// Returns data layout.
+  const llvm::DataLayout & getDataLayout() const noexcept { return *mDL; }
+
   /// Collapses a data-flow graph which represents a region to a one node
   /// in a data-flow graph of an outer region.
   void collapse(DFRegion *R);
-
 private:
   AliasTree *mAliasTree;
   llvm::TargetLibraryInfo *mTLI;
   const llvm::DominatorTree *mDT;
   DefinedMemoryInfo *mDefInfo;
   InterprocDefUseInfo *mInterprocDUInfo = nullptr;
+  const DelinearizeInfo *mDI = nullptr;
+  llvm::ScalarEvolution *mSE = nullptr;
+  const llvm::DataLayout *mDL;
 };
 
 /// This represents results of interprocedural reach definition analysis.

lib/Analysis/Memory/DefinedMemory.cpp

@@ -24,16 +24,20 @@
 
 #include "tsar/Analysis/Memory/DefinedMemory.h"
 #include "tsar/Analysis/DFRegionInfo.h"
+#include "tsar/Analysis/Memory/Delinearization.h"
 #include "tsar/Analysis/Memory/EstimateMemory.h"
 #include "tsar/Analysis/Memory/MemoryAccessUtils.h"
 #include "tsar/Analysis/Memory/Utils.h"
 #include "tsar/Support/Utils.h"
 #include "tsar/Support/IRUtils.h"
+#include "tsar/Support/SCEVUtils.h"
 #include "tsar/Unparse/Utils.h"
 #include <llvm/ADT/STLExtras.h>
 #include <llvm/Analysis/AliasAnalysis.h>
 #include <llvm/Analysis/AliasSetTracker.h>
 #include <llvm/Analysis/LoopInfo.h>
+#include "llvm/Analysis/ScalarEvolution.h"
+#include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include <llvm/Analysis/ValueTracking.h>
 #include <llvm/Config/llvm-config.h>
 #include <llvm/IR/Dominators.h>
@@ -53,6 +57,8 @@ char DefinedMemoryPass::ID = 0;
 INITIALIZE_PASS_BEGIN(DefinedMemoryPass, "def-mem",
   "Defined Memory Region Analysis", false, true)
   LLVM_DEBUG(INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass));
+  INITIALIZE_PASS_DEPENDENCY(DelinearizationPass)
+  INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
   INITIALIZE_PASS_DEPENDENCY(DFRegionInfoPass)
   INITIALIZE_PASS_DEPENDENCY(EstimateMemoryPass)
   INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
@@ -67,18 +73,23 @@ bool llvm::DefinedMemoryPass::runOnFunction(Function & F) {
   const DominatorTree *DT = nullptr;
   LLVM_DEBUG(DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree());
   auto *DFF = cast<DFFunction>(RegionInfo.getTopLevelRegion());
+  auto &DI = getAnalysis<DelinearizationPass>().getDelinearizeInfo();
+  auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   auto &GDM = getAnalysis<GlobalDefinedMemoryWrapper>();
+  auto &DL = F.getParent()->getDataLayout();
   if (GDM) {
-    ReachDFFwk ReachDefFwk(AliasTree, TLI, DT, mDefInfo, *GDM);
+    ReachDFFwk ReachDefFwk(AliasTree, TLI, DT, mDefInfo, DI, SE, DL, *GDM);
     solveDataFlowUpward(&ReachDefFwk, DFF);
   } else {
-    ReachDFFwk ReachDefFwk(AliasTree, TLI, DT, mDefInfo);
+    ReachDFFwk ReachDefFwk(AliasTree, TLI, DT, mDefInfo, DI, SE, DL);
     solveDataFlowUpward(&ReachDefFwk, DFF);
   }
   return false;
 }
 
 void DefinedMemoryPass::getAnalysisUsage(AnalysisUsage & AU) const {
+  AU.addRequired<DelinearizationPass>();
+  AU.addRequired<ScalarEvolutionWrapperPass>();
   LLVM_DEBUG(AU.addRequired<DominatorTreeWrapperPass>());
   AU.addRequired<DFRegionInfoPass>();
   AU.addRequired<EstimateMemoryPass>();
@@ -579,6 +590,49 @@ void ReachDFFwk::collapse(DFRegion *R) {
   // of execution paths of iterations of the loop.
   DFNode *ExitNode = R->getExitNode();
   const DefinitionInfo &ExitingDefs = RT::getValue(ExitNode, this);
+  auto calcArrayLocation = [this, R](const tsar::MemoryLocationRange &Loc) {
+    MemoryLocationRange arrayLoc;
+    arrayLoc.Ptr = nullptr;
+    auto LocInfo = getDelinearizeInfo()->findRange(Loc.Ptr);
+    if (LocInfo.first && LocInfo.first->isDelinearized() &&
+      LocInfo.second->isValid()) {
+      for (auto *S : LocInfo.second->Subscripts) {
+        auto *SE = getScalarEvolution();
+        auto AddRecInfo = computeSCEVAddRec(S, *SE);
+        if (AddRecInfo.second) {
+          auto SCEV = AddRecInfo.first;
+          if (static_cast<SCEVTypes>(SCEV->getSCEVType()) != scAddRecExpr) {
+            break;
+          }
+          auto addRecExpr = cast<SCEVAddRecExpr>(SCEV);
+          if (auto *DFL = dyn_cast<DFLoop>(R)) {
+            auto *L = DFL->getLoop();
+            auto maxTripCount = SE->getSmallConstantMaxTripCount(L);
+            if (maxTripCount == 0)
+              break;
+            auto rangeMin = SE->getSignedRangeMin(SCEV);
+            auto rangeMax = SE->getSignedRangeMax(SCEV);
+            auto *stepSCEV = addRecExpr->getOperand(1);
+            if (static_cast<SCEVTypes>(stepSCEV->getSCEVType()) !=
+              scConstant)
+              break;
+            auto stepNumber = *cast<SCEVConstant>(stepSCEV)->
+              getValue()->getValue().getRawData();
+            if (stepNumber > 1)
+              break;
+            PointerType *pointerType = cast<PointerType>(
+              LocInfo.first->getBase()->getType());
+            auto arrayElementSize = getDataLayout().getTypeStoreSize(
+              pointerType->getElementType());
+            arrayLoc = Loc;
+            arrayLoc.LowerBound = *rangeMin.getRawData() * arrayElementSize;
+            arrayLoc.UpperBound = (*rangeMax.getRawData()+1) * arrayElementSize;
+          }
+        }
+      }
+    }
+    return arrayLoc;
+  };
   for (DFNode *N : R->getNodes()) {
     auto DefItr = getDefInfo().find(N);
     assert(DefItr != getDefInfo().end() &&
@@ -624,8 +678,13 @@ void ReachDFFwk::collapse(DFRegion *R) {
             break;
         }
       }
-      if (!RS->getIn().MustReach.contain(Loc) && !(StartInLoop && EndInLoop))
-        DefUse->addUse(Loc);
+      if (!RS->getIn().MustReach.contain(Loc) && !(StartInLoop && EndInLoop)) {
+        auto arrayLoc = calcArrayLocation(Loc);
+        if (arrayLoc.Ptr != nullptr)
+          DefUse->addUse(arrayLoc);
+        else
+          DefUse->addUse(Loc);
+      }
     }
     // It is possible that some locations are only written in the loop.
     // In this case this locations are not located at set of node uses but
@@ -648,13 +707,27 @@ void ReachDFFwk::collapse(DFRegion *R) {
     //     X = ...;
     // }
     for (auto &Loc : DU->getDefs()) {
-      if (ExitingDefs.MustReach.contain(Loc))
-        DefUse->addDef(Loc);
+      if (ExitingDefs.MustReach.contain(Loc)) {
+        auto arrayLoc = calcArrayLocation(Loc);
+        if (arrayLoc.Ptr != nullptr)
+          DefUse->addDef(arrayLoc);
+        else
+          DefUse->addDef(Loc);
+      } else {
+        auto arrayLoc = calcArrayLocation(Loc);
+        if (arrayLoc.Ptr != nullptr)
+          DefUse->addMayDef(arrayLoc);
+        else
+          DefUse->addMayDef(Loc);
+      }
+    }
+    for (auto &Loc : DU->getMayDefs()) {
+      auto arrayLoc = calcArrayLocation(Loc);
+      if (arrayLoc.Ptr != nullptr)
+        DefUse->addMayDef(arrayLoc);
       else
         DefUse->addMayDef(Loc);
     }
-    for (auto &Loc : DU->getMayDefs())
-      DefUse->addMayDef(Loc);
     DefUse->addExplicitAccesses(DU->getExplicitAccesses());
     DefUse->addExplicitUnknowns(DU->getExplicitUnknowns());
     for (auto Loc : DU->getAddressAccesses())

lib/Analysis/Memory/GlobalDefinedMemory.cpp

@@ -22,9 +22,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "tsar/Analysis/Attributes.h"
+#include "tsar/Analysis/Memory/Delinearization.h"
+#include "llvm/Analysis/ScalarEvolution.h"
 #include "tsar/Analysis/Memory/DefinedMemory.h"
 #include "tsar/Analysis/Memory/EstimateMemory.h"
 #include "tsar/Analysis/Memory/Passes.h"
+#include "tsar/Support/GlobalOptions.h"
 #include "tsar/Support/PassProvider.h"
 #include <bcl/utility.h>
 #include <llvm/ADT/SCCIterator.h>
@@ -90,7 +93,9 @@ class GlobalDefinedMemoryStorage :
 using GlobalDefinedMemoryProvider = FunctionPassProvider<
   DFRegionInfoPass,
   EstimateMemoryPass,
-  DominatorTreeWrapperPass>;
+  DominatorTreeWrapperPass,
+  DelinearizationPass,
+  ScalarEvolutionWrapperPass>;
 }
 
 INITIALIZE_PROVIDER_BEGIN(GlobalDefinedMemoryProvider,
@@ -99,6 +104,7 @@ INITIALIZE_PROVIDER_BEGIN(GlobalDefinedMemoryProvider,
 INITIALIZE_PASS_DEPENDENCY(DFRegionInfoPass)
 INITIALIZE_PASS_DEPENDENCY(EstimateMemoryPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)
 INITIALIZE_PROVIDER_END(GlobalDefinedMemoryProvider, "global-def-mem-provider",
                         "Global Defined Memory Analysis (Provider)")
 
@@ -120,6 +126,7 @@ INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(GlobalDefinedMemoryProvider)
 INITIALIZE_PASS_DEPENDENCY(GlobalDefinedMemoryWrapper)
+INITIALIZE_PASS_DEPENDENCY(GlobalOptionsImmutableWrapper)
 INITIALIZE_PASS_END(GlobalDefinedMemory, "global-def-mem",
                     "Global Defined Memory Analysis", true, true)
 
@@ -128,6 +135,8 @@ void GlobalDefinedMemory::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<GlobalDefinedMemoryWrapper>();
   AU.addRequired<CallGraphWrapperPass>();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
+  AU.addRequired<GlobalOptionsImmutableWrapper>();
+  AU.addRequired<ScalarEvolutionWrapperPass>();
   AU.setPreservesAll();
 }
 
@@ -144,8 +153,14 @@ bool GlobalDefinedMemory::runOnModule(Module &SCC) {
   if (!Wrapper)
     return false;
   Wrapper->clear();
+  auto &GO = getAnalysis<GlobalOptionsImmutableWrapper>().getOptions();
+  GlobalDefinedMemoryProvider::initialize<GlobalOptionsImmutableWrapper>(
+      [&GO](GlobalOptionsImmutableWrapper &Wrapper) {
+        Wrapper.setOptions(&GO);
+      });
   auto &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
   auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
+  auto &DL = SCC.getDataLayout();
   for (scc_iterator<CallGraph *> SCC = scc_begin(&CG); !SCC.isAtEnd(); ++SCC) {
     /// TODO ([email protected]): implement analysis in case of recursion.
     if (SCC->size() > 1)
@@ -164,11 +179,13 @@ bool GlobalDefinedMemory::runOnModule(Module &SCC) {
     auto &Provider = getAnalysis<GlobalDefinedMemoryProvider>(*F);
     auto &RegInfo = Provider.get<DFRegionInfoPass>().getRegionInfo();
     auto &AT = Provider.get<EstimateMemoryPass>().getAliasTree();
+    auto &DI = Provider.get<DelinearizationPass>().getDelinearizeInfo();
+    auto &SE = Provider.get<ScalarEvolutionWrapperPass>().getSE();
     const DominatorTree *DT = nullptr;
     LLVM_DEBUG(DT = &Provider.get<DominatorTreeWrapperPass>().getDomTree());
     auto *DFF = cast<DFFunction>(RegInfo.getTopLevelRegion());
     DefinedMemoryInfo DefInfo;
-    ReachDFFwk ReachDefFwk(AT, TLI, DT, DefInfo, *Wrapper);
+    ReachDFFwk ReachDefFwk(AT, TLI, DT, DefInfo, DI, SE, DL, *Wrapper);
     solveDataFlowUpward(&ReachDefFwk, DFF);
     auto DefUseSetItr = ReachDefFwk.getDefInfo().find(DFF);
     assert(DefUseSetItr != ReachDefFwk.getDefInfo().end() &&

lib/Analysis/Memory/GlobalLiveMemory.cpp

@@ -104,6 +104,7 @@ using CallList = std::vector<
 using LiveMemoryForCalls = DenseMap<const Function *, CallList>;
 
 using GlobalLiveMemoryProvider = FunctionPassProvider<
+  GlobalOptionsImmutableWrapper,
   DFRegionInfoPass,
   DefinedMemoryPass,
   DominatorTreeWrapperPass>;
@@ -187,6 +188,7 @@ INITIALIZE_PROVIDER_BEGIN(GlobalLiveMemoryProvider, "global-live-mem-provider",
 INITIALIZE_PASS_DEPENDENCY(DFRegionInfoPass)
 INITIALIZE_PASS_DEPENDENCY(DefinedMemoryPass)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
+INITIALIZE_PASS_DEPENDENCY(GlobalOptionsImmutableWrapper)
 INITIALIZE_PROVIDER_END(GlobalLiveMemoryProvider, "global-live-mem-provider",
                         "Global Live Memory Analysis (Provider)")
 
@@ -263,6 +265,10 @@ bool GlobalLiveMemory::runOnModule(Module &M) {
       return false;
     Worklist.push_back(CGN);
   }
+  GlobalLiveMemoryProvider::initialize<GlobalOptionsImmutableWrapper>(
+      [&GO](GlobalOptionsImmutableWrapper &Wrapper) {
+        Wrapper.setOptions(&GO);
+      });
   auto &GDM = getAnalysis<GlobalDefinedMemoryWrapper>();
   if (GDM) {
     GlobalLiveMemoryProvider::initialize<GlobalDefinedMemoryWrapper>(