[TSAR, Memory] Use assumption information to perform intersection of memory locations.

Author: yukatan1701

include/tsar/Analysis/Memory/AssumptionInfo.h

@@ -0,0 +1,68 @@
+//===- AssumptionInfo.h -- Delinearization Engine --------------*- C++ -*-===//
+//
+//                     Traits Static Analyzer (SAPFOR)
+//
+// Copyright 2022 DVM System Group
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file allows to perform metadata-based delinearization of array accesses.
+//
+//===----------------------------------------------------------------------===/
+
+#ifndef TSAR_ASSUMPTION_INFO_H
+#define TSAR_ASSUMPTION_INFO_H
+
+#include "tsar/Analysis/Memory/Passes.h"
+#include <llvm/ADT/DenseMap.h>
+#include <llvm/Pass.h>
+#include <bcl/utility.h>
+
+namespace llvm {
+class Value;
+}
+
+namespace tsar {
+  typedef llvm::Optional<int64_t> AssumptionBound;
+  struct AssumptionBounds {
+    AssumptionBound Lower = llvm::None;
+    AssumptionBound Upper = llvm::None;
+  };
+
+  typedef llvm::DenseMap<llvm::Value *, AssumptionBounds> AssumptionMap; 
+}
+
+namespace llvm {
+class AssumptionInfoPass : public FunctionPass, private bcl::Uncopyable {
+public:
+  static char ID;
+
+  AssumptionInfoPass() : FunctionPass(ID) {
+    initializeAssumptionInfoPassPass(*PassRegistry::getPassRegistry());
+  }
+
+  bool runOnFunction(Function &F) override;
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+  void releaseMemory() override { mAM.clear(); }
+
+  const tsar::AssumptionMap & getAssumptionMap() const {
+    return mAM;
+  }
+private:
+  tsar::AssumptionMap mAM; 
+};
+}
+
+#endif //TSAR_ASSUMPTION_INFO_H

include/tsar/Analysis/Memory/DefinedMemory.h

@@ -472,14 +472,6 @@ 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>>,
@@ -500,36 +492,32 @@ class ReachDFFwk : private bcl::Uncopyable {
   ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
       const DFRegionInfo &DFI, const llvm::DominatorTree &DT,
       const DelinearizeInfo &DI, llvm::ScalarEvolution &SE,
-      const llvm::DataLayout &DL, llvm::AssumptionCache &AC,
+      const llvm::DataLayout &DL, const AssumptionMap &AM,
       const GlobalOptions &GO, DefinedMemoryInfo &DefInfo) :
     mAliasTree(&AT), mTLI(&TLI), mRegionInfo(&DFI),
-    mDT(&DT), mDI(&DI), mSE(&SE), mDL(&DL), mGO(&GO), mDefInfo(&DefInfo) {
-      initializeAssumptions(AC);
-    }
+    mDT(&DT), mDI(&DI), mSE(&SE), mDL(&DL), mAM(&AM), mGO(&GO),
+    mDefInfo(&DefInfo) {}
 
   /// Creates data-flow framework.
   ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
       const DFRegionInfo &DFI, const llvm::DominatorTree &DT,
       const DelinearizeInfo &DI, llvm::ScalarEvolution &SE,
-      const llvm::DataLayout &DL, llvm::AssumptionCache &AC,
+      const llvm::DataLayout &DL, const AssumptionMap &AM,
       const GlobalOptions &GO, DefinedMemoryInfo &DefInfo,
       InterprocDefUseInfo &InterprocDUInfo) :
     mAliasTree(&AT), mTLI(&TLI), mRegionInfo(&DFI), mDT(&DT),
-    mDI(&DI), mSE(&SE), mDL(&DL), mGO(&GO), mDefInfo(&DefInfo),
-    mInterprocDUInfo(&InterprocDUInfo) {
-      initializeAssumptions(AC);
-    }
+    mDI(&DI), mSE(&SE), mDL(&DL), mAM(&AM), mGO(&GO), mDefInfo(&DefInfo),
+    mInterprocDUInfo(&InterprocDUInfo) {}
 
   /// Creates data-flow framework.
   ReachDFFwk(AliasTree &AT, llvm::TargetLibraryInfo &TLI,
       const llvm::DominatorTree &DT, const DelinearizeInfo &DI,
       llvm::ScalarEvolution &SE, const llvm::DataLayout &DL,
-      llvm::AssumptionCache &AC, const GlobalOptions &GO,
+      const AssumptionMap &AM, const GlobalOptions &GO,
       DefinedMemoryInfo &DefInfo, InterprocDefUseInfo &InterprocDUInfo) :
     mAliasTree(&AT), mTLI(&TLI), mDT(&DT), mDI(&DI), mSE(&SE), mDL(&DL),
