Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-11-25 14:50:26 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[NFC] Clean up PassBuilder

Browse Source 
Make DebugLogging a member variable so that users of PassBuilder don't
need to pass it around so much.

Move call to TargetMachine::registerPassBuilderCallbacks() within
PassBuilder so users don't need to remember to call it.

Reviewed By: asbirlea

Differential Revision: https://reviews.llvm.org/D90437
This commit is contained in:
Arthur Eubanks 2020-10-29 15:43:31 -07:00
parent 10f2a0d662
commit 2e31727a88
8 changed files with 152 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
clang/lib/CodeGen/BackendUtil.cpp
View File

@ -1203,7 +1203,7 @@ void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(CodeGenOpts.DebugPassManager);
SI.registerCallbacks(PIC);
PassBuilder PB(TM.get(), PTO, PGOOpt, &PIC);
PassBuilder PB(CodeGenOpts.DebugPassManager, TM.get(), PTO, PGOOpt, &PIC);
// Attempt to load pass plugins and register their callbacks with PB.
for (auto &PluginFN : CodeGenOpts.PassPlugins) {
@ -1241,9 +1241,6 @@ void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
PB.registerLoopAnalyses(LAM);
PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
if (TM)
TM->registerPassBuilderCallbacks(PB, CodeGenOpts.DebugPassManager);
ModulePassManager MPM(CodeGenOpts.DebugPassManager);
if (!CodeGenOpts.DisableLLVMPasses) {
@ -1280,7 +1277,7 @@ void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
if (PGOOpt && (PGOOpt->Action == PGOOptions::IRInstr ||
PGOOpt->Action == PGOOptions::IRUse))
PB.addPGOInstrPassesForO0(
MPM, CodeGenOpts.DebugPassManager,
MPM,
/* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
/* IsCS */ false, PGOOpt->ProfileFile,
PGOOpt->ProfileRemappingFile);
@ -1407,18 +1404,15 @@ void EmitAssemblyHelper::EmitAssemblyWithNewPassManager(
});
if (IsThinLTO) {
MPM = PB.buildThinLTOPreLinkDefaultPipeline(
Level, CodeGenOpts.DebugPassManager);
MPM = PB.buildThinLTOPreLinkDefaultPipeline(Level);
MPM.addPass(CanonicalizeAliasesPass());
MPM.addPass(NameAnonGlobalPass());
} else if (IsLTO) {
MPM = PB.buildLTOPreLinkDefaultPipeline(Level,
CodeGenOpts.DebugPassManager);
MPM = PB.buildLTOPreLinkDefaultPipeline(Level);
MPM.addPass(CanonicalizeAliasesPass());
MPM.addPass(NameAnonGlobalPass());
} else {
MPM = PB.buildPerModuleDefaultPipeline(Level,
CodeGenOpts.DebugPassManager);
MPM = PB.buildPerModuleDefaultPipeline(Level);
}
}

82
llvm/include/llvm/Passes/PassBuilder.h
View File

