[WIP] Getting rid of getAnalysisResult usage in PassManager

[fedor.sergeev]

Summary

Removing it in PassManager::run requires fixing PassManagerTest.
Removing it in RepeatedPass::run requires ability to specialize RepeatedPass
on AnalysisManager.

Just for discussion of possible solutions for D47858.

include/llvm/Analysis/CGSCCPassManager.h

 /// A function to deduce a function pass type and wrap it in the
 /// templated adaptor.
 template <typename PassT>
 DevirtSCCRepeatedPass<PassT> createDevirtSCCRepeatedPass(PassT Pass,
                                                          int MaxIterations) {
   return DevirtSCCRepeatedPass<PassT>(std::move(Pass), MaxIterations);
 }
 
+/// A specialized version of RepeatedPass that handles CGSCCAnalysisManager
+/// interface.
+template <typename PassT>
+class RepeatedPass<PassT, CGSCCAnalysisManager>
+    : public PassInfoMixin<RepeatedPass<PassT, CGSCCAnalysisManager>> {
+public:
+  RepeatedPass(int Count, PassT P) : Count(Count), P(std::move(P)) {}
+
+  PreservedAnalyses run(LazyCallGraph::SCC &InitialC, CGSCCAnalysisManager &AM,
+                        LazyCallGraph &G, CGSCCUpdateResult &UR) {
+    // Request PassInstrumentation from analysis manager, will use it to run
+    // instrumenting callbacks for the passes later.
+    // Passing all the Args into AM's getResult since here we know that they do
+    // match.
+    PassInstrumentation PI =
+        AM.template getResult<PassInstrumentationAnalysis>(InitialC, G);
+    PI.startPassManager(*this, InitialC);
+    auto PA = PreservedAnalyses::all();
+    for (int i = 0; i < Count; ++i) {
+      // Tell PassInstrumentation that we started a new iteration.
+      PI.startIteration(*this, i);
+
+      // Check the PassInstrumentation's BeforePass callbacks before running the
+      // pass, skip its execution completely if asked to (callback returns
+      // false).
+      if (!PI.runBeforePass(P, InitialC))
+        continue;
+      PA.intersect(P.run(InitialC, AM, G, UR));
+      PI.runAfterPass(P, InitialC);
+    }
+    PI.finishPassManager(*this, InitialC);
+    return PA;
+  }
+
+private:
+  int Count;
+  PassT P;
+};
+
 // Clear out the debug logging macro.
 #undef DEBUG_TYPE
 
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_CGSCCPASSMANAGER_H

include/llvm/IR/PassManager.h

public:
   /// Run all of the passes in this manager over the given unit of IR.
   /// ExtraArgs are passed to each pass.
   PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
                         ExtraArgTs... ExtraArgs) {
     PreservedAnalyses PA = PreservedAnalyses::all();
 
     // Request PassInstrumentation from analysis manager, will use it to run
     // instrumenting callbacks for the passes later.
-    // Here we use std::tuple wrapper over getResult which helps to extract
-    // AnalysisManager's arguments out of the whole ExtraArgs set.
     PassInstrumentation PI =
-        detail::getAnalysisResult<PassInstrumentationAnalysis>(
-            AM, IR, std::tuple<ExtraArgTs...>(ExtraArgs...));
+        AM.template getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);
     PI.startPassManager(*this, IR);
     if (DebugLogging)
       dbgs() << "Starting " << getTypeName<IRUnitT>() << " pass manager run.\n";
 
     for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
       auto *P = Passes[Idx].get();
       if (DebugLogging)
         dbgs() << "Running pass: " << P->name() << " on " << IR.getName()
PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
     return PreservedAnalyses::none();
   }
 };
 
 /// A utility pass template that simply runs another pass multiple times.
 ///
 /// This can be useful when debugging or testing passes. It also serves as an
 /// example of how to extend the pass manager in ways beyond composition.
