[NewPM] Remove ModuleInlinerWrapperPass and directly add passes to PMs

[aeubanks]

Summary

ModuleInlinerWrapperPass is a unique pass in that it creates its own
pass manager and runs that. This causes unnecessary nesting. Besides
making some pipeline tests longer, it can also cause more invalidation
than necessary. At the top level ModulePassManager we can ignore the
returned PreservedAnalyses. But if there is a sub-ModulePassManager, the
outer ModulePassManager must invalidate based on the returned
PreservedAnalyses.

[aeubanks]

I'll update the pipeline tests if this looks good

llvm/include/llvm/Passes/PassBuilder.h

public:
   /// build them.
   ///
   /// \p Phase indicates the current ThinLTO phase.
   ModulePassManager buildModuleSimplificationPipeline(OptimizationLevel Level,
                                                       ThinOrFullLTOPhase Phase);
 
   /// Construct the module pipeline that performs inlining as well as
   /// the inlining-driven cleanups.
-  ModuleInlinerWrapperPass buildInlinerPipeline(OptimizationLevel Level,
-                                                ThinOrFullLTOPhase Phase);
+  ModulePassManager buildInlinerPipeline(OptimizationLevel Level,
 
   /// Construct the core LLVM module optimization pipeline.
   ///
   /// This pipeline focuses on optimizing the execution speed of the IR. It
   /// uses cost modeling and thresholds to balance code growth against runtime
   /// improvements. It includes vectorization and other information destroying
   /// transformations. It also cannot generally be run repeatedly on a module
   /// without potentially seriously regressing either runtime performance of

llvm/include/llvm/Transforms/IPO/Inliner.h

 
 private:
   InlineAdvisor &getAdvisor(const ModuleAnalysisManagerCGSCCProxy::Result &MAM,
                             FunctionAnalysisManager &FAM, Module &M);
   std::unique_ptr<InlineAdvisor> OwnedAdvisor;
   const bool OnlyMandatory;
 };
 
-/// Module pass, wrapping the inliner pass. This works in conjunction with the
+/// Create a ModulePassManager that revolves around the inliner. The
+/// NoInlinerCGPM should contain all passes that run after the inliner
 /// InlineAdvisorAnalysis to facilitate inlining decisions taking into account
-/// module-wide state, that need to keep track of inter-inliner pass runs, for
+/// module-wide state, that need to keep track of inter-inliner pass runs for
 /// a given module. An InlineAdvisor is configured and kept alive for the
 /// duration of the ModuleInlinerWrapperPass::run.