@ -118,6 +118,7 @@ public:
/// of the built-in passes, and those may reference these members during
/// construction.
class PassBuilder {
bool DebugLogging;
TargetMachine *TM;
PipelineTuningOptions PTO;
Optional<PGOOptions> PGOOpt;
@ -259,11 +260,10 @@ public:
unsigned getSizeLevel() const { return SizeLevel; }
};
explicit PassBuilder(TargetMachine *TM = nullptr,
explicit PassBuilder(bool DebugLogging = false, TargetMachine *TM = nullptr,
PipelineTuningOptions PTO = PipelineTuningOptions(),
Optional<PGOOptions> PGOOpt = None,
PassInstrumentationCallbacks *PIC = nullptr)
: TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {}
PassInstrumentationCallbacks *PIC = nullptr);
/// Cross register the analysis managers through their proxies.
///
@ -321,8 +321,7 @@ public:
/// \p Phase indicates the current ThinLTO phase.
FunctionPassManager
buildFunctionSimplificationPipeline(OptimizationLevel Level,
ThinLTOPhase Phase,
bool DebugLogging = false);
ThinLTOPhase Phase);
/// Construct the core LLVM module canonicalization and simplification
/// pipeline.
@ -339,16 +338,13 @@ public:
/// build them.
///
/// \p Phase indicates the current ThinLTO phase.
ModulePassManager
buildModuleSimplificationPipeline(OptimizationLevel Level,
ThinLTOPhase Phase,
bool DebugLogging = false);
ModulePassManager buildModuleSimplificationPipeline(OptimizationLevel Level,
ThinLTOPhase Phase);
/// Construct the module pipeline that performs inlining as well as
/// the inlining-driven cleanups.
ModuleInlinerWrapperPass buildInlinerPipeline(OptimizationLevel Level,
ThinLTOPhase Phase,
bool DebugLogging = false);
ThinLTOPhase Phase);
/// Construct the core LLVM module optimization pipeline.
///
@ -364,7 +360,6 @@ public:
/// require some transformations for semantic reasons, they should explicitly
/// build them.
ModulePassManager buildModuleOptimizationPipeline(OptimizationLevel Level,
bool DebugLogging = false,
bool LTOPreLink = false);
/// Build a per-module default optimization pipeline.
@ -379,7 +374,6 @@ public:
/// require some transformations for semantic reasons, they should explicitly
/// build them.
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level,
bool DebugLogging = false,
bool LTOPreLink = false);
/// Build a pre-link, ThinLTO-targeting default optimization pipeline to
@ -394,9 +388,7 @@ public:
/// only intended for use when attempting to optimize code. If frontends
/// require some transformations for semantic reasons, they should explicitly
/// build them.
ModulePassManager
buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level,
bool DebugLogging = false);
ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level);
/// Build an ThinLTO default optimization pipeline to a pass manager.
///
@ -410,7 +402,7 @@ public:
/// require some transformations for semantic reasons, they should explicitly
/// build them.
ModulePassManager
buildThinLTODefaultPipeline(OptimizationLevel Level, bool DebugLogging,
buildThinLTODefaultPipeline(OptimizationLevel Level,
const ModuleSummaryIndex *ImportSummary);
/// Build a pre-link, LTO-targeting default optimization pipeline to a pass
@ -425,8 +417,7 @@ public:
/// only intended for use when attempting to optimize code. If frontends
/// require some transformations for semantic reasons, they should explicitly
/// build them.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level,
bool DebugLogging = false);
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level);
/// Build an LTO default optimization pipeline to a pass manager.
///
@ -440,7 +431,6 @@ public:
/// require some transformations for semantic reasons, they should explicitly
/// build them.
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level,
bool DebugLogging,
ModuleSummaryIndex *ExportSummary);
/// Build the default `AAManager` with the default alias analysis pipeline
@ -487,8 +477,7 @@ public:
/// specifically want the pass to run under a adaptor directly. This is
/// preferred when a pipeline is largely of one type, but one or just a few
/// passes are of different types(See PassBuilder.cpp for examples).
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText,
bool DebugLogging = false);
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText);
/// {{@ Parse a textual pass pipeline description into a specific PassManager
///
@ -497,12 +486,9 @@ public:
/// this is the valid pipeline text:
///
/// function(lpass)
Error parsePassPipeline(CGSCCPassManager &CGPM, StringRef PipelineText,
bool DebugLogging = false);
Error parsePassPipeline(FunctionPassManager &FPM, StringRef PipelineText,
bool DebugLogging = false);
Error parsePassPipeline(LoopPassManager &LPM, StringRef PipelineText,
bool DebugLogging = false);
Error parsePassPipeline(CGSCCPassManager &CGPM, StringRef PipelineText);
Error parsePassPipeline(FunctionPassManager &FPM, StringRef PipelineText);
Error parsePassPipeline(LoopPassManager &LPM, StringRef PipelineText);
/// @}}
/// Parse a textual alias analysis pipeline into the provided AA manager.
@ -681,12 +667,10 @@ public:
bool DebugLogging)> &C);
/// Add PGOInstrumenation passes for O0 only.
void addPGOInstrPassesForO0(ModulePassManager &MPM, bool DebugLogging,
bool RunProfileGen, bool IsCS,
std::string ProfileFile,
void addPGOInstrPassesForO0(ModulePassManager &MPM, bool RunProfileGen,
bool IsCS, std::string ProfileFile,
std::string ProfileRemappingFile);
/// Returns PIC. External libraries can use this to register pass
/// instrumentation callbacks.
PassInstrumentationCallbacks *getPassInstrumentationCallbacks() const {
@ -695,38 +679,30 @@ public:
private:
// O1 pass pipeline
FunctionPassManager buildO1FunctionSimplificationPipeline(
OptimizationLevel Level, ThinLTOPhase Phase, bool DebugLogging = false);
FunctionPassManager
buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
ThinLTOPhase Phase);
static Optional<std::vector<PipelineElement>>
parsePipelineText(StringRef Text);
Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E,
bool DebugLogging);
Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E,
bool DebugLogging);
Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E,
bool DebugLogging);
Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
bool DebugLogging);
Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E);
Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E);
Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E);
Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E);
bool parseAAPassName(AAManager &AA, StringRef Name);
Error parseLoopPassPipeline(LoopPassManager &LPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging);
ArrayRef<PipelineElement> Pipeline);
Error parseFunctionPassPipeline(FunctionPassManager &FPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging);
ArrayRef<PipelineElement> Pipeline);
Error parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging);
ArrayRef<PipelineElement> Pipeline);
Error parseModulePassPipeline(ModulePassManager &MPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging);
ArrayRef<PipelineElement> Pipeline);
void addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
OptimizationLevel Level, bool RunProfileGen, bool IsCS,
std::string ProfileFile,
void addPGOInstrPasses(ModulePassManager &MPM, OptimizationLevel Level,
bool RunProfileGen, bool IsCS, std::string ProfileFile,
std::string ProfileRemappingFile);
void invokePeepholeEPCallbacks(FunctionPassManager &, OptimizationLevel);

11
llvm/lib/LTO/LTOBackend.cpp
View File