-template <typename PassT>
-class RepeatedPass : public PassInfoMixin<RepeatedPass<PassT>> {
+
+template <typename PassT, typename AnalysisManagerT>
+class RepeatedPass
+    : public PassInfoMixin<RepeatedPass<PassT, AnalysisManagerT>> {
 public:
   RepeatedPass(int Count, PassT P) : Count(Count), P(std::move(P)) {}
 
-  template <typename IRUnitT, typename AnalysisManagerT, typename... Ts>
-  PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, Ts &&... Args) {
+  template <typename IRUnitT, typename... ExtraArgTs>
+  PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
+                        ExtraArgTs &&... Args) {
+    // This implementation assumes that arguments of the pass and analysis
+    // manager do match fully. You will have to partially specialize
+    // RepeatedPass for your own AnalysisManager if this assumption is broken.
+    static_assert(std::is_same<AnalysisManagerT,
+                               AnalysisManager<IRUnitT, ExtraArgTs...>>::value,
+                  "generic RepeatedPass::run assumes AnalysisManager takes the "
+                  "same Args");
 
     // Request PassInstrumentation from analysis manager, will use it to run
     // instrumenting callbacks for the passes later.
-    // Here we use std::tuple wrapper over getResult which helps to extract
-    // AnalysisManager's arguments out of the whole Args set.
+    // Passing all the Args into AM's getResult since here we know that they do
+    // match.
     PassInstrumentation PI =
-        detail::getAnalysisResult<PassInstrumentationAnalysis>(
-            AM, IR, std::tuple<Ts...>(Args...));
-
+        AM.template getResult<PassInstrumentationAnalysis>(IR, Args...);
     PI.startPassManager(*this, IR);
     auto PA = PreservedAnalyses::all();
     for (int i = 0; i < Count; ++i) {
       // Tell PassInstrumentation that we started a new iteration.
       PI.startIteration(*this, i);
 
       // Check the PassInstrumentation's BeforePass callbacks before running the
       // pass, skip its execution completely if asked to (callback returns
       // false).
       if (!PI.runBeforePass<IRUnitT>(P, IR))
         continue;
-      PA.intersect(P.run(IR, AM, std::forward<Ts>(Args)...));
+      PA.intersect(P.run(IR, AM, Args...));
       PI.runAfterPass(P, IR);
     }
     PI.finishPassManager(*this, IR);
     return PA;
   }
 
 private:
   int Count;
   PassT P;
 };
 
-template <typename PassT>
-RepeatedPass<PassT> createRepeatedPass(int Count, PassT P) {
-  return RepeatedPass<PassT>(Count, std::move(P));
+template <typename AnalysisManagerT, typename PassT>
+RepeatedPass<PassT, AnalysisManagerT> createRepeatedPass(int Count, PassT P) {
+  return RepeatedPass<PassT, AnalysisManagerT>(Count, std::move(P));
 }
 
 } // end namespace llvm
 
 #endif // LLVM_IR_PASSMANAGER_H

include/llvm/Transforms/Scalar/LoopPassManager.h

 
 public:
   PrintLoopPass();
   PrintLoopPass(raw_ostream &OS, const std::string &Banner = "");
 
   PreservedAnalyses run(Loop &L, LoopAnalysisManager &,
                         LoopStandardAnalysisResults &, LPMUpdater &);
 };
+
+/// A specialized version of RepeatedPass that handles LoopAnalysisManager
+/// interface.
+template <typename PassT>
+class RepeatedPass<PassT, LoopAnalysisManager>
+    : public PassInfoMixin<RepeatedPass<PassT, LoopAnalysisManager>> {
+public:
+  RepeatedPass(int Count, PassT P) : Count(Count), P(std::move(P)) {}
+
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &LU) {
+    // Request PassInstrumentation from analysis manager, will use it to run
+    // instrumenting callbacks for the passes later.
+    // Passing all the Args into AM's getResult since here we know that they do
+    // match.
+    PassInstrumentation PI =
+        AM.template getResult<PassInstrumentationAnalysis>(L, AR);
+    PI.startPassManager(*this, L);
+    auto PA = PreservedAnalyses::all();
+    for (int i = 0; i < Count; ++i) {
+      // Tell PassInstrumentation that we started a new iteration.
+      PI.startIteration(*this, i);
+
+      // Check the PassInstrumentation's BeforePass callbacks before running the
+      // pass, skip its execution completely if asked to (callback returns
+      // false).
+      if (!PI.runBeforePass(P, L))
+        continue;
+      PA.intersect(P.run(L, AM, AR, LU));
+      PI.runAfterPass(P, L);
+    }
+    PI.finishPassManager(*this, L);
+    return PA;
+  }
+
+private:
+  int Count;
+  PassT P;
+};
 }
 
 #endif // LLVM_TRANSFORMS_SCALAR_LOOPPASSMANAGER_H

lib/Passes/PassBuilder.cpp

if (Name == "function") {
       MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
       return true;
     }
     if (auto Count = parseRepeatPassName(Name)) {
       ModulePassManager NestedMPM(DebugLogging);
       if (!parseModulePassPipeline(NestedMPM, InnerPipeline, VerifyEachPass,
                                    DebugLogging))
         return false;
-      MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
+      MPM.addPass(createRepeatedPass<ModuleAnalysisManager>(
+          *Count, std::move(NestedMPM)));
       return true;
     }
 
     for (auto &C : ModulePipelineParsingCallbacks)
       if (C(Name, MPM, InnerPipeline))
         return true;
 
     // Normal passes can't have pipelines.