-class ModuleInlinerWrapperPass
-    : public PassInfoMixin<ModuleInlinerWrapperPass> {
-public:
-  ModuleInlinerWrapperPass(
-      InlineParams Params = getInlineParams(), bool Debugging = false,
-      bool MandatoryFirst = true,
+ModulePassManager
+createInlinerPipeline(CGSCCPassManager NoInlinerCGPM,
+                      InlineParams Params = getInlineParams(),
+                      bool DebugLogging = false, bool MandatoryFirst = true,
+                      InliningAdvisorMode Mode = InliningAdvisorMode::Default,
+                      unsigned MaxDevirtIterations = 0);
+ModulePassManager
+createInlinerPipeline(InlineParams Params = getInlineParams(),
+                      bool DebugLogging = false, bool MandatoryFirst = true,
                       InliningAdvisorMode Mode = InliningAdvisorMode::Default,
                       unsigned MaxDevirtIterations = 0);
-  ModuleInlinerWrapperPass(ModuleInlinerWrapperPass &&Arg) = default;
-
-  PreservedAnalyses run(Module &, ModuleAnalysisManager &);
-
-  /// Allow adding more CGSCC passes, besides inlining. This should be called
-  /// before run is called, as part of pass pipeline building.
-  CGSCCPassManager &getPM() { return PM; }
-
-  /// Allow adding module-level analyses benefiting the contained CGSCC passes.
-  template <class T> void addRequiredModuleAnalysis() {
-    MPM.addPass(RequireAnalysisPass<T, Module>());
-  }
 
-private:
-  const InlineParams Params;
-  const InliningAdvisorMode Mode;
-  const unsigned MaxDevirtIterations;
-  CGSCCPassManager PM;
-  ModulePassManager MPM;
-};
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_IPO_INLINER_H

llvm/lib/Passes/PassBuilder.cpp

if (!IsCS && !DisablePreInliner) {
 
     IP.DefaultThreshold = PreInlineThreshold;
 
     // FIXME: The hint threshold has the same value used by the regular inliner
     // when not optimzing for size. This should probably be lowered after
     // performance testing.
     // FIXME: this comment is cargo culted from the old pass manager, revisit).
     IP.HintThreshold = Level.isOptimizingForSize() ? PreInlineThreshold : 325;
-    ModuleInlinerWrapperPass MIWP(IP, DebugLogging);
-    CGSCCPassManager &CGPipeline = MIWP.getPM();
+    CGSCCPassManager CGPipeline(DebugLogging);
 
     FunctionPassManager FPM;
     FPM.addPass(SROA());
     FPM.addPass(EarlyCSEPass());    // Catch trivial redundancies.
     FPM.addPass(SimplifyCFGPass()); // Merge & remove basic blocks.
     FPM.addPass(InstCombinePass()); // Combine silly sequences.
     invokePeepholeEPCallbacks(FPM, Level);
 
     CGPipeline.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
 
-    MPM.addPass(std::move(MIWP));
+    MPM.addPass(createInlinerPipeline(std::move(CGPipeline), IP, DebugLogging));
 
     // Delete anything that is now dead to make sure that we don't instrument
     // dead code. Instrumentation can end up keeping dead code around and
     // dramatically increase code size.
     MPM.addPass(GlobalDCEPass());
   }
 
   if (!RunProfileGen) {
void PassBuilder::addPGOInstrPassesForO0(ModulePassManager &MPM,
   MPM.addPass(InstrProfiling(Options, IsCS));
 }
 
 static InlineParams
 getInlineParamsFromOptLevel(PassBuilder::OptimizationLevel Level) {
   return getInlineParams(Level.getSpeedupLevel(), Level.getSizeLevel());
 }
 
-ModuleInlinerWrapperPass
-PassBuilder::buildInlinerPipeline(OptimizationLevel Level,
+ModulePassManager PassBuilder::buildInlinerPipeline(OptimizationLevel Level,
                                                     ThinOrFullLTOPhase Phase) {
   InlineParams IP = getInlineParamsFromOptLevel(Level);
   if (Phase == ThinOrFullLTOPhase::ThinLTOPreLink && PGOOpt &&
       PGOOpt->Action == PGOOptions::SampleUse)
     IP.HotCallSiteThreshold = 0;
 
   if (PGOOpt)
     IP.EnableDeferral = EnablePGOInlineDeferral;
 
-  ModuleInlinerWrapperPass MIWP(IP, DebugLogging,
-                                PerformMandatoryInliningsFirst,
-                                UseInlineAdvisor, MaxDevirtIterations);
+  ModulePassManager MPM(DebugLogging);
 
   // Require the GlobalsAA analysis for the module so we can query it within
   // the CGSCC pipeline.
-  MIWP.addRequiredModuleAnalysis<GlobalsAA>();
+  MPM.addPass(RequireAnalysisPass<GlobalsAA, Module>());
 
   // Require the ProfileSummaryAnalysis for the module so we can query it within
   // the inliner pass.
-  MIWP.addRequiredModuleAnalysis<ProfileSummaryAnalysis>();
+  MPM.addPass(RequireAnalysisPass<ProfileSummaryAnalysis, Module>());
 
   // Now begin the main postorder CGSCC pipeline.
   // FIXME: The current CGSCC pipeline has its origins in the legacy pass
   // manager and trying to emulate its precise behavior. Much of this doesn't
   // make a lot of sense and we should revisit the core CGSCC structure.
-  CGSCCPassManager &MainCGPipeline = MIWP.getPM();
+  CGSCCPassManager MainCGPipeline(DebugLogging);
 
   // Note: historically, the PruneEH pass was run first to deduce nounwind and
   // generally clean up exception handling overhead. It isn't clear this is
   // valuable as the inliner doesn't currently care whether it is inlining an
   // invoke or a call.
 
   if (AttributorRun & AttributorRunOption::CGSCC)
     MainCGPipeline.addPass(AttributorCGSCCPass());
ModulePassManager PassBuilder::buildInlinerPipeline(OptimizationLevel Level,
   for (auto &C : CGSCCOptimizerLateEPCallbacks)
     C(MainCGPipeline, Level);
 
   // Lastly, add the core function simplification pipeline nested inside the
   // CGSCC walk.
   MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
       buildFunctionSimplificationPipeline(Level, Phase)));
 
-  return MIWP;
+  MPM.addPass(createInlinerPipeline(std::move(MainCGPipeline), IP, DebugLogging,
+                                    PerformMandatoryInliningsFirst,
+                                    UseInlineAdvisor, MaxDevirtIterations));
+
+  return MPM;
 }
 
 ModulePassManager
 PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
                                                ThinOrFullLTOPhase Phase) {
   ModulePassManager MPM(DebugLogging);
 
   // Place pseudo probe instrumentation as the first pass of the pipeline to
PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level,
 
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(PeepholeFPM)));
 
   // Note: historically, the PruneEH pass was run first to deduce nounwind and
   // generally clean up exception handling overhead. It isn't clear this is
   // valuable as the inliner doesn't currently care whether it is inlining an
   // invoke or a call.
   // Run the inliner now.
