Index: llvm/include/llvm/Passes/PassBuilder.h =================================================================== --- llvm/include/llvm/Passes/PassBuilder.h +++ llvm/include/llvm/Passes/PassBuilder.h @@ -705,6 +705,33 @@ 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 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 Index: llvm/lib/LTO/LTOBackend.cpp =================================================================== --- llvm/lib/LTO/LTOBackend.cpp +++ llvm/lib/LTO/LTOBackend.cpp @@ -253,23 +253,18 @@ } 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 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()) { @@ -279,15 +274,10 @@ 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; @@ -330,7 +320,7 @@ 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, Index: llvm/lib/LTO/ThinLTOCodeGenerator.cpp =================================================================== --- llvm/lib/LTO/ThinLTOCodeGenerator.cpp +++ llvm/lib/LTO/ThinLTOCodeGenerator.cpp @@ -238,31 +238,22 @@ unsigned OptLevel, bool Freestanding, bool DebugPassManager, ModuleSummaryIndex *Index) { std::optional 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 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; @@ -285,9 +276,9 @@ 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 Index: llvm/lib/Passes/PassBuilderBindings.cpp =================================================================== --- llvm/lib/Passes/PassBuilderBindings.cpp +++ llvm/lib/Passes/PassBuilderBindings.cpp @@ -52,30 +52,18 @@ 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; } Index: llvm/tools/llvm-extract/llvm-extract.cpp =================================================================== --- llvm/tools/llvm-extract/llvm-extract.cpp +++ llvm/tools/llvm-extract/llvm-extract.cpp @@ -323,22 +323,12 @@ { std::vector 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. @@ -370,39 +360,19 @@ 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) @@ -422,7 +392,7 @@ 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(); Index: llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp =================================================================== --- llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp +++ llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp @@ -136,21 +136,11 @@ // 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)); @@ -158,7 +148,7 @@ // 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())) { Index: llvm/tools/llvm-reduce/ReducerWorkItem.cpp =================================================================== --- llvm/tools/llvm-reduce/ReducerWorkItem.cpp +++ llvm/tools/llvm-reduce/ReducerWorkItem.cpp @@ -713,19 +713,11 @@ 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 Index; if (LTOInfo && LTOInfo->HasSummary) { Index: llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp =================================================================== --- llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp +++ llvm/tools/llvm-reduce/deltas/RunIRPasses.cpp @@ -25,28 +25,17 @@ 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) { Index: llvm/unittests/Analysis/PluginInlineAdvisorAnalysisTest.cpp =================================================================== --- llvm/unittests/Analysis/PluginInlineAdvisorAnalysisTest.cpp +++ llvm/unittests/Analysis/PluginInlineAdvisorAnalysisTest.cpp @@ -50,11 +50,7 @@ ModulePassManager MPM; InlineParams IP; - PassBuilder PB; - LoopAnalysisManager LAM; - FunctionAnalysisManager FAM; - CGSCCAnalysisManager CGAM; - ModuleAnalysisManager MAM; + PassBuilderContext PBC; SMDiagnostic Error; @@ -64,24 +60,20 @@ ASSERT_NE("", PluginPath); Expected 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)); } @@ -99,7 +91,7 @@ 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}; @@ -114,7 +106,7 @@ // 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}; Index: llvm/unittests/Analysis/PluginInlineOrderAnalysisTest.cpp =================================================================== --- llvm/unittests/Analysis/PluginInlineOrderAnalysisTest.cpp +++ llvm/unittests/Analysis/PluginInlineOrderAnalysisTest.cpp @@ -32,11 +32,7 @@ ModulePassManager MPM; InlineParams IP; - PassBuilder PB; - LoopAnalysisManager LAM; - FunctionAnalysisManager FAM; - CGSCCAnalysisManager CGAM; - ModuleAnalysisManager MAM; + PassBuilderContext PBC; SMDiagnostic Error; @@ -46,16 +42,12 @@ ASSERT_NE("", PluginPath); Expected 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)); } @@ -72,7 +64,7 @@ // 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}; Index: llvm/unittests/Transforms/Coroutines/ExtraRematTest.cpp =================================================================== --- llvm/unittests/Transforms/Coroutines/ExtraRematTest.cpp +++ llvm/unittests/Transforms/Coroutines/ExtraRematTest.cpp @@ -19,22 +19,13 @@ 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 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 { @@ -141,7 +132,7 @@ 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"); @@ -166,7 +157,7 @@ CGPM.addPass( CoroSplitPass(std::function(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"); Index: llvm/unittests/Transforms/Scalar/LICMTest.cpp =================================================================== --- llvm/unittests/Transforms/Scalar/LICMTest.cpp +++ llvm/unittests/Transforms/Scalar/LICMTest.cpp @@ -20,20 +20,11 @@ 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,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"( @@ -58,7 +49,7 @@ std::unique_ptr M = parseAssemblyString(Text, Error, Ctx); ASSERT_TRUE(M); Function *F = M->getFunction("foo"); - ScalarEvolution &SE = FAM.getResult(*F); + ScalarEvolution &SE = PBC.FAM.getResult(*F); BasicBlock &EntryBB = F->getEntryBlock(); BasicBlock *LoopBB = EntryBB.getUniqueSuccessor(); @@ -70,7 +61,7 @@ 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(); Index: llvm/unittests/Transforms/Utils/MemTransferLowering.cpp =================================================================== --- llvm/unittests/Transforms/Utils/MemTransferLowering.cpp +++ llvm/unittests/Transforms/Utils/MemTransferLowering.cpp @@ -42,22 +42,13 @@ }; struct MemTransferLowerTest : public testing::Test { - PassBuilder PB; - LoopAnalysisManager LAM; - FunctionAnalysisManager FAM; - CGSCCAnalysisManager CGAM; - ModuleAnalysisManager MAM; + PassBuilderContext PBC; ModulePassManager MPM; LLVMContext Context; std::unique_ptr 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 { @@ -132,7 +123,7 @@ })); 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 @@ -172,7 +163,7 @@ })); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); - MPM.run(*M, MAM); + MPM.run(*M, PBC.MAM); } TEST_F(MemTransferLowerTest, AtomicMemCpyKnownLength) { @@ -217,7 +208,7 @@ })); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); - MPM.run(*M, MAM); + MPM.run(*M, PBC.MAM); } TEST_F(MemTransferLowerTest, AtomicMemCpyUnKnownLength) { @@ -262,6 +253,6 @@ })); MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM))); - MPM.run(*M, MAM); + MPM.run(*M, PBC.MAM); } } // namespace