[Passes] Add PassBuilderContext

[nikic]

Summary

Using the NewPM requires a whole bunch of magic incantations -- you need to declare all the different pass managers, register all analysis passes and cross-register the proxies. This boilerplate always looks the same.

This patch adds a PassBuilderContext, which stores both the PassBuilder and the various analysis managers, and exposes a method to perform the analysis registration. This is more convenient for most uses of PassBuilder that aren't doing anything complicated.

[nikic]

llvm/include/llvm/Passes/PassBuilder.h

712

Not entirely sure whether PassInstrumentationCallbacks should be part of this or not. This is mostly used in conjunction with StandardInstrumentations, so maybe it doesn't belong here.

[aeubanks]

I've thought about doing this a couple of times, thanks for bring this up

I've had the thought that perhaps PassInstrumentation plus all the analysis managers should just be in PassBuilder itself (instead of a separate wrapper around PassBuilder), WDYT?

llvm/include/llvm/Passes/PassBuilder.h

712

I think it does belong here, and I'd even by default add StandardInstrumentations.

there's the issue that optnone handling is done in StandardInstrumentations, which honestly is pretty bad since users don't have to register StandardInstrumentations (that's my bad from when I just joined). maybe PassInstrumentation should by default register StandardInstrumentations

llvm/include/llvm/Passes/PassBuilder.h

if (PipelineName != AnalysisName)
       return false;
     PM.addPass(RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
                                    ExtraArgTs...>());
     return true;
   }
 
   return false;
 }
+
+/// Context storing PassBuilder, PassInstrumentationCallbacks and
+/// AnalysisManagers.
+struct PassBuilderContext {
+  PassInstrumentationCallbacks PIC;
+  PassBuilder PB;
+  LoopAnalysisManager LAM;
+  FunctionAnalysisManager FAM;
+  CGSCCAnalysisManager CGAM;
+  ModuleAnalysisManager MAM;
+
+  PassBuilderContext(TargetMachine *TM = nullptr,
+                     PipelineTuningOptions PTO = PipelineTuningOptions(),
+                     std::optional<PGOOptions> PGOOpts = std::nullopt)
+      : PB(TM, PTO, PGOOpts, &PIC) {}
+
+  /// In order to override any default analyses (e.g. TLI or the AA pipeline),
+  /// register the passes before calling this method.
+  void registerAnalyses() {
+    PB.registerLoopAnalyses(LAM);
+    PB.registerFunctionAnalyses(FAM);
+    PB.registerCGSCCAnalyses(CGAM);
+    PB.registerModuleAnalyses(MAM);
+    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  }
+};
+
 }
 
 #endif

llvm/lib/LTO/LTOBackend.cpp

PGOOpt = PGOOptions(Conf.CSIRProfile, "", Conf.ProfileRemapping, FS,
                         Conf.AddFSDiscriminator);
     NoPGOWarnMismatch = !Conf.PGOWarnMismatch;
   } else if (Conf.AddFSDiscriminator) {
     PGOOpt = PGOOptions("", "", "", nullptr, PGOOptions::NoAction,
                         PGOOptions::NoCSAction, true);
   }
   TM->setPGOOption(PGOOpt);
 
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
-
-  PassInstrumentationCallbacks PIC;
+  PassBuilderContext PBC(TM, Conf.PTO, PGOOpt);
   StandardInstrumentations SI(Mod.getContext(), Conf.DebugPassManager);
-  SI.registerCallbacks(PIC, &MAM);
-  PassBuilder PB(TM, Conf.PTO, PGOOpt, &PIC);
+  SI.registerCallbacks(PBC.PIC, &PBC.MAM);
 
+  PassBuilder &PB = PBC.PB;
   RegisterPassPlugins(Conf.PassPlugins, PB);
 
   std::unique_ptr<TargetLibraryInfoImpl> TLII(
       new TargetLibraryInfoImpl(Triple(TM->getTargetTriple())));
   if (Conf.Freestanding)
     TLII->disableAllFunctions();