-  MPM.addPass(ModuleInlinerWrapperPass(getInlineParamsFromOptLevel(Level),
-                                       DebugLogging));
+  MPM.addPass(createInlinerPipeline(
+      CGSCCPassManager(), getInlineParamsFromOptLevel(Level), DebugLogging));
 
   // Optimize globals again after we ran the inliner.
   MPM.addPass(GlobalOptPass());
 
   // Garbage collect dead functions.
   // FIXME: Add ArgumentPromotion pass after once it's ported.
   MPM.addPass(GlobalDCEPass());
 

llvm/lib/Passes/PassRegistry.def

 MODULE_PASS("function-import", FunctionImportPass())
 MODULE_PASS("globaldce", GlobalDCEPass())
 MODULE_PASS("globalopt", GlobalOptPass())
 MODULE_PASS("globalsplit", GlobalSplitPass())
 MODULE_PASS("hotcoldsplit", HotColdSplittingPass())
 MODULE_PASS("hwasan", HWAddressSanitizerPass(false, false))
 MODULE_PASS("khwasan", HWAddressSanitizerPass(true, true))
 MODULE_PASS("inferattrs", InferFunctionAttrsPass())
-MODULE_PASS("inliner-wrapper", ModuleInlinerWrapperPass())
-MODULE_PASS("inliner-wrapper-no-mandatory-first", ModuleInlinerWrapperPass(
+MODULE_PASS("inliner-wrapper", createInlinerPipeline())
+MODULE_PASS("inliner-wrapper-no-mandatory-first", createInlinerPipeline(
   getInlineParams(),
   DebugLogging,
   false))
 MODULE_PASS("insert-gcov-profiling", GCOVProfilerPass())
 MODULE_PASS("instrorderfile", InstrOrderFilePass())
 MODULE_PASS("instrprof", InstrProfiling())
 MODULE_PASS("internalize", InternalizePass())
 MODULE_PASS("invalidate<all>", InvalidateAllAnalysesPass())

llvm/lib/Transforms/IPO/Inliner.cpp

PreservedAnalyses InlinerPass::run(LazyCallGraph::SCC &InitialC,
 
   // Even if we change the IR, we update the core CGSCC data structures and so
   // can preserve the proxy to the function analysis manager.
   PreservedAnalyses PA;
   PA.preserve<FunctionAnalysisManagerCGSCCProxy>();
   return PA;
 }
 
-ModuleInlinerWrapperPass::ModuleInlinerWrapperPass(InlineParams Params,
-                                                   bool Debugging,
-                                                   bool MandatoryFirst,
-                                                   InliningAdvisorMode Mode,
-                                                   unsigned MaxDevirtIterations)
-    : Params(Params), Mode(Mode), MaxDevirtIterations(MaxDevirtIterations),
-      PM(Debugging), MPM(Debugging) {
-  // Run the inliner first. The theory is that we are walking bottom-up and so
-  // the callees have already been fully optimized, and we want to inline them
-  // into the callers so that our optimizations can reflect that.
-  // For PreLinkThinLTO pass, we disable hot-caller heuristic for sample PGO
-  // because it makes profile annotation in the backend inaccurate.
-  if (MandatoryFirst)
-    PM.addPass(InlinerPass(/*OnlyMandatory*/ true));
-  PM.addPass(InlinerPass());
-}
-
-PreservedAnalyses ModuleInlinerWrapperPass::run(Module &M,
-                                                ModuleAnalysisManager &MAM) {
-  auto &IAA = MAM.getResult<InlineAdvisorAnalysis>(M);
+struct CreateInlineAdvisorPass : PassInfoMixin<CreateInlineAdvisorPass> {
+  CreateInlineAdvisorPass(InlineParams Params, InliningAdvisorMode Mode)
+      : Params(Params), Mode(Mode) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
+    auto &IAA = AM.getResult<InlineAdvisorAnalysis>(M);
     if (!IAA.tryCreate(Params, Mode, CGSCCInlineReplayFile)) {
       M.getContext().emitError(
           "Could not setup Inlining Advisor for the requested "
           "mode and/or options");
+    }
     return PreservedAnalyses::all();
   }
 
+private:
+  InlineParams Params;
+  InliningAdvisorMode Mode;
+};
+
+struct ClearInlineAdvisorPass : PassInfoMixin<ClearInlineAdvisorPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM) {
+    auto *IAA = AM.getCachedResult<InlineAdvisorAnalysis>(M);
+    assert(IAA && "InlineAdvisorAnalysis should not be invalidated");
+    IAA->clear();
+    return PreservedAnalyses::all();
+  }
+};
+
+ModulePassManager llvm::createInlinerPipeline(CGSCCPassManager NoInlinerCGPM,
+                                              InlineParams Params,
+                                              bool DebugLogging,
+                                              bool MandatoryFirst,
+                                              InliningAdvisorMode Mode,
+                                              unsigned MaxDevirtIterations) {
+  ModulePassManager MPM(DebugLogging);
+
+  MPM.addPass(CreateInlineAdvisorPass(Params, Mode));
+
+  CGSCCPassManager CGPM(DebugLogging);
+  if (MandatoryFirst)
+    CGPM.addPass(InlinerPass(/*OnlyMandatory*/ true));
+  CGPM.addPass(InlinerPass());
+  CGPM.addPass(std::move(NoInlinerCGPM));
+
   // We wrap the CGSCC pipeline in a devirtualization repeater. This will try
   // to detect when we devirtualize indirect calls and iterate the SCC passes
   // in that case to try and catch knock-on inlining or function attrs
   // opportunities. Then we add it to the module pipeline by walking the SCCs
   // in postorder (or bottom-up).
   // If MaxDevirtIterations is 0, we just don't use the devirtualization
   // wrapper.
   if (MaxDevirtIterations == 0)
-    MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(PM)));
+    MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
   else
     MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(
-        createDevirtSCCRepeatedPass(std::move(PM), MaxDevirtIterations)));
-  auto Ret = MPM.run(M, MAM);
+        createDevirtSCCRepeatedPass(std::move(CGPM), MaxDevirtIterations)));
 
-  IAA.clear();
-  return Ret;
+  MPM.addPass(ClearInlineAdvisorPass());
+
+  return MPM;
+}
+
+ModulePassManager llvm::createInlinerPipeline(InlineParams Params,
+                                              bool DebugLogging,
+                                              bool MandatoryFirst,
+                                              InliningAdvisorMode Mode,
+                                              unsigned MaxDevirtIterations) {
+  return createInlinerPipeline(CGSCCPassManager(DebugLogging), Params,
+                               DebugLogging, MandatoryFirst, Mode,
+                               MaxDevirtIterations);
 }