[Polly][NewPM] Port DependenceInfo to the new ScopPassManager.

[philip.pfaffe]

Summary

This patch ports DependenceInfo to the new ScopPassManager. Printing is implemented as a seperate printer pass.

[grosser]

lib/Analysis/DependenceInfo.cpp

948

and print THEM.

include/polly/DependenceInfo.h

struct Dependences {
 
   /// Return the granularity of this dependence analysis.
   AnalysisLevel getDependenceLevel() { return Level; }
 
   /// Allow the DependenceInfo access to private members and methods.
   ///
   /// To restrict access to the internal state, only the DependenceInfo class
   /// is able to call or modify a Dependences struct.
+  friend struct DependenceAnalysis;
+  friend struct DependenceInfoPrinterPass;
   friend class DependenceInfo;
   friend class DependenceInfoWrapperPass;
 
   /// Destructor that will free internal objects.
   ~Dependences() { releaseMemory(); }
 
 private:
   /// Create an empty dependences struct.
private:
 
   /// Isl context from the SCoP.
   std::shared_ptr<isl_ctx> IslCtx;
 
   /// Granularity of this dependence analysis.
   const AnalysisLevel Level;
 };
 
+struct DependenceAnalysis : public AnalysisInfoMixin<DependenceAnalysis> {
+  static AnalysisKey Key;
+  struct Result {
+    Scop &S;
+    std::unique_ptr<Dependences> D[Dependences::NumAnalysisLevels];
+
+    /// Return the dependence information for the current SCoP.
+    ///
+    /// @param Level The granularity of dependence analysis result.
+    ///
+    /// @return The dependence analysis result
+    ///
+    const Dependences &getDependences(Dependences::AnalysisLevel Level);
+
+    /// Recompute dependences from schedule and memory accesses.
+    const Dependences &recomputeDependences(Dependences::AnalysisLevel Level);
+  };
+  Result run(Scop &S, ScopAnalysisManager &SAM,
+             ScopStandardAnalysisResults &SAR);
+};
+
+struct DependenceInfoPrinterPass
+    : public PassInfoMixin<DependenceInfoPrinterPass> {
+  DependenceInfoPrinterPass(raw_ostream &OS) : OS(OS) {}
+
+  PreservedAnalyses run(Scop &S, ScopAnalysisManager &,
+                        ScopStandardAnalysisResults &, SPMUpdater &);
+
+  raw_ostream &OS;
+};
+
 class DependenceInfo : public ScopPass {
 public:
   static char ID;
 
   /// Construct a new DependenceInfo pass.
   DependenceInfo() : ScopPass(ID) {}
 
   /// Return the dependence information for the current SCoP.

lib/Analysis/DependenceInfo.cpp

 
 void Dependences::setReductionDependences(MemoryAccess *MA, isl_map *D) {
   assert(ReductionDependences.count(MA) == 0 &&
          "Reduction dependences set twice!");
   ReductionDependences[MA] = D;
 }
 
 const Dependences &
+DependenceAnalysis::Result::getDependences(Dependences::AnalysisLevel Level) {
+  if (Dependences *d = D[Level].get())
+    return *d;
+
+  return recomputeDependences(Level);
+}
+
+const Dependences &DependenceAnalysis::Result::recomputeDependences(
+    Dependences::AnalysisLevel Level) {
+  D[Level].reset(new Dependences(S.getSharedIslCtx(), Level));
+  D[Level]->calculateDependences(S);
+  return *D[Level];
+}
+
+DependenceAnalysis::Result
+DependenceAnalysis::run(Scop &S, ScopAnalysisManager &SAM,
+                        ScopStandardAnalysisResults &SAR) {
+  return {S, {}};
+}
+
+AnalysisKey DependenceAnalysis::Key;
+
+PreservedAnalyses
+DependenceInfoPrinterPass::run(Scop &S, ScopAnalysisManager &SAM,
+                               ScopStandardAnalysisResults &SAR,
+                               SPMUpdater &U) {
+  auto &DI = SAM.getResult<DependenceAnalysis>(S, SAR);
+
+  if (auto d = DI.D[OptAnalysisLevel].get()) {
+    d->print(OS);
+    return PreservedAnalyses::all();
+  }
+
+  // Otherwise create the dependences on-the-fly and print it
+  Dependences D(S.getSharedIslCtx(), OptAnalysisLevel);
+  D.calculateDependences(S);
+  D.print(OS);
+
+  return PreservedAnalyses::all();
+}
+
+const Dependences &
 DependenceInfo::getDependences(Dependences::AnalysisLevel Level) {
   if (Dependences *d = D[Level].get())
     return *d;
 
   return recomputeDependences(Level);
 }
 
 const Dependences &