1 //===- NewPMDriver.cpp - Driver for opt with new PM -----------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 ///
11 /// This file is just a split of the code that logically belongs in opt.cpp but
12 /// that includes the new pass manager headers.
13 ///
14 //===----------------------------------------------------------------------===//
15 
16 #include "NewPMDriver.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/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/Support/CommandLine.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/ToolOutputFile.h"
32 #include "llvm/Target/TargetMachine.h"
33 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
34 #include "llvm/Transforms/Scalar/LoopPassManager.h"
35 
36 using namespace llvm;
37 using namespace opt_tool;
38 
39 static cl::opt<bool>
40     DebugPM("debug-pass-manager", cl::Hidden,
41             cl::desc("Print pass management debugging information"));
42 
43 // This flag specifies a textual description of the alias analysis pipeline to
44 // use when querying for aliasing information. It only works in concert with
45 // the "passes" flag above.
46 static cl::opt<std::string>
47     AAPipeline("aa-pipeline",
48                cl::desc("A textual description of the alias analysis "
49                         "pipeline for handling managed aliasing queries"),
50                cl::Hidden);
51 
52 /// {{@ These options accept textual pipeline descriptions which will be
53 /// inserted into default pipelines at the respective extension points
54 static cl::opt<std::string> PeepholeEPPipeline(
55     "passes-ep-peephole",
56     cl::desc("A textual description of the function pass pipeline inserted at "
57              "the Peephole extension points into default pipelines"),
58     cl::Hidden);
59 static cl::opt<std::string> LateLoopOptimizationsEPPipeline(
60     "passes-ep-late-loop-optimizations",
61     cl::desc(
62         "A textual description of the loop pass pipeline inserted at "
63         "the LateLoopOptimizations extension point into default pipelines"),
64     cl::Hidden);
65 static cl::opt<std::string> LoopOptimizerEndEPPipeline(
66     "passes-ep-loop-optimizer-end",
67     cl::desc("A textual description of the loop pass pipeline inserted at "
68              "the LoopOptimizerEnd extension point into default pipelines"),
69     cl::Hidden);
70 static cl::opt<std::string> ScalarOptimizerLateEPPipeline(
71     "passes-ep-scalar-optimizer-late",
72     cl::desc("A textual description of the function pass pipeline inserted at "
73              "the ScalarOptimizerLate extension point into default pipelines"),
74     cl::Hidden);
75 static cl::opt<std::string> CGSCCOptimizerLateEPPipeline(
76     "passes-ep-cgscc-optimizer-late",
77     cl::desc("A textual description of the cgscc pass pipeline inserted at "
78              "the CGSCCOptimizerLate extension point into default pipelines"),
79     cl::Hidden);
80 static cl::opt<std::string> VectorizerStartEPPipeline(
81     "passes-ep-vectorizer-start",
82     cl::desc("A textual description of the function pass pipeline inserted at "
83              "the VectorizerStart extension point into default pipelines"),
84     cl::Hidden);
85 enum PGOKind { NoPGO, InstrGen, InstrUse, SampleUse };
86 static cl::opt<PGOKind> PGOKindFlag(
87     "pgo-kind", cl::init(NoPGO), cl::Hidden,
88     cl::desc("The kind of profile guided optimization"),
89     cl::values(clEnumValN(NoPGO, "nopgo", "Do not use PGO."),
90                clEnumValN(InstrGen, "new-pm-pgo-instr-gen-pipeline",
91                           "Instrument the IR to generate profile."),
92                clEnumValN(InstrUse, "new-pm-pgo-instr-use-pipeline",
93                           "Use instrumented profile to guide PGO."),
94                clEnumValN(SampleUse, "new-pm-pgo-sample-use-pipeline",
95                           "Use sampled profile to guide PGO.")));
96 static cl::opt<std::string> ProfileFile(
97     "profile-file", cl::desc("Path to the profile."), cl::Hidden);
98 static cl::opt<bool> DebugInfoForProfiling(
99     "new-pm-debug-info-for-profiling", cl::init(false), cl::Hidden,
100     cl::desc("Emit special debug info to enable PGO profile generation."));
101 /// @}}
102 
103 template <typename PassManagerT>
104 bool tryParsePipelineText(PassBuilder &PB, StringRef PipelineText) {
105   if (PipelineText.empty())
106     return false;
107 
108   // Verify the pipeline is parseable:
109   PassManagerT PM;
110   if (PB.parsePassPipeline(PM, PipelineText))
111     return true;
112 
113   errs() << "Could not parse pipeline '" << PipelineText
114          << "'. I'm going to igore it.\n";
115   return false;
116 }
117 
118 /// If one of the EPPipeline command line options was given, register callbacks
119 /// for parsing and inserting the given pipeline
120 static void registerEPCallbacks(PassBuilder &PB, bool VerifyEachPass,
121                                 bool DebugLogging) {
122   if (tryParsePipelineText<FunctionPassManager>(PB, PeepholeEPPipeline))
123     PB.registerPeepholeEPCallback([&PB, VerifyEachPass, DebugLogging](
124         FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
125       PB.parsePassPipeline(PM, PeepholeEPPipeline, VerifyEachPass,
126                            DebugLogging);
127     });
128   if (tryParsePipelineText<LoopPassManager>(PB,
129                                             LateLoopOptimizationsEPPipeline))
130     PB.registerLateLoopOptimizationsEPCallback(
131         [&PB, VerifyEachPass, DebugLogging](
132             LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
133           PB.parsePassPipeline(PM, LateLoopOptimizationsEPPipeline,
134                                VerifyEachPass, DebugLogging);
135         });
136   if (tryParsePipelineText<LoopPassManager>(PB, LoopOptimizerEndEPPipeline))
137     PB.registerLoopOptimizerEndEPCallback([&PB, VerifyEachPass, DebugLogging](
138         LoopPassManager &PM, PassBuilder::OptimizationLevel Level) {
139       PB.parsePassPipeline(PM, LoopOptimizerEndEPPipeline, VerifyEachPass,
140                            DebugLogging);
141     });
142   if (tryParsePipelineText<FunctionPassManager>(PB,
143                                                 ScalarOptimizerLateEPPipeline))
144     PB.registerScalarOptimizerLateEPCallback(
145         [&PB, VerifyEachPass, DebugLogging](
146             FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
147           PB.parsePassPipeline(PM, ScalarOptimizerLateEPPipeline,
148                                VerifyEachPass, DebugLogging);
149         });
150   if (tryParsePipelineText<CGSCCPassManager>(PB, CGSCCOptimizerLateEPPipeline))
151     PB.registerCGSCCOptimizerLateEPCallback([&PB, VerifyEachPass, DebugLogging](
152         CGSCCPassManager &PM, PassBuilder::OptimizationLevel Level) {
153       PB.parsePassPipeline(PM, CGSCCOptimizerLateEPPipeline, VerifyEachPass,
154                            DebugLogging);
155     });
156   if (tryParsePipelineText<FunctionPassManager>(PB, VectorizerStartEPPipeline))
157     PB.registerVectorizerStartEPCallback([&PB, VerifyEachPass, DebugLogging](
158         FunctionPassManager &PM, PassBuilder::OptimizationLevel Level) {
159       PB.parsePassPipeline(PM, VectorizerStartEPPipeline, VerifyEachPass,
160                            DebugLogging);
161     });
162 }
163 
164 #ifdef LINK_POLLY_INTO_TOOLS
165 namespace polly {
166 void RegisterPollyPasses(PassBuilder &);
167 }
168 #endif
169 
170 bool llvm::runPassPipeline(StringRef Arg0, Module &M, TargetMachine *TM,
171                            tool_output_file *Out,
172                            tool_output_file *ThinLTOLinkOut,
173                            tool_output_file *OptRemarkFile,
174                            StringRef PassPipeline, OutputKind OK,
175                            VerifierKind VK,
176                            bool ShouldPreserveAssemblyUseListOrder,
177                            bool ShouldPreserveBitcodeUseListOrder,
178                            bool EmitSummaryIndex, bool EmitModuleHash) {
179   bool VerifyEachPass = VK == VK_VerifyEachPass;
180 
181   Optional<PGOOptions> P;
182   switch (PGOKindFlag) {
183     case InstrGen:
184       P = PGOOptions(ProfileFile, "", "", true);
185       break;
186     case InstrUse:
187       P = PGOOptions("", ProfileFile, "", false);
188       break;
189     case SampleUse:
190       P = PGOOptions("", "", ProfileFile, false);
191       break;
192     case NoPGO:
193       if (DebugInfoForProfiling)
194         P = PGOOptions("", "", "", false, true);
195       else
196         P = None;
197   }
198   PassBuilder PB(TM, P);
199   registerEPCallbacks(PB, VerifyEachPass, DebugPM);
200 
201 #ifdef LINK_POLLY_INTO_TOOLS
202   polly::RegisterPollyPasses(PB);
203 #endif
204 
205   // Specially handle the alias analysis manager so that we can register
206   // a custom pipeline of AA passes with it.
207   AAManager AA;
208   if (!PB.parseAAPipeline(AA, AAPipeline)) {
209     errs() << Arg0 << ": unable to parse AA pipeline description.\n";
210     return false;
211   }
212 
213   LoopAnalysisManager LAM(DebugPM);
214   FunctionAnalysisManager FAM(DebugPM);
215   CGSCCAnalysisManager CGAM(DebugPM);
216   ModuleAnalysisManager MAM(DebugPM);
217 
218   // Register the AA manager first so that our version is the one used.
219   FAM.registerPass([&] { return std::move(AA); });
220 
221   // Register all the basic analyses with the managers.
222   PB.registerModuleAnalyses(MAM);
223   PB.registerCGSCCAnalyses(CGAM);
224   PB.registerFunctionAnalyses(FAM);
225   PB.registerLoopAnalyses(LAM);
226   PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
227 
228   ModulePassManager MPM(DebugPM);
229   if (VK > VK_NoVerifier)
230     MPM.addPass(VerifierPass());
231 
232   if (!PB.parsePassPipeline(MPM, PassPipeline, VerifyEachPass, DebugPM)) {
233     errs() << Arg0 << ": unable to parse pass pipeline description.\n";
234     return false;
235   }
236 
237   if (VK > VK_NoVerifier)
238     MPM.addPass(VerifierPass());
239 
240   // Add any relevant output pass at the end of the pipeline.
241   switch (OK) {
242   case OK_NoOutput:
243     break; // No output pass needed.
244   case OK_OutputAssembly:
245     MPM.addPass(
246         PrintModulePass(Out->os(), "", ShouldPreserveAssemblyUseListOrder));
247     break;
248   case OK_OutputBitcode:
249     MPM.addPass(BitcodeWriterPass(Out->os(), ShouldPreserveBitcodeUseListOrder,
250                                   EmitSummaryIndex, EmitModuleHash));
251     break;
252   case OK_OutputThinLTOBitcode:
253     MPM.addPass(ThinLTOBitcodeWriterPass(
254         Out->os(), ThinLTOLinkOut ? &ThinLTOLinkOut->os() : nullptr));
255     break;
256   }
257 
258   // Before executing passes, print the final values of the LLVM options.
259   cl::PrintOptionValues();
260 
261   // Now that we have all of the passes ready, run them.
262   MPM.run(M, MAM);
263 
264   // Declare success.
265   if (OK != OK_NoOutput) {
266     Out->keep();
267     if (OK == OK_OutputThinLTOBitcode && ThinLTOLinkOut)
268       ThinLTOLinkOut->keep();
269   }
270 
271   if (OptRemarkFile)
272     OptRemarkFile->keep();
273 
274   return true;
275 }
276