if (Name == "function") {
       CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
       return true;
     }
     if (auto Count = parseRepeatPassName(Name)) {
       CGSCCPassManager NestedCGPM(DebugLogging);
       if (!parseCGSCCPassPipeline(NestedCGPM, InnerPipeline, VerifyEachPass,
                                   DebugLogging))
         return false;
-      CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM)));
+      CGPM.addPass(createRepeatedPass<CGSCCAnalysisManager>(
+          *Count, std::move(NestedCGPM)));
       return true;
     }
     if (auto MaxRepetitions = parseDevirtPassName(Name)) {
       CGSCCPassManager NestedCGPM(DebugLogging);
       if (!parseCGSCCPassPipeline(NestedCGPM, InnerPipeline, VerifyEachPass,
                                   DebugLogging))
         return false;
       CGPM.addPass(
if (Name == "loop") {
           createFunctionToLoopPassAdaptor(std::move(LPM), DebugLogging));
       return true;
     }
     if (auto Count = parseRepeatPassName(Name)) {
       FunctionPassManager NestedFPM(DebugLogging);
       if (!parseFunctionPassPipeline(NestedFPM, InnerPipeline, VerifyEachPass,
                                      DebugLogging))
         return false;
-      FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
+      FPM.addPass(createRepeatedPass<FunctionAnalysisManager>(
+          *Count, std::move(NestedFPM)));
       return true;
     }
 
     for (auto &C : FunctionPipelineParsingCallbacks)
       if (C(Name, FPM, InnerPipeline))
         return true;
 
     // Normal passes can't have pipelines.
if (Name == "loop") {
       LPM.addPass(std::move(NestedLPM));
       return true;
     }
     if (auto Count = parseRepeatPassName(Name)) {
       LoopPassManager NestedLPM(DebugLogging);
       if (!parseLoopPassPipeline(NestedLPM, InnerPipeline, VerifyEachPass,
                                  DebugLogging))
         return false;
-      LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
+      LPM.addPass(createRepeatedPass<LoopAnalysisManager>(
+          *Count, std::move(NestedLPM)));
       return true;
     }
 
     for (auto &C : LoopPipelineParsingCallbacks)
       if (C(Name, LPM, InnerPipeline))
         return true;
 
     // Normal passes can't have pipelines.

unittests/IR/PassManagerTest.cpp

 
 private:
   friend AnalysisInfoMixin<CustomizedAnalysis>;
   static AnalysisKey Key;
 };
 
 AnalysisKey CustomizedAnalysis::Key;
 
+} // namespace
+
+namespace llvm {
+template <>
+PreservedAnalyses
+PassManager<Function, CustomizedAnalysisManager, int, int &>::run(
+    Function &IR, CustomizedAnalysisManager &AM, int I, int &O) {
+  PreservedAnalyses PA = PreservedAnalyses::all();
+
+  // Request PassInstrumentation from analysis manager, will use it to run
+  // instrumenting callbacks for the passes later.
+  PassInstrumentation PI =
+      AM.template getResult<PassInstrumentationAnalysis>(IR, I);
+  PI.startPassManager(*this, IR);
+  if (DebugLogging)
+    dbgs() << "Starting " << getTypeName<Function>() << " pass manager run.\n";
+
+  for (unsigned Idx = 0, Size = Passes.size(); Idx != Size; ++Idx) {
+    auto *P = Passes[Idx].get();
+    if (DebugLogging)
+      dbgs() << "Running pass: " << P->name() << " on " << IR.getName() << "\n";
+
+    // Check the PassInstrumentation's BeforePass callbacks before running the
+    // pass, skip its execution completely if asked to (callback returns
+    // false).
+    if (!PI.runBeforePass<Function>(*P, IR))
+      continue;
+
+    PreservedAnalyses PassPA = P->run(IR, AM, I, O);
+
+    // Call onto PassInstrumentation's AfterPass callbacks immediately after
+    // running the pass.
+    PI.runAfterPass<Function>(*P, IR);
+
+    // Update the analysis manager as each pass runs and potentially
+    // invalidates analyses.
+    AM.invalidate(IR, PassPA);
+
+    // Finally, intersect the preserved analyses to compute the aggregate
+    // preserved set for this pass manager.
+    PA.intersect(std::move(PassPA));
+
+    // FIXME: Historically, the pass managers all called the LLVM context's
+    // yield function here. We don't have a generic way to acquire the
+    // context and it isn't yet clear what the right pattern is for yielding
+    // in the new pass manager so it is currently omitted.
+    // IR.getContext().yield();
+  }
+
+  // Invalidation was handled after each pass in the above loop for the
+  // current unit of IR. Therefore, the remaining analysis results in the
+  // AnalysisManager are preserved. We mark this with a set so that we don't
+  // need to inspect each one individually.
+  PA.preserveSet<AllAnalysesOn<Function>>();
+
+  PI.finishPassManager(*this, IR);
+  if (DebugLogging)
+    dbgs() << "Finished " << getTypeName<Function>() << " pass manager run.\n";
+
+  return PA;
+}
+
+} // namespace llvm
+
+namespace {
 struct CustomizedPass : PassInfoMixin<CustomizedPass> {
   std::function<void(CustomizedAnalysis::Result &, int &)> Callback;
 
   template <typename CallbackT>
   CustomizedPass(CallbackT Callback) : Callback(Callback) {}
 
   PreservedAnalyses run(Function &F, CustomizedAnalysisManager &AM, int I,
                         int &O) {