1 files changed, 35 insertions, 13 deletions

diff --git a/gnu/llvm/include/llvm/Analysis/DependenceAnalysis.h b/gnu/llvm/include/llvm/Analysis/DependenceAnalysis.h
index 5290552b41d..32dd367a9c0 100644
--- a/gnu/llvm/include/llvm/Analysis/DependenceAnalysis.h
+++ b/gnu/llvm/include/llvm/Analysis/DependenceAnalysis.h
@@ -41,12 +41,12 @@
 #define LLVM_ANALYSIS_DEPENDENCEANALYSIS_H
 
 #include "llvm/ADT/SmallBitVector.h"
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
+template <typename T> class ArrayRef;
   class Loop;
   class LoopInfo;
   class ScalarEvolution;
@@ -206,7 +206,7 @@ namespace llvm {
   private:
     Instruction *Src, *Dst;
     const Dependence *NextPredecessor, *NextSuccessor;
-    friend class DependenceAnalysis;
+    friend class DependenceInfo;
   };
 
   /// FullDependence - This class represents a dependence between two memory
@@ -274,16 +274,17 @@ namespace llvm {
     bool LoopIndependent;
     bool Consistent; // Init to true, then refine.
     std::unique_ptr<DVEntry[]> DV;
-    friend class DependenceAnalysis;
+    friend class DependenceInfo;
   };
 
-  /// DependenceAnalysis - This class is the main dependence-analysis driver.
+  /// DependenceInfo - This class is the main dependence-analysis driver.
   ///
-  class DependenceAnalysis : public FunctionPass {
-    void operator=(const DependenceAnalysis &) = delete;
-    DependenceAnalysis(const DependenceAnalysis &) = delete;
-
+  class DependenceInfo {
   public:
+    DependenceInfo(Function *F, AliasAnalysis *AA, ScalarEvolution *SE,
+                   LoopInfo *LI)
+        : AA(AA), SE(SE), LI(LI), F(F) {}
+
     /// depends - Tests for a dependence between the Src and Dst instructions.
     /// Returns NULL if no dependence; otherwise, returns a Dependence (or a
     /// FullDependence) with as much information as can be gleaned.
@@ -336,6 +337,8 @@ namespace llvm {
     /// both loops.
     const SCEV *getSplitIteration(const Dependence &Dep, unsigned Level);
 
+    Function *getFunction() const { return F; }
+
   private:
     AliasAnalysis *AA;
     ScalarEvolution *SE;
@@ -919,22 +922,41 @@ namespace llvm {
 
     bool tryDelinearize(Instruction *Src, Instruction *Dst,
                         SmallVectorImpl<Subscript> &Pair);
+  }; // class DependenceInfo
 
+  /// \brief AnalysisPass to compute dependence information in a function
+  class DependenceAnalysis : public AnalysisInfoMixin<DependenceAnalysis> {
+  public:
+    typedef DependenceInfo Result;
+    Result run(Function &F, FunctionAnalysisManager &FAM);
+
+  private:
+    static char PassID;
+    friend struct AnalysisInfoMixin<DependenceAnalysis>;
+  }; // class DependenceAnalysis
+
+  /// \brief Legacy pass manager pass to access dependence information
+  class DependenceAnalysisWrapperPass : public FunctionPass {
   public:
     static char ID; // Class identification, replacement for typeinfo
-    DependenceAnalysis() : FunctionPass(ID) {
-      initializeDependenceAnalysisPass(*PassRegistry::getPassRegistry());
+    DependenceAnalysisWrapperPass() : FunctionPass(ID) {
+      initializeDependenceAnalysisWrapperPassPass(
+          *PassRegistry::getPassRegistry());
     }
 
     bool runOnFunction(Function &F) override;
     void releaseMemory() override;
     void getAnalysisUsage(AnalysisUsage &) const override;
     void print(raw_ostream &, const Module * = nullptr) const override;
-  }; // class DependenceAnalysis
+    DependenceInfo &getDI() const;
+
+  private:
+    std::unique_ptr<DependenceInfo> info;
+  }; // class DependenceAnalysisWrapperPass
 
   /// createDependenceAnalysisPass - This creates an instance of the
-  /// DependenceAnalysis pass.
-  FunctionPass *createDependenceAnalysisPass();
+  /// DependenceAnalysis wrapper pass.
+  FunctionPass *createDependenceAnalysisWrapperPass();
 
 } // namespace llvm