-  FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
+  PBC.FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
 
   // Parse a custom AA pipeline if asked to.
   if (!Conf.AAPipeline.empty()) {
     AAManager AA;
     if (auto Err = PB.parseAAPipeline(AA, Conf.AAPipeline)) {
       report_fatal_error(Twine("unable to parse AA pipeline description '") +
                          Conf.AAPipeline + "': " + toString(std::move(Err)));
     }
     // Register the AA manager first so that our version is the one used.
-    FAM.registerPass([&] { return std::move(AA); });
+    PBC.FAM.registerPass([&] { return std::move(AA); });
   }
 
-  // Register all the basic analyses with the managers.
-  PB.registerModuleAnalyses(MAM);
-  PB.registerCGSCCAnalyses(CGAM);
-  PB.registerFunctionAnalyses(FAM);
-  PB.registerLoopAnalyses(LAM);
-  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PBC.registerAnalyses();
 
   ModulePassManager MPM;
 
   if (!Conf.DisableVerify)
     MPM.addPass(VerifierPass());
 
   OptimizationLevel OL;
 
if (!Conf.OptPipeline.empty()) {
     MPM.addPass(PB.buildThinLTODefaultPipeline(OL, ImportSummary));
   } else {
     MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
   }
 
   if (!Conf.DisableVerify)
     MPM.addPass(VerifierPass());
 