@ -223,7 +223,7 @@ static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(Conf.DebugPassManager);
SI.registerCallbacks(PIC);
PassBuilder PB(TM, Conf.PTO, PGOOpt, &PIC);
PassBuilder PB(Conf.DebugPassManager, TM, Conf.PTO, PGOOpt, &PIC);
AAManager AA;
// Parse a custom AA pipeline if asked to.
@ -270,10 +270,9 @@ static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
}
if (IsThinLTO)
MPM = PB.buildThinLTODefaultPipeline(OL, Conf.DebugPassManager,
ImportSummary);
MPM = PB.buildThinLTODefaultPipeline(OL, ImportSummary);
else
MPM = PB.buildLTODefaultPipeline(OL, Conf.DebugPassManager, ExportSummary);
MPM = PB.buildLTODefaultPipeline(OL, ExportSummary);
MPM.run(Mod, MAM);
// FIXME (davide): verify the output.
@ -283,7 +282,7 @@ static void runNewPMCustomPasses(const Config &Conf, Module &Mod,
TargetMachine *TM, std::string PipelineDesc,
std::string AAPipelineDesc,
bool DisableVerify) {
PassBuilder PB(TM);
PassBuilder PB(Conf.DebugPassManager, TM);
AAManager AA;
// Parse a custom AA pipeline if asked to.
@ -722,4 +721,4 @@ bool lto::loadReferencedModules(
OwnedImportsLifetimeManager.push_back(std::move(*MBOrErr));
}
return true;
}
}

182
llvm/lib/Passes/PassBuilder.cpp
View File

