1 //===- NewPMDriver.cpp - Driver for opt with new PM -----------------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
10 /// This file is just a split of the code that logically belongs in opt.cpp but
11 /// that includes the new pass manager headers.
13 //===----------------------------------------------------------------------===//
15 #include "NewPMDriver.h"
16 #include "PassPrinters.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/Analysis/AliasAnalysis.h"
19 #include "llvm/Analysis/CGSCCPassManager.h"
20 #include "llvm/Bitcode/BitcodeWriterPass.h"
21 #include "llvm/Config/llvm-config.h"
22 #include "llvm/IR/Dominators.h"
23 #include "llvm/IR/IRPrintingPasses.h"
24 #include "llvm/IR/LLVMContext.h"
25 #include "llvm/IR/Module.h"
26 #include "llvm/IR/PassManager.h"
27 #include "llvm/IR/Verifier.h"
28 #include "llvm/Passes/PassBuilder.h"
29 #include "llvm/Passes/PassPlugin.h"
30 #include "llvm/Passes/StandardInstrumentations.h"
31 #include "llvm/Support/CommandLine.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/ToolOutputFile.h"
34 #include "llvm/Target/TargetMachine.h"
35 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
36 #include "llvm/Transforms/Scalar/LoopPassManager.h"
37 #include "llvm/Transforms/Utils/Debugify.h"
40 using namespace opt_tool;
43 DebugPM("debug-pass-manager", cl::Hidden,
44 cl::desc("Print pass management debugging information"));
46 static cl::list<std::string>
47 PassPlugins("load-pass-plugin",
48 cl::desc("Load passes from plugin library"));
50 // This flag specifies a textual description of the alias analysis pipeline to
51 // use when querying for aliasing information. It only works in concert with
52 // the "passes" flag above.
53 static cl::opt<std::string>
54 AAPipeline("aa-pipeline",
55 cl::desc("A textual description of the alias analysis "
56 "pipeline for handling managed aliasing queries"),
59 /// {{@ These options accept textual pipeline descriptions which will be
60 /// inserted into default pipelines at the respective extension points
61 static cl::opt<std::string> PeepholeEPPipeline(
63 cl::desc("A textual description of the function pass pipeline inserted at "
64 "the Peephole extension points into default pipelines"),
66 static cl::opt<std::string> LateLoopOptimizationsEPPipeline(
67 "passes-ep-late-loop-optimizations",
69 "A textual description of the loop pass pipeline inserted at "
70 "the LateLoopOptimizations extension point into default pipelines"),
72 static cl::opt<std::string> LoopOptimizerEndEPPipeline(
73 "passes-ep-loop-optimizer-end",
74 cl::desc("A textual description of the loop pass pipeline inserted at "
75 "the LoopOptimizerEnd extension point into default pipelines"),
77 static cl::opt<std::string> ScalarOptimizerLateEPPipeline(
78 "passes-ep-scalar-optimizer-late",
79 cl::desc("A textual description of the function pass pipeline inserted at "
80 "the ScalarOptimizerLate extension point into default pipelines"),
82 static cl::opt<std::string> CGSCCOptimizerLateEPPipeline(
83 "passes-ep-cgscc-optimizer-late",
84 cl::desc("A textual description of the cgscc pass pipeline inserted at "
85 "the CGSCCOptimizerLate extension point into default pipelines"),
87 static cl::opt<std::string> VectorizerStartEPPipeline(
88 "passes-ep-vectorizer-start",
89 cl::desc("A textual description of the function pass pipeline inserted at "
90 "the VectorizerStart extension point into default pipelines"),
92 static cl::opt<std::string> PipelineStartEPPipeline(
93 "passes-ep-pipeline-start",
94 cl::desc("A textual description of the function pass pipeline inserted at "
95 "the PipelineStart extension point into default pipelines"),
97 static cl::opt<std::string> OptimizerLastEPPipeline(
98 "passes-ep-optimizer-last",
99 cl::desc("A textual description of the function pass pipeline inserted at "
100 "the OptimizerLast extension point into default pipelines"),
103 extern cl::opt<PGOKind> PGOKindFlag;
104 extern cl::opt<std::string> ProfileFile;
105 extern cl::opt<CSPGOKind> CSPGOKindFlag;
106 extern cl::opt<std::string> CSProfileGenFile;
108 static cl::opt<std::string>
109 ProfileRemappingFile("profile-remapping-file",
110 cl::desc("Path to the profile remapping file."),
112 static cl::opt<bool> DebugInfoForProfiling(
113 "new-pm-debug-info-for-profiling", cl::init(false), cl::Hidden,
114 cl::desc("Emit special debug info to enable PGO profile generation."));
117 template <typename PassManagerT>
118 bool tryParsePipelineText(PassBuilder &PB,
119 const cl::opt<std::string> &PipelineOpt) {
120 if (PipelineOpt.empty())
123 // Verify the pipeline is parseable:
125 if (auto Err = PB.parsePassPipeline(PM, PipelineOpt)) {
126 errs() << "Could not parse -" << PipelineOpt.ArgStr
127 << " pipeline: " << toString(std::move(Err))
128 << "... I'm going to ignore it.\n";
134 /// If one of the EPPipeline command line options was given, register callbacks
135 /// for parsing and inserting the given pipeline
136 static void registerEPCallbacks(PassBuilder &PB, bool VerifyEachPass,
138 if (tryParsePipelineText<FunctionPassManager>(PB, PeepholeEPPipeline))
139 PB.registerPeepholeEPCallback(
140 [&PB, VerifyEachPass, DebugLogging](
141 FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
142 ExitOnError Err("Unable to parse PeepholeEP pipeline: ");
143 Err(PB.parsePassPipeline(PM, PeepholeEPPipeline, VerifyEachPass,
146 if (tryParsePipelineText<LoopPassManager>(PB,
147 LateLoopOptimizationsEPPipeline))
148 PB.registerLateLoopOptimizationsEPCallback(
149 [&PB, VerifyEachPass, DebugLogging](
150 LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
151 ExitOnError Err("Unable to parse LateLoopOptimizationsEP pipeline: ");
152 Err(PB.parsePassPipeline(PM, LateLoopOptimizationsEPPipeline,
153 VerifyEachPass, DebugLogging));
155 if (tryParsePipelineText<LoopPassManager>(PB, LoopOptimizerEndEPPipeline))
156 PB.registerLoopOptimizerEndEPCallback(
157 [&PB, VerifyEachPass, DebugLogging](
158 LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
159 ExitOnError Err("Unable to parse LoopOptimizerEndEP pipeline: ");
160 Err(PB.parsePassPipeline(PM, LoopOptimizerEndEPPipeline,
161 VerifyEachPass, DebugLogging));
163 if (tryParsePipelineText<FunctionPassManager>(PB,
164 ScalarOptimizerLateEPPipeline))
165 PB.registerScalarOptimizerLateEPCallback(
166 [&PB, VerifyEachPass, DebugLogging](
167 FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
168 ExitOnError Err("Unable to parse ScalarOptimizerLateEP pipeline: ");
169 Err(PB.parsePassPipeline(PM, ScalarOptimizerLateEPPipeline,
170 VerifyEachPass, DebugLogging));
172 if (tryParsePipelineText<CGSCCPassManager>(PB, CGSCCOptimizerLateEPPipeline))
173 PB.registerCGSCCOptimizerLateEPCallback(
174 [&PB, VerifyEachPass, DebugLogging](
175 CGSCCPassManager &PM, PassBuilder::OptimizationLevel Level) {
176 ExitOnError Err("Unable to parse CGSCCOptimizerLateEP pipeline: ");
177 Err(PB.parsePassPipeline(PM, CGSCCOptimizerLateEPPipeline,
178 VerifyEachPass, DebugLogging));
180 if (tryParsePipelineText<FunctionPassManager>(PB, VectorizerStartEPPipeline))
181 PB.registerVectorizerStartEPCallback(
182 [&PB, VerifyEachPass, DebugLogging](
183 FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
184 ExitOnError Err("Unable to parse VectorizerStartEP pipeline: ");
185 Err(PB.parsePassPipeline(PM, VectorizerStartEPPipeline,
186 VerifyEachPass, DebugLogging));
188 if (tryParsePipelineText<ModulePassManager>(PB, PipelineStartEPPipeline))
189 PB.registerPipelineStartEPCallback(
190 [&PB, VerifyEachPass, DebugLogging](ModulePassManager &PM) {
191 ExitOnError Err("Unable to parse PipelineStartEP pipeline: ");
192 Err(PB.parsePassPipeline(PM, PipelineStartEPPipeline, VerifyEachPass,
195 if (tryParsePipelineText<FunctionPassManager>(PB, OptimizerLastEPPipeline))
196 PB.registerOptimizerLastEPCallback(
197 [&PB, VerifyEachPass, DebugLogging](FunctionPassManager &PM,
198 PassBuilder::OptimizationLevel) {
199 ExitOnError Err("Unable to parse OptimizerLastEP pipeline: ");
200 Err(PB.parsePassPipeline(PM, OptimizerLastEPPipeline, VerifyEachPass,
205 #define HANDLE_EXTENSION(Ext) \
206 llvm::PassPluginLibraryInfo get##Ext##PluginInfo();
207 #include "llvm/Support/Extension.def"
209 bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
210 ToolOutputFile *Out, ToolOutputFile *ThinLTOLinkOut,
211 ToolOutputFile *OptRemarkFile,
212 StringRef PassPipeline, OutputKind OK,
214 bool ShouldPreserveAssemblyUseListOrder,
215 bool ShouldPreserveBitcodeUseListOrder,
216 bool EmitSummaryIndex, bool EmitModuleHash,
217 bool EnableDebugify) {
218 bool VerifyEachPass = VK == VK_VerifyEachPass;
220 Optional<PGOOptions> P;
221 switch (PGOKindFlag) {
223 P = PGOOptions(ProfileFile, "", "", PGOOptions::IRInstr);
226 P = PGOOptions(ProfileFile, "", ProfileRemappingFile, PGOOptions::IRUse);
229 P = PGOOptions(ProfileFile, "", ProfileRemappingFile,
230 PGOOptions::SampleUse);
233 if (DebugInfoForProfiling)
234 P = PGOOptions("", "", "", PGOOptions::NoAction, PGOOptions::NoCSAction,
239 if (CSPGOKindFlag != NoCSPGO) {
240 if (P && (P->Action == PGOOptions::IRInstr ||
241 P->Action == PGOOptions::SampleUse))
242 errs() << "CSPGOKind cannot be used with IRInstr or SampleUse";
243 if (CSPGOKindFlag == CSInstrGen) {
244 if (CSProfileGenFile.empty())
245 errs() << "CSInstrGen needs to specify CSProfileGenFile";
247 P->CSAction = PGOOptions::CSIRInstr;
248 P->CSProfileGenFile = CSProfileGenFile;
250 P = PGOOptions("", CSProfileGenFile, ProfileRemappingFile,
251 PGOOptions::NoAction, PGOOptions::CSIRInstr);
252 } else /* CSPGOKindFlag == CSInstrUse */ {
254 errs() << "CSInstrUse needs to be together with InstrUse";
255 P->CSAction = PGOOptions::CSIRUse;
258 PassInstrumentationCallbacks PIC;
259 StandardInstrumentations SI;
260 SI.registerCallbacks(PIC);
262 PassBuilder PB(TM, PipelineTuningOptions(), P, &PIC);
263 registerEPCallbacks(PB, VerifyEachPass, DebugPM);
265 // Load requested pass plugins and let them register pass builder callbacks
266 for (auto &PluginFN : PassPlugins) {
267 auto PassPlugin = PassPlugin::Load(PluginFN);
269 errs() << "Failed to load passes from '" << PluginFN
270 << "'. Request ignored.\n";
274 PassPlugin->registerPassBuilderCallbacks(PB);
277 // Register a callback that creates the debugify passes as needed.
278 PB.registerPipelineParsingCallback(
279 [](StringRef Name, ModulePassManager &MPM,
280 ArrayRef<PassBuilder::PipelineElement>) {
281 if (Name == "debugify") {
282 MPM.addPass(NewPMDebugifyPass());
284 } else if (Name == "check-debugify") {
285 MPM.addPass(NewPMCheckDebugifyPass());
291 #define HANDLE_EXTENSION(Ext) \
292 get##Ext##PluginInfo().RegisterPassBuilderCallbacks(PB);
293 #include "llvm/Support/Extension.def"
295 // Specially handle the alias analysis manager so that we can register
296 // a custom pipeline of AA passes with it.
298 if (auto Err = PB.parseAAPipeline(AA, AAPipeline)) {
299 errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
303 LoopAnalysisManager LAM(DebugPM);
304 FunctionAnalysisManager FAM(DebugPM);
305 CGSCCAnalysisManager CGAM(DebugPM);
306 ModuleAnalysisManager MAM(DebugPM);
308 // Register the AA manager first so that our version is the one used.
309 FAM.registerPass([&] { return std::move(AA); });
311 // Register all the basic analyses with the managers.
312 PB.registerModuleAnalyses(MAM);
313 PB.registerCGSCCAnalyses(CGAM);
314 PB.registerFunctionAnalyses(FAM);
315 PB.registerLoopAnalyses(LAM);
316 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
318 ModulePassManager MPM(DebugPM);
319 if (VK > VK_NoVerifier)
320 MPM.addPass(VerifierPass());
322 MPM.addPass(NewPMDebugifyPass());
325 PB.parsePassPipeline(MPM, PassPipeline, VerifyEachPass, DebugPM)) {
326 errs() << Arg0 << ": " << toString(std::move(Err)) << "\n";
330 if (VK > VK_NoVerifier)
331 MPM.addPass(VerifierPass());
333 MPM.addPass(NewPMCheckDebugifyPass());
335 // Add any relevant output pass at the end of the pipeline.
338 break; // No output pass needed.
339 case OK_OutputAssembly:
341 PrintModulePass(Out->os(), "", ShouldPreserveAssemblyUseListOrder));
343 case OK_OutputBitcode:
344 MPM.addPass(BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder,
345 EmitSummaryIndex, EmitModuleHash));
347 case OK_OutputThinLTOBitcode:
348 MPM.addPass(ThinLTOBitcodeWriterPass(
349 Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr));
353 // Before executing passes, print the final values of the LLVM options.
354 cl::PrintOptionValues();
356 // Now that we have all of the passes ready, run them.
360 if (OK != OK_NoOutput) {
362 if (OK == OK_OutputThinLTOBitcode && ThinLTOLinkOut)
363 ThinLTOLinkOut->keep();
367 OptRemarkFile->keep();