-  MPM.run(Mod, MAM);
+  MPM.run(Mod, PBC.MAM);
 }
 
 bool lto::opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
               bool IsThinLTO, ModuleSummaryIndex *ExportSummary,
               const ModuleSummaryIndex *ImportSummary,
               const std::vector<uint8_t> &CmdArgs) {
   if (EmbedBitcode == LTOBitcodeEmbedding::EmbedPostMergePreOptimized) {
     // FIXME: the motivation for capturing post-merge bitcode and command line

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
   // Verify again after cross-importing.
   verifyLoadedModule(TheModule);
 }
 
 static void optimizeModule(Module &TheModule, TargetMachine &TM,
                            unsigned OptLevel, bool Freestanding,
                            bool DebugPassManager, ModuleSummaryIndex *Index) {
   std::optional<PGOOptions> PGOOpt;
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
 
-  PassInstrumentationCallbacks PIC;
-  StandardInstrumentations SI(TheModule.getContext(), DebugPassManager);
-  SI.registerCallbacks(PIC, &MAM);
   PipelineTuningOptions PTO;
   PTO.LoopVectorization = true;
   PTO.SLPVectorization = true;
-  PassBuilder PB(&TM, PTO, PGOOpt, &PIC);
+  PassBuilderContext PBC(&TM, PTO, PGOOpt);
+  StandardInstrumentations SI(TheModule.getContext(), DebugPassManager);
+  SI.registerCallbacks(PBC.PIC, &PBC.MAM);
 
   std::unique_ptr<TargetLibraryInfoImpl> TLII(
       new TargetLibraryInfoImpl(Triple(TM.getTargetTriple())));
   if (Freestanding)
     TLII->disableAllFunctions();
-  FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
+  PBC.FAM.registerPass([&] { return TargetLibraryAnalysis(*TLII); });
 
   // Register all the basic analyses with the managers.
-  PB.registerModuleAnalyses(MAM);
-  PB.registerCGSCCAnalyses(CGAM);
-  PB.registerFunctionAnalyses(FAM);
-  PB.registerLoopAnalyses(LAM);
-  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PBC.registerAnalyses();
 
   ModulePassManager MPM;
 
   OptimizationLevel OL;
 
   switch (OptLevel) {
   default:
     llvm_unreachable("Invalid optimization level");
   case 0:
     OL = OptimizationLevel::O0;
     break;
   case 1:
     OL = OptimizationLevel::O1;
     break;
   case 2:
     OL = OptimizationLevel::O2;
     break;
   case 3:
     OL = OptimizationLevel::O3;
     break;
   }
 
-  MPM.addPass(PB.buildThinLTODefaultPipeline(OL, Index));
+  MPM.addPass(PBC.PB.buildThinLTODefaultPipeline(OL, Index));
 
-  MPM.run(TheModule, MAM);
+  MPM.run(TheModule, PBC.MAM);
 }
 
 static void
 addUsedSymbolToPreservedGUID(const lto::InputFile &File,
                              DenseSet<GlobalValue::GUID> &PreservedGUID) {
   for (const auto &Sym : File.symbols()) {
     if (Sym.isUsed())
       PreservedGUID.insert(GlobalValue::getGUID(Sym.getIRName()));

llvm/lib/Passes/PassBuilderBindings.cpp

LLVMErrorRef LLVMRunPasses(LLVMModuleRef M, const char *Passes,
                            LLVMTargetMachineRef TM,
                            LLVMPassBuilderOptionsRef Options) {
   TargetMachine *Machine = unwrap(TM);
   LLVMPassBuilderOptions *PassOpts = unwrap(Options);
   bool Debug = PassOpts->DebugLogging;
   bool VerifyEach = PassOpts->VerifyEach;
 
   Module *Mod = unwrap(M);
-  PassInstrumentationCallbacks PIC;
-  PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC);
-
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
-  PB.registerLoopAnalyses(LAM);
-  PB.registerFunctionAnalyses(FAM);
-  PB.registerCGSCCAnalyses(CGAM);
-  PB.registerModuleAnalyses(MAM);
-  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
-
+  PassBuilderContext PBC(Machine, PassOpts->PTO);
   StandardInstrumentations SI(Mod->getContext(), Debug, VerifyEach);
-  SI.registerCallbacks(PIC, &MAM);
+  SI.registerCallbacks(PBC.PIC, &PBC.MAM);
+  PBC.registerAnalyses();
+
   ModulePassManager MPM;
-  if (VerifyEach) {
+  if (VerifyEach)
     MPM.addPass(VerifierPass());
-  }
-  if (auto Err = PB.parsePassPipeline(MPM, Passes)) {
+  if (auto Err = PBC.PB.parsePassPipeline(MPM, Passes))
     return wrap(std::move(Err));
-  }
 
-  MPM.run(*Mod, MAM);
+  MPM.run(*Mod, PBC.MAM);
   return LLVMErrorSuccess;
 }
 
 LLVMPassBuilderOptionsRef LLVMCreatePassBuilderOptions() {
   return wrap(new LLVMPassBuilderOptions());
 }
 
 void LLVMPassBuilderOptionsSetVerifyEach(LLVMPassBuilderOptionsRef Options,

llvm/tools/llvm-extract/llvm-extract.cpp

if (!DeleteFn) {
     for (auto &F : *M) {
       if (!GVSet.count(&F))
         Materialize(F);
     }
   }
 
   {
     std::vector<GlobalValue *> Gvs(GVs.begin(), GVs.end());
-    LoopAnalysisManager LAM;
-    FunctionAnalysisManager FAM;
-    CGSCCAnalysisManager CGAM;
-    ModuleAnalysisManager MAM;
-
-    PassBuilder PB;
-
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    PassBuilderContext PBC;
+    PBC.registerAnalyses();
 
     ModulePassManager PM;
     PM.addPass(ExtractGVPass(Gvs, DeleteFn, KeepConstInit));
-    PM.run(*M, MAM);
+    PM.run(*M, PBC.MAM);
 
     // Now that we have all the GVs we want, mark the module as fully
     // materialized.
     // FIXME: should the GVExtractionPass handle this?
     ExitOnErr(M->materializeAll());
   }
 
   // Extract the specified basic blocks from the module and erase the existing
for (auto &P : BBMap) {
                  << "'!\n";
           return 1;
         }
         BBs.push_back(&*Res);
       }
       GroupOfBBs.push_back(BBs);
     }
 
-    LoopAnalysisManager LAM;
-    FunctionAnalysisManager FAM;
-    CGSCCAnalysisManager CGAM;
-    ModuleAnalysisManager MAM;
-
-    PassBuilder PB;
-
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    PassBuilderContext PBC;
+    PBC.registerAnalyses();
 
     ModulePassManager PM;
     PM.addPass(BlockExtractorPass(std::move(GroupOfBBs), true));
-    PM.run(*M, MAM);
+    PM.run(*M, PBC.MAM);
   }
 
   // In addition to deleting all other functions, we also want to spiff it
   // up a little bit.  Do this now.
 
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
-
-  PassBuilder PB;
-
-  PB.registerModuleAnalyses(MAM);
-  PB.registerCGSCCAnalyses(CGAM);
-  PB.registerFunctionAnalyses(FAM);
-  PB.registerLoopAnalyses(LAM);
-  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PassBuilderContext PBC;
+  PBC.registerAnalyses();
 
   ModulePassManager PM;
   if (!DeleteFn)
     PM.addPass(GlobalDCEPass());
   PM.addPass(StripDeadDebugInfoPass());
   PM.addPass(StripDeadPrototypesPass());
 
   std::error_code EC;
   ToolOutputFile Out(OutputFilename, EC, sys::fs::OF_None);
   if (EC) {
     errs() << EC.message() << '\n';
     return 1;
   }
 
   if (OutputAssembly)
     PM.addPass(PrintModulePass(Out.os(), "", PreserveAssemblyUseListOrder));
   else if (Force || !CheckBitcodeOutputToConsole(Out.os()))
     PM.addPass(BitcodeWriterPass(Out.os(), PreserveBitcodeUseListOrder));
 