@ -431,6 +431,14 @@ AnalysisKey NoOpLoopAnalysis::Key;
} // namespace
PassBuilder::PassBuilder(bool DebugLogging, TargetMachine *TM,
PipelineTuningOptions PTO, Optional<PGOOptions> PGOOpt,
PassInstrumentationCallbacks *PIC)
: DebugLogging(DebugLogging), TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
if (TM)
TM->registerPassBuilderCallbacks(*this, DebugLogging);
}
void PassBuilder::invokePeepholeEPCallbacks(
FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
for (auto &C : PeepholeEPCallbacks)
@ -474,8 +482,9 @@ void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) {
}
// TODO: Investigate the cost/benefit of tail call elimination on debugging.
FunctionPassManager PassBuilder::buildO1FunctionSimplificationPipeline(
OptimizationLevel Level, ThinLTOPhase Phase, bool DebugLogging) {
FunctionPassManager
PassBuilder::buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
ThinLTOPhase Phase) {
FunctionPassManager FPM(DebugLogging);
@ -600,14 +609,13 @@ FunctionPassManager PassBuilder::buildO1FunctionSimplificationPipeline(
FunctionPassManager
PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
ThinLTOPhase Phase,
bool DebugLogging) {
ThinLTOPhase Phase) {
assert(Level != OptimizationLevel::O0 && "Must request optimizations!");
// The O1 pipeline has a separate pipeline creation function to simplify
// construction readability.
if (Level.getSpeedupLevel() == 1)
return buildO1FunctionSimplificationPipeline(Level, Phase, DebugLogging);
return buildO1FunctionSimplificationPipeline(Level, Phase);
FunctionPassManager FPM(DebugLogging);
@ -784,7 +792,7 @@ PassBuilder::buildFunctionSimplificationPipeline(OptimizationLevel Level,
return FPM;
}
void PassBuilder::addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
void PassBuilder::addPGOInstrPasses(ModulePassManager &MPM,
PassBuilder::OptimizationLevel Level,
bool RunProfileGen, bool IsCS,
std::string ProfileFile,
@ -854,8 +862,8 @@ void PassBuilder::addPGOInstrPasses(ModulePassManager &MPM, bool DebugLogging,
}
void PassBuilder::addPGOInstrPassesForO0(ModulePassManager &MPM,
bool DebugLogging, bool RunProfileGen,
bool IsCS, std::string ProfileFile,
bool RunProfileGen, bool IsCS,
std::string ProfileFile,
std::string ProfileRemappingFile) {
if (!RunProfileGen) {
assert(!ProfileFile.empty() && "Profile use expecting a profile file!");
@ -884,8 +892,7 @@ getInlineParamsFromOptLevel(PassBuilder::OptimizationLevel Level) {
}
ModuleInlinerWrapperPass
PassBuilder::buildInlinerPipeline(OptimizationLevel Level, ThinLTOPhase Phase,
bool DebugLogging) {
PassBuilder::buildInlinerPipeline(OptimizationLevel Level, ThinLTOPhase Phase) {
InlineParams IP = getInlineParamsFromOptLevel(Level);
if (Phase == PassBuilder::ThinLTOPhase::PreLink && PGOOpt &&
PGOOpt->Action == PGOOptions::SampleUse)
@ -938,7 +945,7 @@ PassBuilder::buildInlinerPipeline(OptimizationLevel Level, ThinLTOPhase Phase,
// Lastly, add the core function simplification pipeline nested inside the
// CGSCC walk.
MainCGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
buildFunctionSimplificationPipeline(Level, Phase, DebugLogging)));
buildFunctionSimplificationPipeline(Level, Phase)));
for (auto &C : CGSCCOptimizerLateEPCallbacks)
C(MainCGPipeline, Level);
@ -946,8 +953,9 @@ PassBuilder::buildInlinerPipeline(OptimizationLevel Level, ThinLTOPhase Phase,
return MIWP;
}
ModulePassManager PassBuilder::buildModuleSimplificationPipeline(
OptimizationLevel Level, ThinLTOPhase Phase, bool DebugLogging) {
ModulePassManager
PassBuilder::buildModuleSimplificationPipeline(OptimizationLevel Level,
ThinLTOPhase Phase) {
ModulePassManager MPM(DebugLogging);
bool HasSampleProfile = PGOOpt && (PGOOpt->Action == PGOOptions::SampleUse);
@ -1068,7 +1076,7 @@ ModulePassManager PassBuilder::buildModuleSimplificationPipeline(
if (PGOOpt && Phase != ThinLTOPhase::PostLink &&
(PGOOpt->Action == PGOOptions::IRInstr ||
PGOOpt->Action == PGOOptions::IRUse)) {
addPGOInstrPasses(MPM, DebugLogging, Level,
addPGOInstrPasses(MPM, Level,
/* RunProfileGen */ PGOOpt->Action == PGOOptions::IRInstr,
/* IsCS */ false, PGOOpt->ProfileFile,
PGOOpt->ProfileRemappingFile);
@ -1082,7 +1090,7 @@ ModulePassManager PassBuilder::buildModuleSimplificationPipeline(
if (EnableSyntheticCounts && !PGOOpt)
MPM.addPass(SyntheticCountsPropagation());
MPM.addPass(buildInlinerPipeline(Level, Phase, DebugLogging));
MPM.addPass(buildInlinerPipeline(Level, Phase));
if (EnableMemProfiler && Phase != ThinLTOPhase::PreLink) {
MPM.addPass(createModuleToFunctionPassAdaptor(MemProfilerPass()));
@ -1092,8 +1100,9 @@ ModulePassManager PassBuilder::buildModuleSimplificationPipeline(
return MPM;
}
ModulePassManager PassBuilder::buildModuleOptimizationPipeline(
OptimizationLevel Level, bool DebugLogging, bool LTOPreLink) {
ModulePassManager
PassBuilder::buildModuleOptimizationPipeline(OptimizationLevel Level,
bool LTOPreLink) {
ModulePassManager MPM(DebugLogging);
// Optimize globals now that the module is fully simplified.
@ -1131,11 +1140,11 @@ ModulePassManager PassBuilder::buildModuleOptimizationPipeline(
// instrumentation is after all the inlines are done.
if (!LTOPreLink && PGOOpt) {
if (PGOOpt->CSAction == PGOOptions::CSIRInstr)
addPGOInstrPasses(MPM, DebugLogging, Level, /* RunProfileGen */ true,
addPGOInstrPasses(MPM, Level, /* RunProfileGen */ true,
/* IsCS */ true, PGOOpt->CSProfileGenFile,
PGOOpt->ProfileRemappingFile);
else if (PGOOpt->CSAction == PGOOptions::CSIRUse)
addPGOInstrPasses(MPM, DebugLogging, Level, /* RunProfileGen */ false,
addPGOInstrPasses(MPM, Level, /* RunProfileGen */ false,
/* IsCS */ true, PGOOpt->ProfileFile,
PGOOpt->ProfileRemappingFile);
}
@ -1298,7 +1307,7 @@ ModulePassManager PassBuilder::buildModuleOptimizationPipeline(
ModulePassManager
PassBuilder::buildPerModuleDefaultPipeline(OptimizationLevel Level,
bool DebugLogging, bool LTOPreLink) {
bool LTOPreLink) {
assert(Level != OptimizationLevel::O0 &&
"Must request optimizations for the default pipeline!");
@ -1315,18 +1324,16 @@ PassBuilder::buildPerModuleDefaultPipeline(OptimizationLevel Level,
MPM.addPass(createModuleToFunctionPassAdaptor(AddDiscriminatorsPass()));
// Add the core simplification pipeline.
MPM.addPass(buildModuleSimplificationPipeline(Level, ThinLTOPhase::None,
DebugLogging));
MPM.addPass(buildModuleSimplificationPipeline(Level, ThinLTOPhase::None));
// Now add the optimization pipeline.
MPM.addPass(buildModuleOptimizationPipeline(Level, DebugLogging, LTOPreLink));
MPM.addPass(buildModuleOptimizationPipeline(Level, LTOPreLink));
return MPM;
}
ModulePassManager
PassBuilder::buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level,
bool DebugLogging) {
PassBuilder::buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level) {
assert(Level != OptimizationLevel::O0 &&
"Must request optimizations for the default pipeline!");
@ -1345,8 +1352,7 @@ PassBuilder::buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level,
// If we are planning to perform ThinLTO later, we don't bloat the code with
// unrolling/vectorization/... now. Just simplify the module as much as we
// can.
MPM.addPass(buildModuleSimplificationPipeline(Level, ThinLTOPhase::PreLink,
DebugLogging));
MPM.addPass(buildModuleSimplificationPipeline(Level, ThinLTOPhase::PreLink));
// Run partial inlining pass to partially inline functions that have
// large bodies.
@ -1371,8 +1377,7 @@ PassBuilder::buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level,
}
ModulePassManager PassBuilder::buildThinLTODefaultPipeline(
OptimizationLevel Level, bool DebugLogging,
const ModuleSummaryIndex *ImportSummary) {
OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary) {
ModulePassManager MPM(DebugLogging);
if (ImportSummary) {
@ -1402,27 +1407,25 @@ ModulePassManager PassBuilder::buildThinLTODefaultPipeline(
MPM.addPass(ForceFunctionAttrsPass());
// Add the core simplification pipeline.
MPM.addPass(buildModuleSimplificationPipeline(Level, ThinLTOPhase::PostLink,
DebugLogging));
MPM.addPass(buildModuleSimplificationPipeline(Level, ThinLTOPhase::PostLink));
// Now add the optimization pipeline.
MPM.addPass(buildModuleOptimizationPipeline(Level, DebugLogging));
MPM.addPass(buildModuleOptimizationPipeline(Level));
return MPM;
}
ModulePassManager
PassBuilder::buildLTOPreLinkDefaultPipeline(OptimizationLevel Level,
bool DebugLogging) {
PassBuilder::buildLTOPreLinkDefaultPipeline(OptimizationLevel Level) {
assert(Level != OptimizationLevel::O0 &&
"Must request optimizations for the default pipeline!");
// FIXME: We should use a customized pre-link pipeline!
return buildPerModuleDefaultPipeline(Level, DebugLogging,
return buildPerModuleDefaultPipeline(Level,
/* LTOPreLink */ true);
}
ModulePassManager
PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level, bool DebugLogging,
PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level,
ModuleSummaryIndex *ExportSummary) {
ModulePassManager MPM(DebugLogging);
@ -1558,11 +1561,11 @@ PassBuilder::buildLTODefaultPipeline(OptimizationLevel Level, bool DebugLogging,
// sensitive PGO pass.
if (PGOOpt) {
if (PGOOpt->CSAction == PGOOptions::CSIRInstr)
addPGOInstrPasses(MPM, DebugLogging, Level, /* RunProfileGen */ true,
addPGOInstrPasses(MPM, Level, /* RunProfileGen */ true,
/* IsCS */ true, PGOOpt->CSProfileGenFile,
PGOOpt->ProfileRemappingFile);
else if (PGOOpt->CSAction == PGOOptions::CSIRUse)
addPGOInstrPasses(MPM, DebugLogging, Level, /* RunProfileGen */ false,
addPGOInstrPasses(MPM, Level, /* RunProfileGen */ false,
/* IsCS */ true, PGOOpt->ProfileFile,
PGOOpt->ProfileRemappingFile);
}
@ -2149,8 +2152,7 @@ PassBuilder::parsePipelineText(StringRef Text) {
}
Error PassBuilder::parseModulePass(ModulePassManager &MPM,
const PipelineElement &E,
bool DebugLogging) {
const PipelineElement &E) {
auto &Name = E.Name;
auto &InnerPipeline = E.InnerPipeline;
@ -2158,31 +2160,28 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
if (!InnerPipeline.empty()) {
if (Name == "module") {
ModulePassManager NestedMPM(DebugLogging);
if (auto Err =
parseModulePassPipeline(NestedMPM, InnerPipeline, DebugLogging))
if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
return Err;
MPM.addPass(std::move(NestedMPM));
return Error::success();
}
if (Name == "cgscc") {
CGSCCPassManager CGPM(DebugLogging);
if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline, DebugLogging))
if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
return Err;
MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
return Error::success();
}
if (Name == "function") {
FunctionPassManager FPM(DebugLogging);
if (auto Err =
parseFunctionPassPipeline(FPM, InnerPipeline, DebugLogging))
if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
return Err;
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
return Error::success();
}
if (auto Count = parseRepeatPassName(Name)) {
ModulePassManager NestedMPM(DebugLogging);
if (auto Err =
parseModulePassPipeline(NestedMPM, InnerPipeline, DebugLogging))
if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
return Err;
MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
return Error::success();
@ -2222,7 +2221,7 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
(PGOOpt->Action == PGOOptions::IRInstr ||
PGOOpt->Action == PGOOptions::IRUse))
addPGOInstrPassesForO0(
MPM, DebugLogging,
MPM,
/* RunProfileGen */ (PGOOpt->Action == PGOOptions::IRInstr),
/* IsCS */ false, PGOOpt->ProfileFile,
PGOOpt->ProfileRemappingFile);
@ -2253,16 +2252,16 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
if (Matches[1] == "default") {
MPM.addPass(buildPerModuleDefaultPipeline(L, DebugLogging));
MPM.addPass(buildPerModuleDefaultPipeline(L));
} else if (Matches[1] == "thinlto-pre-link") {
MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L, DebugLogging));
MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L));
} else if (Matches[1] == "thinlto") {
MPM.addPass(buildThinLTODefaultPipeline(L, DebugLogging, nullptr));
MPM.addPass(buildThinLTODefaultPipeline(L, nullptr));
} else if (Matches[1] == "lto-pre-link") {
MPM.addPass(buildLTOPreLinkDefaultPipeline(L, DebugLogging));
MPM.addPass(buildLTOPreLinkDefaultPipeline(L));
} else {
assert(Matches[1] == "lto" && "Not one of the matched options!");
MPM.addPass(buildLTODefaultPipeline(L, DebugLogging, nullptr));
MPM.addPass(buildLTODefaultPipeline(L, nullptr));
}
return Error::success();
}
@ -2331,7 +2330,7 @@ Error PassBuilder::parseModulePass(ModulePassManager &MPM,
}
Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
const PipelineElement &E, bool DebugLogging) {
const PipelineElement &E) {
auto &Name = E.Name;
auto &InnerPipeline = E.InnerPipeline;
@ -2339,8 +2338,7 @@ Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
if (!InnerPipeline.empty()) {
if (Name == "cgscc") {
CGSCCPassManager NestedCGPM(DebugLogging);
if (auto Err =
parseCGSCCPassPipeline(NestedCGPM, InnerPipeline, DebugLogging))
if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
return Err;
// Add the nested pass manager with the appropriate adaptor.
CGPM.addPass(std::move(NestedCGPM));
@ -2348,8 +2346,7 @@ Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
}
if (Name == "function") {
FunctionPassManager FPM(DebugLogging);
if (auto Err =
parseFunctionPassPipeline(FPM, InnerPipeline, DebugLogging))
if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
return Err;
// Add the nested pass manager with the appropriate adaptor.
CGPM.addPass(createCGSCCToFunctionPassAdaptor(std::move(FPM)));
@ -2357,16 +2354,14 @@ Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
}
if (auto Count = parseRepeatPassName(Name)) {
CGSCCPassManager NestedCGPM(DebugLogging);
if (auto Err =
parseCGSCCPassPipeline(NestedCGPM, InnerPipeline, DebugLogging))
if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
return Err;
CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM)));
return Error::success();
}
if (auto MaxRepetitions = parseDevirtPassName(Name)) {
CGSCCPassManager NestedCGPM(DebugLogging);
if (auto Err =
parseCGSCCPassPipeline(NestedCGPM, InnerPipeline, DebugLogging))
if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
return Err;
CGPM.addPass(
createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
@ -2443,8 +2438,7 @@ Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
}
Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
const PipelineElement &E,
bool DebugLogging) {
const PipelineElement &E) {
auto &Name = E.Name;
auto &InnerPipeline = E.InnerPipeline;
@ -2452,8 +2446,7 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
if (!InnerPipeline.empty()) {
if (Name == "function") {
FunctionPassManager NestedFPM(DebugLogging);
if (auto Err =
parseFunctionPassPipeline(NestedFPM, InnerPipeline, DebugLogging))
if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
return Err;
// Add the nested pass manager with the appropriate adaptor.
FPM.addPass(std::move(NestedFPM));
@ -2461,7 +2454,7 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
}
if (Name == "loop" || Name == "loop-mssa") {
LoopPassManager LPM(DebugLogging);
if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline, DebugLogging))
if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
return Err;
// Add the nested pass manager with the appropriate adaptor.
bool UseMemorySSA = (Name == "loop-mssa");
@ -2474,8 +2467,7 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
}
if (auto Count = parseRepeatPassName(Name)) {
FunctionPassManager NestedFPM(DebugLogging);
if (auto Err =
parseFunctionPassPipeline(NestedFPM, InnerPipeline, DebugLogging))
if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
return Err;
FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
return Error::success();
@ -2546,8 +2538,8 @@ Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
inconvertibleErrorCode());
}
Error PassBuilder::parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
bool DebugLogging) {
Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
const PipelineElement &E) {
StringRef Name = E.Name;
auto &InnerPipeline = E.InnerPipeline;
@ -2555,8 +2547,7 @@ Error PassBuilder::parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
if (!InnerPipeline.empty()) {
if (Name == "loop") {
LoopPassManager NestedLPM(DebugLogging);
if (auto Err =
parseLoopPassPipeline(NestedLPM, InnerPipeline, DebugLogging))
if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
return Err;
// Add the nested pass manager with the appropriate adaptor.
LPM.addPass(std::move(NestedLPM));
@ -2564,8 +2555,7 @@ Error PassBuilder::parseLoopPass(LoopPassManager &LPM, const PipelineElement &E,
}
if (auto Count = parseRepeatPassName(Name)) {
LoopPassManager NestedLPM(DebugLogging);
if (auto Err =
parseLoopPassPipeline(NestedLPM, InnerPipeline, DebugLogging))
if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
return Err;
LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
return Error::success();
@ -2639,30 +2629,27 @@ bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
}
Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging) {
ArrayRef<PipelineElement> Pipeline) {
for (const auto &Element : Pipeline) {
if (auto Err = parseLoopPass(LPM, Element, DebugLogging))
if (auto Err = parseLoopPass(LPM, Element))
return Err;
}
return Error::success();
}
Error PassBuilder::parseFunctionPassPipeline(FunctionPassManager &FPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging) {
Error PassBuilder::parseFunctionPassPipeline(
FunctionPassManager &FPM, ArrayRef<PipelineElement> Pipeline) {
for (const auto &Element : Pipeline) {
if (auto Err = parseFunctionPass(FPM, Element, DebugLogging))
if (auto Err = parseFunctionPass(FPM, Element))
return Err;
}
return Error::success();
}
Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging) {
ArrayRef<PipelineElement> Pipeline) {
for (const auto &Element : Pipeline) {
if (auto Err = parseCGSCCPass(CGPM, Element, DebugLogging))
if (auto Err = parseCGSCCPass(CGPM, Element))
return Err;
}
return Error::success();
@ -2682,10 +2669,9 @@ void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM,
}
Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
ArrayRef<PipelineElement> Pipeline,
bool DebugLogging) {
ArrayRef<PipelineElement> Pipeline) {
for (const auto &Element : Pipeline) {
if (auto Err = parseModulePass(MPM, Element, DebugLogging))
if (auto Err = parseModulePass(MPM, Element))
return Err;
}
return Error::success();
@ -2695,8 +2681,7 @@ Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
// FIXME: Should this routine accept a TargetMachine or require the caller to
// pre-populate the analysis managers with target-specific stuff?
Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
StringRef PipelineText,
bool DebugLogging) {
StringRef PipelineText) {
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
@ -2730,15 +2715,14 @@ Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
}
}
if (auto Err = parseModulePassPipeline(MPM, *Pipeline, DebugLogging))
if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
return Err;
return Error::success();
}
// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
StringRef PipelineText,
bool DebugLogging) {
StringRef PipelineText) {
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
@ -2753,7 +2737,7 @@ Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
.str(),
inconvertibleErrorCode());
if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline, DebugLogging))
if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
return Err;
return Error::success();
}
@ -2761,8 +2745,7 @@ Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
// Primary pass pipeline description parsing routine for a \c
// FunctionPassManager
Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM,
StringRef PipelineText,
bool DebugLogging) {
StringRef PipelineText) {
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
@ -2777,22 +2760,21 @@ Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM,
.str(),
inconvertibleErrorCode());
if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline, DebugLogging))
if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
return Err;
return Error::success();
}
// Primary pass pipeline description parsing routine for a \c LoopPassManager
Error PassBuilder::parsePassPipeline(LoopPassManager &CGPM,
StringRef PipelineText,
bool DebugLogging) {
StringRef PipelineText) {
auto Pipeline = parsePipelineText(PipelineText);
if (!Pipeline || Pipeline->empty())
return make_error<StringError>(
formatv("invalid pipeline '{0}'", PipelineText).str(),
inconvertibleErrorCode());
if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline, DebugLogging))
if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
return Err;
return Error::success();

4
llvm/lib/Passes/PassRegistry.def
View File

@ -93,10 +93,10 @@ MODULE_PASS("rewrite-symbols", RewriteSymbolPass())
MODULE_PASS("rpo-function-attrs", ReversePostOrderFunctionAttrsPass())
MODULE_PASS("sample-profile", SampleProfileLoaderPass())
MODULE_PASS("scc-oz-module-inliner",
buildInlinerPipeline(OptimizationLevel::Oz, ThinLTOPhase::None, DebugLogging))
buildInlinerPipeline(OptimizationLevel::Oz, ThinLTOPhase::None))
MODULE_PASS("loop-extract-single", LoopExtractorPass(1))
MODULE_PASS("oz-module-optimizer",
buildModuleOptimizationPipeline(OptimizationLevel::Oz, DebugLogging, /*LTOPreLink*/false))
buildModuleOptimizationPipeline(OptimizationLevel::Oz, /*LTOPreLink*/false))
MODULE_PASS("strip", StripSymbolsPass())
MODULE_PASS("strip-dead-debug-info", StripDeadDebugInfoPass())
MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())

8
llvm/tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp
View File

@ -133,7 +133,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
// Create pass pipeline
//
PassBuilder PB(TM.get());
PassBuilder PB(false, TM.get());
LoopAnalysisManager LAM;
FunctionAnalysisManager FAM;
@ -148,7 +148,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
PB.registerLoopAnalyses(LAM);
PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
auto Err = PB.parsePassPipeline(MPM, PassPipeline, false);
auto Err = 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));
@ -240,9 +240,9 @@ extern "C" LLVM_ATTRIBUTE_USED int LLVMFuzzerInitialize(
exit(1);
}
PassBuilder PB(TM.get());
PassBuilder PB(false, TM.get());
ModulePassManager MPM;
if (auto Err = PB.parsePassPipeline(MPM, PassPipeline, false)) {
if (auto Err = PB.parsePassPipeline(MPM, PassPipeline)) {
errs() << *argv[0] << ": " << toString(std::move(Err)) << "\n";
exit(1);
}

62
llvm/tools/opt/NewPMDriver.cpp
View File

@ -140,68 +140,55 @@ bool tryParsePipelineText(PassBuilder &PB,
/// If one of the EPPipeline command line options was given, register callbacks
/// for parsing and inserting the given pipeline
static void registerEPCallbacks(PassBuilder &PB, bool DebugLogging) {
static void registerEPCallbacks(PassBuilder &PB) {
if (tryParsePipelineText<FunctionPassManager>(PB, PeepholeEPPipeline))
PB.registerPeepholeEPCallback(
[&PB, DebugLogging](FunctionPassManager &PM,
PassBuilder::OptimizationLevel Level) {
[&PB](FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
ExitOnError Err("Unable to parse PeepholeEP pipeline: ");
Err(PB.parsePassPipeline(PM, PeepholeEPPipeline, DebugLogging));
Err(PB.parsePassPipeline(PM, PeepholeEPPipeline));
});
if (tryParsePipelineText<LoopPassManager>(PB,
LateLoopOptimizationsEPPipeline))
PB.registerLateLoopOptimizationsEPCallback(
[&PB, DebugLogging](LoopPassManager &PM,
PassBuilder::OptimizationLevel Level) {
[&PB](LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
ExitOnError Err("Unable to parse LateLoopOptimizationsEP pipeline: ");
Err(PB.parsePassPipeline(PM, LateLoopOptimizationsEPPipeline,
DebugLogging));
Err(PB.parsePassPipeline(PM, LateLoopOptimizationsEPPipeline));
});
if (tryParsePipelineText<LoopPassManager>(PB, LoopOptimizerEndEPPipeline))
PB.registerLoopOptimizerEndEPCallback(
[&PB, DebugLogging](LoopPassManager &PM,
PassBuilder::OptimizationLevel Level) {
[&PB](LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
ExitOnError Err("Unable to parse LoopOptimizerEndEP pipeline: ");
Err(PB.parsePassPipeline(PM, LoopOptimizerEndEPPipeline,
DebugLogging));
Err(PB.parsePassPipeline(PM, LoopOptimizerEndEPPipeline));
});
if (tryParsePipelineText<FunctionPassManager>(PB,
ScalarOptimizerLateEPPipeline))
PB.registerScalarOptimizerLateEPCallback(
[&PB, DebugLogging](FunctionPassManager &PM,
PassBuilder::OptimizationLevel Level) {
[&PB](FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
ExitOnError Err("Unable to parse ScalarOptimizerLateEP pipeline: ");
Err(PB.parsePassPipeline(PM, ScalarOptimizerLateEPPipeline,
DebugLogging));
Err(PB.parsePassPipeline(PM, ScalarOptimizerLateEPPipeline));
});
if (tryParsePipelineText<CGSCCPassManager>(PB, CGSCCOptimizerLateEPPipeline))
PB.registerCGSCCOptimizerLateEPCallback(
[&PB, DebugLogging](CGSCCPassManager &PM,
PassBuilder::OptimizationLevel Level) {
[&PB](CGSCCPassManager &PM, PassBuilder::OptimizationLevel Level) {
ExitOnError Err("Unable to parse CGSCCOptimizerLateEP pipeline: ");
Err(PB.parsePassPipeline(PM, CGSCCOptimizerLateEPPipeline,
DebugLogging));
Err(PB.parsePassPipeline(PM, CGSCCOptimizerLateEPPipeline));
});
if (tryParsePipelineText<FunctionPassManager>(PB, VectorizerStartEPPipeline))
PB.registerVectorizerStartEPCallback(
[&PB, DebugLogging](FunctionPassManager &PM,
PassBuilder::OptimizationLevel Level) {
[&PB](FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
ExitOnError Err("Unable to parse VectorizerStartEP pipeline: ");
Err(PB.parsePassPipeline(PM, VectorizerStartEPPipeline,
DebugLogging));
Err(PB.parsePassPipeline(PM, VectorizerStartEPPipeline));
});
if (tryParsePipelineText<ModulePassManager>(PB, PipelineStartEPPipeline))
PB.registerPipelineStartEPCallback(
[&PB, DebugLogging](ModulePassManager &PM) {
ExitOnError Err("Unable to parse PipelineStartEP pipeline: ");
Err(PB.parsePassPipeline(PM, PipelineStartEPPipeline, DebugLogging));
});
PB.registerPipelineStartEPCallback([&PB](ModulePassManager &PM) {
ExitOnError Err("Unable to parse PipelineStartEP pipeline: ");
Err(PB.parsePassPipeline(PM, PipelineStartEPPipeline));
});
if (tryParsePipelineText<FunctionPassManager>(PB, OptimizerLastEPPipeline))
PB.registerOptimizerLastEPCallback(
[&PB, DebugLogging](ModulePassManager &PM,
PassBuilder::OptimizationLevel) {
[&PB](ModulePassManager &PM, PassBuilder::OptimizationLevel) {
ExitOnError Err("Unable to parse OptimizerLastEP pipeline: ");
Err(PB.parsePassPipeline(PM, OptimizerLastEPPipeline, DebugLogging));
Err(PB.parsePassPipeline(PM, OptimizerLastEPPipeline));
});
}
@ -269,8 +256,8 @@ bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
// option has been enabled.
PTO.LoopUnrolling = !DisableLoopUnrolling;
PTO.Coroutines = Coroutines;
PassBuilder PB(TM, PTO, P, &PIC);
registerEPCallbacks(PB, DebugPM);
PassBuilder PB(DebugPM, TM, PTO, P, &PIC);
registerEPCallbacks(PB);
// Load requested pass plugins and let them register pass builder callbacks
for (auto &PluginFN : PassPlugins) {
@ -371,9 +358,6 @@ bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
PB.registerLoopAnalyses(LAM);
PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
if (TM)
TM->registerPassBuilderCallbacks(PB, DebugPM);
ModulePassManager MPM(DebugPM);
if (VK > VK_NoVerifier)
MPM.addPass(VerifierPass());
@ -383,7 +367,7 @@ bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
if (!PassPipeline.empty()) {
assert(Passes.empty() &&
"PassPipeline and Passes should not both contain passes");
if (auto Err = PB.parsePassPipeline(MPM, PassPipeline, DebugPM)) {
if (auto Err = PB.parsePassPipeline(MPM, PassPipeline)) {
errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
return false;
}
@ -392,7 +376,7 @@ bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
std::string ModifiedPassName(PassName.begin(), PassName.end());
if (PB.isAnalysisPassName(PassName))
ModifiedPassName = "require<" + ModifiedPassName + ">";
if (auto Err = PB.parsePassPipeline(MPM, ModifiedPassName, DebugPM)) {
if (auto Err = PB.parsePassPipeline(MPM, ModifiedPassName)) {
errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
return false;
}

4
llvm/unittests/IR/PassBuilderCallbacksTest.cpp
View File

@ -439,8 +439,8 @@ protected:
"exit:\n"
" ret void\n"
"}\n")),
CallbacksHandle(),
PB(nullptr, PipelineTuningOptions(), None, &CallbacksHandle.Callbacks),
CallbacksHandle(), PB(false, nullptr, PipelineTuningOptions(), None,
&CallbacksHandle.Callbacks),
PM(true), LAM(true), FAM(true), CGAM(true), AM(true) {
EXPECT_TRUE(&CallbacksHandle.Callbacks ==