-    mGO(&GO), mDefInfo(&DefInfo), mInterprocDUInfo(&InterprocDUInfo) {
-      initializeAssumptions(AC);
-    }
+    mGO(&GO), mAM(&AM), mDefInfo(&DefInfo),
+    mInterprocDUInfo(&InterprocDUInfo) {}
 
   /// Return results of interprocedural analysis or nullptr.
   InterprocDefUseInfo * getInterprocDefUseInfo() noexcept {
@@ -568,8 +556,8 @@ class ReachDFFwk : private bcl::Uncopyable {
   /// Returns data layout.
   const llvm::DataLayout & getDataLayout() const noexcept { return *mDL; }
 
-  /// Returns assumption cache.
-  const AssumptionMap & getAssumptionMap() const noexcept {
+  /// Returns assumption map.
+  const AssumptionMap * getAssumptionMap() const noexcept {
     return mAM;
   }
 
@@ -580,8 +568,6 @@ 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;
@@ -591,7 +577,7 @@ class ReachDFFwk : private bcl::Uncopyable {
   const DelinearizeInfo *mDI;
   llvm::ScalarEvolution *mSE;
   const llvm::DataLayout *mDL;
-  AssumptionMap mAM;
+  const AssumptionMap *mAM;
   const GlobalOptions *mGO;
 };
 

include/tsar/Analysis/Memory/MemoryLocationRange.h

@@ -25,6 +25,7 @@
 #ifndef TSAR_MEMORY_LOCATION_RANGE_H
 #define TSAR_MEMORY_LOCATION_RANGE_H
 
+#include "tsar/Analysis/Memory/AssumptionInfo.h"
 #include <llvm/ADT/APInt.h>
 #include <llvm/ADT/BitmaskEnum.h>
 #include <llvm/Analysis/MemoryLocation.h>
@@ -76,6 +77,7 @@ struct MemoryLocationRange {
   llvm::AAMDNodes AATags;
   LocKind Kind;
   llvm::ScalarEvolution *SE;
+  const AssumptionMap *AM;
 
   /// Return a location with information about the memory reference by the given
   /// instruction.
@@ -143,24 +145,26 @@ struct MemoryLocationRange {
                                LocationSize UpperBound = UnknownSize,
                                const llvm::AAMDNodes &AATags = llvm::AAMDNodes())
       : Ptr(Ptr), LowerBound(LowerBound), UpperBound(UpperBound),
-        AATags(AATags), SE(nullptr), Kind(LocKind::Default) {}
+        AATags(AATags), SE(nullptr), AM(nullptr), Kind(LocKind::Default) {}
 
   explicit MemoryLocationRange(const llvm::Value *Ptr,
                                LocationSize LowerBound,
                                LocationSize UpperBound,
                                LocKind Kind,
                                llvm::ScalarEvolution *SE,
+                               AssumptionMap *AM,
                                const llvm::AAMDNodes &AATags = llvm::AAMDNodes())
       : Ptr(Ptr), LowerBound(LowerBound), UpperBound(UpperBound), Kind(Kind),
-        SE(SE), AATags(AATags) {}
+        SE(SE), AM(AM), AATags(AATags) {}
 
   MemoryLocationRange(const llvm::MemoryLocation &Loc)
       : Ptr(Loc.Ptr), LowerBound(0), UpperBound(Loc.Size), AATags(Loc.AATags),
-        Kind(LocKind::Default), SE(nullptr) {}
+        Kind(LocKind::Default), SE(nullptr), AM(nullptr) {}
 
   MemoryLocationRange(const MemoryLocationRange &Loc)
       : Ptr(Loc.Ptr), LowerBound(Loc.LowerBound), UpperBound(Loc.UpperBound),
-        AATags(Loc.AATags), DimList(Loc.DimList), Kind(Loc.Kind), SE(Loc.SE) {}
+        AATags(Loc.AATags), DimList(Loc.DimList), Kind(Loc.Kind), SE(Loc.SE),
+        AM(Loc.AM) {}
 
   MemoryLocationRange &operator=(const llvm::MemoryLocation &Loc) {
     Ptr = Loc.Ptr;
@@ -169,13 +173,15 @@ struct MemoryLocationRange {
     AATags = Loc.AATags;
     Kind = Default;
     SE = nullptr;
+    AM = nullptr;
     return *this;
   }
 
   bool operator==(const MemoryLocationRange &Other) const {
     return Ptr == Other.Ptr && AATags == Other.AATags &&
       LowerBound == Other.LowerBound && UpperBound == Other.UpperBound &&
-      DimList == Other.DimList && SE == Other.SE && Kind == Other.Kind;
+      DimList == Other.DimList && SE == Other.SE && AM == Other.AM &&
+      Kind == Other.Kind;
   }
 
   llvm::StringRef getKindAsString() const {

include/tsar/Analysis/Memory/Passes.h

@@ -234,5 +234,9 @@ ModulePass * createGlobalsAccessCollector();
 // Initialize a pass to access list of explicit accesses to global
 // values in a function.
 void initializeGlobalsAccessWrapperPass(PassRegistry &Registry);
+
+FunctionPass *createAssumptionInfoPass();
+
+void initializeAssumptionInfoPassPass(PassRegistry& Registry);
 }
 #endif//TSAR_MEMORY_ANALYSIS_PASSES_H

include/tsar/Support/SCEVUtils.h

@@ -31,6 +31,7 @@
 namespace llvm {
 class ScalarEvolution;
 class SCEV;
+class SCEVAddRecExpr;
 }
 
 namespace tsar {
@@ -91,5 +92,11 @@ const llvm::SCEV *subtractSCEVAndCast(const llvm::SCEV *LHS,
 llvm::Optional<int64_t> compareSCEVs(const llvm::SCEV *LHS,
                                      const llvm::SCEV *RHS,
                                      llvm::ScalarEvolution *SE);
+
+/// Return the value of this chain of recurrences at the specified
+/// iteration number.
+const llvm::SCEV *evaluateAtIteration(const llvm::SCEVAddRecExpr *ARE,
+                                      const llvm::SCEV *It,
+                                      llvm::ScalarEvolution *SE);
 }
 #endif//TSAR_SCEV_UTILS_H