-  PM.run(*M, MAM);
+  PM.run(*M, PBC.MAM);
 
   // Declare success.
   Out.keep();
 
   return 0;
 }

llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   M->setTargetTriple(TM->getTargetTriple().normalize());
   M->setDataLayout(TM->createDataLayout());
   codegen::setFunctionAttributes(TM->getTargetCPU(),
                                  TM->getTargetFeatureString(), *M);
 
   // Create pass pipeline
   //
 
-  PassBuilder PB(TM.get());
+  PassBuilderContext PBC(TM.get());
+  PBC.registerAnalyses();
 
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
   ModulePassManager MPM;
-  ModuleAnalysisManager MAM;
-
-  PB.registerModuleAnalyses(MAM);
-  PB.registerCGSCCAnalyses(CGAM);
-  PB.registerFunctionAnalyses(FAM);
-  PB.registerLoopAnalyses(LAM);
-  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
-
-  auto Err = PB.parsePassPipeline(MPM, PassPipeline);
+  auto Err = PBC.PB.parsePassPipeline(MPM, PassPipeline);
   assert(!Err && "Should have been checked during fuzzer initialization");
   // Only fail with assert above, otherwise ignore the parsing error.
   consumeError(std::move(Err));
 
   // Run passes which we need to test
   //
 
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 
   // Check that passes resulted in a correct code
   if (verifyModule(*M, &errs())) {
     errs() << "Transformation resulted in an invalid module\n";
     abort();
   }
 
   return 0;

llvm/tools/llvm-reduce/ReducerWorkItem.cpp

if (!LI || !MOrErr) {
     exit(1);
   }
   LTOInfo = std::make_unique<BitcodeLTOInfo>(*LI);
   M = std::move(MOrErr.get());
 }
 
 void ReducerWorkItem::writeBitcode(raw_ostream &OutStream) const {
   if (LTOInfo && LTOInfo->IsThinLTO && LTOInfo->EnableSplitLTOUnit) {
-    PassBuilder PB;
-    LoopAnalysisManager LAM;
-    FunctionAnalysisManager FAM;
-    CGSCCAnalysisManager CGAM;
-    ModuleAnalysisManager MAM;
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    PassBuilderContext PBC;
+    PBC.registerAnalyses();
     ModulePassManager MPM;
     MPM.addPass(ThinLTOBitcodeWriterPass(OutStream, nullptr));
-    MPM.run(*M, MAM);
+    MPM.run(*M, PBC.MAM);
   } else {
     std::unique_ptr<ModuleSummaryIndex> Index;
     if (LTOInfo && LTOInfo->HasSummary) {
       ProfileSummaryInfo PSI(*M);
       Index = std::make_unique<ModuleSummaryIndex>(
           buildModuleSummaryIndex(*M, nullptr, &PSI));
     }
     WriteBitcodeToFile(getModule(), OutStream, Index.get());

llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp

static cl::opt<std::string> PassPipeline(
     "ir-passes",
     cl::desc("A textual description of the pass pipeline, same as "
              "what's passed to `opt -passes`."),
     cl::init("function(sroa,instcombine,gvn,simplifycfg,infer-address-spaces)"),
     cl::cat(LLVMReduceOptions));
 
 static void runPasses(Oracle &O, ReducerWorkItem &WorkItem) {
   Module &Program = WorkItem.getModule();
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
-
-  PassInstrumentationCallbacks PIC;
-  PIC.registerShouldRunOptionalPassCallback(
+  PassBuilderContext PBC;
+  PBC.PIC.registerShouldRunOptionalPassCallback(
       [&](StringRef, Any) { return !O.shouldKeep(); });
-  PassBuilder PB(nullptr, PipelineTuningOptions(), std::nullopt, &PIC);
-
-  PB.registerModuleAnalyses(MAM);
-  PB.registerCGSCCAnalyses(CGAM);
-  PB.registerFunctionAnalyses(FAM);
-  PB.registerLoopAnalyses(LAM);
-  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PBC.registerAnalyses();
 
   ModulePassManager MPM;
-  if (auto Err = PB.parsePassPipeline(MPM, PassPipeline)) {
+  if (auto Err = PBC.PB.parsePassPipeline(MPM, PassPipeline)) {
     errs() << toString(std::move(Err)) << "\n";
     report_fatal_error("Error constructing pass pipeline");
   }
-  MPM.run(Program, MAM);
+  MPM.run(Program, PBC.MAM);
 }
 
 void llvm::runIRPassesDeltaPass(TestRunner &Test) {
   runDeltaPass(Test, runPasses, "Running passes");
 }

llvm/unittests/Analysis/PluginInlineAdvisorAnalysisTest.cpp

static InlineAdvisor *fooOnlyFactory(Module &M, FunctionAnalysisManager &FAM,
   return new FooOnlyInlineAdvisor(M, FAM, Params, IC);
 }
 
 struct CompilerInstance {
   LLVMContext Ctx;
   ModulePassManager MPM;
   InlineParams IP;
 
-  PassBuilder PB;
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
+  PassBuilderContext PBC;
 
   SMDiagnostic Error;
 
   // connect the plugin to our compiler instance
   void setupPlugin() {
     auto PluginPath = libPath();
     ASSERT_NE("", PluginPath);
     Expected<PassPlugin> Plugin = PassPlugin::Load(PluginPath);
     ASSERT_TRUE(!!Plugin) << "Plugin path: " << PluginPath;
-    Plugin->registerPassBuilderCallbacks(PB);
-    ASSERT_THAT_ERROR(PB.parsePassPipeline(MPM, "dynamic-inline-advisor"),
+    Plugin->registerPassBuilderCallbacks(PBC.PB);
+    ASSERT_THAT_ERROR(PBC.PB.parsePassPipeline(MPM, "dynamic-inline-advisor"),
                       Succeeded());
   }
 
   // connect the FooOnlyInlineAdvisor to our compiler instance
   void setupFooOnly() {
-    MAM.registerPass(
+    PBC.MAM.registerPass(
         [&] { return PluginInlineAdvisorAnalysis(fooOnlyFactory); });
   }
 
   CompilerInstance() {
     IP = getInlineParams(3, 0);
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    PBC.registerAnalyses();
     MPM.addPass(ModuleInlinerPass(IP, InliningAdvisorMode::Default,
                                   ThinOrFullLTOPhase::None));
   }
 
   ~CompilerInstance() {
     // Reset the static variable that tracks if the plugin has been registered.
     // This is needed to allow the test to run multiple times.
     PluginInlineAdvisorAnalysis::HasBeenRegistered = false;
   }
 
   std::string output;
   std::unique_ptr<Module> outputM;
 
   // run with the default inliner
   auto run_default(StringRef IR) {
     PluginInlineAdvisorAnalysis::HasBeenRegistered = false;
     outputM = parseAssemblyString(IR, Error, Ctx);
-    MPM.run(*outputM, MAM);
+    MPM.run(*outputM, PBC.MAM);
     ASSERT_TRUE(outputM);
     output.clear();
     raw_string_ostream o_stream{output};
     outputM->print(o_stream, nullptr);
     ASSERT_TRUE(true);
   }
 
   // run with the dnamic inliner
   auto run_dynamic(StringRef IR) {
     // note typically the constructor for the DynamicInlineAdvisorAnalysis
     // will automatically set this to true, we controll it here only to
     // altenate between the default and dynamic inliner in our test
     PluginInlineAdvisorAnalysis::HasBeenRegistered = true;
     outputM = parseAssemblyString(IR, Error, Ctx);
-    MPM.run(*outputM, MAM);
+    MPM.run(*outputM, PBC.MAM);
     ASSERT_TRUE(outputM);
     output.clear();
     raw_string_ostream o_stream{output};
     outputM->print(o_stream, nullptr);
     ASSERT_TRUE(true);
   }
 };
 

llvm/unittests/Analysis/PluginInlineOrderAnalysisTest.cpp

std::string libPath(const std::string Name = "InlineOrderPlugin") {
   return std::string(Buf.str());
 }
 
 struct CompilerInstance {
   LLVMContext Ctx;
   ModulePassManager MPM;
   InlineParams IP;
 
-  PassBuilder PB;
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
+  PassBuilderContext PBC;
 
   SMDiagnostic Error;
 
   // Connect the plugin to our compiler instance.
   void setupPlugin() {
     auto PluginPath = libPath();
     ASSERT_NE("", PluginPath);
     Expected<PassPlugin> Plugin = PassPlugin::Load(PluginPath);
     ASSERT_TRUE(!!Plugin) << "Plugin path: " << PluginPath;
-    Plugin->registerPassBuilderCallbacks(PB);
+    Plugin->registerPassBuilderCallbacks(PBC.PB);
   }
 
   CompilerInstance() {
     IP = getInlineParams(3, 0);
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    PBC.registerAnalyses();
     MPM.addPass(ModuleInlinerPass(IP, InliningAdvisorMode::Default,
                                   ThinOrFullLTOPhase::None));
   }
 
   ~CompilerInstance() {
     // Reset the static variable that tracks if the plugin has been registered.
     // This is needed to allow the test to run multiple times.
     PluginInlineOrderAnalysis::unregister();
   }
 
   std::string Output;
   std::unique_ptr<Module> OutputM;
 
   // Run with the dynamic inline order.
   auto run(StringRef IR) {
     OutputM = parseAssemblyString(IR, Error, Ctx);
-    MPM.run(*OutputM, MAM);
+    MPM.run(*OutputM, PBC.MAM);
     ASSERT_TRUE(OutputM);
     Output.clear();
     raw_string_ostream OStream{Output};
     OutputM->print(OStream, nullptr);
     ASSERT_TRUE(true);
   }
 };
 

llvm/unittests/Transforms/Coroutines/ExtraRematTest.cpp

 #include "llvm/Transforms/Coroutines/CoroSplit.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 struct ExtraRematTest : public testing::Test {
-  LLVMContext Ctx;
   ModulePassManager MPM;
-  PassBuilder PB;
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
+  PassBuilderContext PBC;
   LLVMContext Context;
   std::unique_ptr<Module> M;
 
   ExtraRematTest() {
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    PBC.registerAnalyses();
   }
 
   BasicBlock *getBasicBlockByName(Function *F, StringRef Name) const {
     for (BasicBlock &BB : *F) {
       if (BB.getName() == Name)
         return &BB;
     }
     return nullptr;

 TEST_F(ExtraRematTest, TestCoroRematDefault) {
   ParseAssembly(Text);
 
   ASSERT_TRUE(M);
 
   CGSCCPassManager CGPM;
   CGPM.addPass(CoroSplitPass());
   MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 
   // Verify that extra rematerializable instruction has been rematerialized
   Function *F = M->getFunction("f.resume");
   ASSERT_TRUE(F) << "could not find split function f.resume";
 
   BasicBlock *Resume1 = getBasicBlockByName(F, "resume1");
   ASSERT_TRUE(Resume1)
       << "could not find expected BB resume1 in split function";
 
   // With default materialization the intrinsic should not have been
   // rematerialized
   CallInst *CI = getCallByName(Resume1, "should.remat");
   ASSERT_FALSE(CI);
 }
 
 TEST_F(ExtraRematTest, TestCoroRematWithCallback) {
   ParseAssembly(Text);
 
   ASSERT_TRUE(M);
 
   CGSCCPassManager CGPM;
   CGPM.addPass(
       CoroSplitPass(std::function<bool(Instruction &)>(ExtraMaterializable)));
   MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 
   // Verify that extra rematerializable instruction has been rematerialized
   Function *F = M->getFunction("f.resume");
   ASSERT_TRUE(F) << "could not find split function f.resume";
 
   BasicBlock *Resume1 = getBasicBlockByName(F, "resume1");
   ASSERT_TRUE(Resume1)
       << "could not find expected BB resume1 in split function";
 
   // With callback the extra rematerialization of the function should have
   // happened
   CallInst *CI = getCallByName(Resume1, "should.remat");
   ASSERT_TRUE(CI);
 }
 } // namespace

llvm/unittests/Transforms/Scalar/LICMTest.cpp

 #include "llvm/Transforms/Scalar/LICM.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
 
 TEST(LICMTest, TestSCEVInvalidationOnHoisting) {
   LLVMContext Ctx;
   ModulePassManager MPM;
-  PassBuilder PB;
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
-
-  PB.registerModuleAnalyses(MAM);
-  PB.registerCGSCCAnalyses(CGAM);
-  PB.registerFunctionAnalyses(FAM);
-  PB.registerLoopAnalyses(LAM);
-  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+  PassBuilderContext PBC;
+  PBC.registerAnalyses();
 
   StringRef PipelineStr = "require<opt-remark-emit>,loop-mssa(licm)";
-  ASSERT_THAT_ERROR(PB.parsePassPipeline(MPM, PipelineStr), Succeeded());
+  ASSERT_THAT_ERROR(PBC.PB.parsePassPipeline(MPM, PipelineStr), Succeeded());
 
   SMDiagnostic Error;
   StringRef Text = R"(
     define void @foo(i64* %ptr) {
     entry:
       br label %loop
 
     loop:
       %iv = phi i64 [ 0, %entry ], [ %iv.inc, %loop ]
       %n = load i64, i64* %ptr, !invariant.load !0
       %iv.inc = add i64 %iv, 1
       %cmp = icmp ult i64 %iv.inc, %n
       br i1 %cmp, label %loop, label %exit
 
     exit:
       ret void
     }
 
     !0 = !{}
   )";
 
   std::unique_ptr<Module> M = parseAssemblyString(Text, Error, Ctx);
   ASSERT_TRUE(M);
   Function *F = M->getFunction("foo");
-  ScalarEvolution &SE = FAM.getResult<ScalarEvolutionAnalysis>(*F);
+  ScalarEvolution &SE = PBC.FAM.getResult<ScalarEvolutionAnalysis>(*F);
   BasicBlock &EntryBB = F->getEntryBlock();
   BasicBlock *LoopBB = EntryBB.getUniqueSuccessor();
 
   // Select `load i64, i64* %ptr`.
   Instruction *IBefore = LoopBB->getFirstNonPHI();
   // Make sure the right instruction was selected.
   ASSERT_TRUE(isa<LoadInst>(IBefore));
   // Upon this query SCEV caches disposition of <load i64, i64* %ptr> SCEV.
   ASSERT_EQ(SE.getBlockDisposition(SE.getSCEV(IBefore), LoopBB),
             ScalarEvolution::BlockDisposition::DominatesBlock);
 
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 
   // Select `load i64, i64* %ptr` after it was hoisted.
   Instruction *IAfter = EntryBB.getFirstNonPHI();
   // Make sure the right instruction was selected.
   ASSERT_TRUE(isa<LoadInst>(IAfter));
 
   ScalarEvolution::BlockDisposition DispositionBeforeInvalidation =
       SE.getBlockDisposition(SE.getSCEV(IAfter), LoopBB);

llvm/unittests/Transforms/Utils/MemTransferLowering.cpp

struct ForwardingPass : public PassInfoMixin<ForwardingPass> {
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM) {
     return Func(F, FAM);
   }
 
   std::function<PreservedAnalyses(Function &, FunctionAnalysisManager &)> Func;
 };
 
 struct MemTransferLowerTest : public testing::Test {
-  PassBuilder PB;
-  LoopAnalysisManager LAM;
-  FunctionAnalysisManager FAM;
-  CGSCCAnalysisManager CGAM;
-  ModuleAnalysisManager MAM;
+  PassBuilderContext PBC;
   ModulePassManager MPM;
   LLVMContext Context;
   std::unique_ptr<Module> M;
 
   MemTransferLowerTest() {
-    // Register all the basic analyses with the managers.
-    PB.registerModuleAnalyses(MAM);
-    PB.registerCGSCCAnalyses(CGAM);
-    PB.registerFunctionAnalyses(FAM);
-    PB.registerLoopAnalyses(LAM);
-    PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+    PBC.registerAnalyses();
   }
 
   BasicBlock *getBasicBlockByName(Function &F, StringRef Name) const {
     for (BasicBlock &BB : F) {
       if (BB.getName() == Name)
         return &BB;
     }
     return nullptr;
FPM.addPass(ForwardingPass(
         EXPECT_NE(nullptr, LoadInst->getMetadata(LLVMContext::MD_alias_scope));
         Instruction *StoreInst =
             getInstructionByOpcode(*CopyLoopBB, Instruction::Store, 1);
         EXPECT_NE(nullptr, StoreInst->getMetadata(LLVMContext::MD_noalias));
         return PreservedAnalyses::none();
       }));
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 }
 
 // This test indirectly checks that loads and stores (generated as a result of
 // llvm.memcpy lowering) doesn't alias by making sure the loop can be
 // successfully vectorized without additional runtime checks.
 TEST_F(MemTransferLowerTest, VecMemCpyKnownLength) {
   ParseAssembly("declare void @llvm.memcpy.p0i8.p0i8.i64(i8*, i8 *, i64, i1)\n"
                 "define void @foo(i8* %dst, i8* %src, i64 %n) optsize {\n"
TEST_F(MemTransferLowerTest, VecMemCpyKnownLength) {
   FPM.addPass(ForwardingPass(
       [=](Function &F, FunctionAnalysisManager &FAM) -> PreservedAnalyses {
         auto *TargetBB = getBasicBlockByName(F, "vector.body");
         EXPECT_NE(nullptr, TargetBB);
         return PreservedAnalyses::all();
       }));
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 }
 
 TEST_F(MemTransferLowerTest, AtomicMemCpyKnownLength) {
   ParseAssembly("declare void "
                 "@llvm.memcpy.element.unordered.atomic.p0i32.p0i32.i64(i32*, "
                 "i32 *, i64, i32)\n"
                 "define void @foo(i32* %dst, i32* %src, i64 %n) optsize {\n"
                 "entry:\n"
FPM.addPass(ForwardingPass(
         Instruction *StoreInst =
             getInstructionByOpcode(*CopyLoopBB, Instruction::Store, 1);
         EXPECT_TRUE(StoreInst->isAtomic());
         EXPECT_NE(StoreInst->getMetadata(LLVMContext::MD_noalias), nullptr);
         return PreservedAnalyses::none();
       }));
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 }
 
 TEST_F(MemTransferLowerTest, AtomicMemCpyUnKnownLength) {
   ParseAssembly("declare void "
                 "@llvm.memcpy.element.unordered.atomic.p0i32.p0i32.i64(i32*, "
                 "i32 *, i64, i32)\n"
                 "define void @foo(i32* %dst, i32* %src, i64 %n) optsize {\n"
                 "entry:\n"
FPM.addPass(ForwardingPass(
         Instruction *StoreInst =
             getInstructionByOpcode(*CopyLoopBB, Instruction::Store, 1);
         EXPECT_TRUE(StoreInst->isAtomic());
         EXPECT_NE(StoreInst->getMetadata(LLVMContext::MD_noalias), nullptr);
         return PreservedAnalyses::none();
       }));
   MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
 
-  MPM.run(*M, MAM);
+  MPM.run(*M, PBC.MAM);
 }
 } // namespace