1 //===- opt.cpp - The LLVM Modular Optimizer -------------------------------===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Optimizations may be specified an arbitrary number of times on the command
10 // line, They are run in the order specified.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "BreakpointPrinter.h"
15 #include "NewPMDriver.h"
16 #include "PassPrinters.h"
17 #include "llvm/ADT/Triple.h"
18 #include "llvm/Analysis/CallGraph.h"
19 #include "llvm/Analysis/CallGraphSCCPass.h"
20 #include "llvm/Analysis/LoopPass.h"
21 #include "llvm/Analysis/RegionPass.h"
22 #include "llvm/Analysis/TargetLibraryInfo.h"
23 #include "llvm/Analysis/TargetTransformInfo.h"
24 #include "llvm/AsmParser/Parser.h"
25 #include "llvm/CodeGen/CommandFlags.h"
26 #include "llvm/CodeGen/TargetPassConfig.h"
27 #include "llvm/Config/llvm-config.h"
28 #include "llvm/IR/DataLayout.h"
29 #include "llvm/IR/DebugInfo.h"
30 #include "llvm/IR/LLVMContext.h"
31 #include "llvm/IR/LLVMRemarkStreamer.h"
32 #include "llvm/IR/LegacyPassManager.h"
33 #include "llvm/IR/LegacyPassNameParser.h"
34 #include "llvm/IR/Module.h"
35 #include "llvm/IR/Verifier.h"
36 #include "llvm/IRReader/IRReader.h"
37 #include "llvm/InitializePasses.h"
38 #include "llvm/LinkAllIR.h"
39 #include "llvm/LinkAllPasses.h"
40 #include "llvm/MC/SubtargetFeature.h"
41 #include "llvm/MC/TargetRegistry.h"
42 #include "llvm/Remarks/HotnessThresholdParser.h"
43 #include "llvm/Support/Debug.h"
44 #include "llvm/Support/FileSystem.h"
45 #include "llvm/Support/Host.h"
46 #include "llvm/Support/InitLLVM.h"
47 #include "llvm/Support/PluginLoader.h"
48 #include "llvm/Support/SourceMgr.h"
49 #include "llvm/Support/SystemUtils.h"
50 #include "llvm/Support/TargetSelect.h"
51 #include "llvm/Support/ToolOutputFile.h"
52 #include "llvm/Support/YAMLTraits.h"
53 #include "llvm/Target/TargetMachine.h"
54 #include "llvm/Transforms/Coroutines.h"
55 #include "llvm/Transforms/IPO/AlwaysInliner.h"
56 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
57 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
58 #include "llvm/Transforms/Utils/Cloning.h"
59 #include "llvm/Transforms/Utils/Debugify.h"
60 #include <algorithm>
61 #include <memory>
62 using namespace llvm;
63 using namespace opt_tool;
64 
65 static codegen::RegisterCodeGenFlags CFG;
66 
67 // The OptimizationList is automatically populated with registered Passes by the
68 // PassNameParser.
69 static cl::list<const PassInfo *, bool, PassNameParser> PassList(cl::desc(
70     "Optimizations available (use '-passes=' for the new pass manager)"));
71 
72 static cl::opt<bool> EnableNewPassManager(
73     "enable-new-pm",
74     cl::desc("Enable the new pass manager, translating "
75              "'opt -foo' to 'opt -passes=foo'. This is strictly for the new PM "
76              "migration, use '-passes=' when possible."),
77     cl::init(LLVM_ENABLE_NEW_PASS_MANAGER));
78 
79 // This flag specifies a textual description of the optimization pass pipeline
80 // to run over the module. This flag switches opt to use the new pass manager
81 // infrastructure, completely disabling all of the flags specific to the old
82 // pass management.
83 static cl::opt<std::string> PassPipeline(
84     "passes",
85     cl::desc(
86         "A textual description of the pass pipeline. To have analysis passes "
87         "available before a certain pass, add 'require<foo-analysis>'."));
88 
89 static cl::opt<bool> PrintPasses("print-passes",
90                                  cl::desc("Print available passes that can be "
91                                           "specified in -passes=foo and exit"));
92 
93 static cl::opt<std::string>
94 InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
95     cl::init("-"), cl::value_desc("filename"));
96 
97 static cl::opt<std::string>
98 OutputFilename("o", cl::desc("Override output filename"),
99                cl::value_desc("filename"));
100 
101 static cl::opt<bool>
102 Force("f", cl::desc("Enable binary output on terminals"));
103 
104 static cl::opt<bool>
105 NoOutput("disable-output",
106          cl::desc("Do not write result bitcode file"), cl::Hidden);
107 
108 static cl::opt<bool>
109 OutputAssembly("S", cl::desc("Write output as LLVM assembly"));
110 
111 static cl::opt<bool>
112     OutputThinLTOBC("thinlto-bc",
113                     cl::desc("Write output as ThinLTO-ready bitcode"));
114 
115 static cl::opt<bool>
116     SplitLTOUnit("thinlto-split-lto-unit",
117                  cl::desc("Enable splitting of a ThinLTO LTOUnit"));
118 
119 static cl::opt<std::string> ThinLinkBitcodeFile(
120     "thin-link-bitcode-file", cl::value_desc("filename"),
121     cl::desc(
122         "A file in which to write minimized bitcode for the thin link only"));
123 
124 static cl::opt<bool>
125 NoVerify("disable-verify", cl::desc("Do not run the verifier"), cl::Hidden);
126 
127 static cl::opt<bool> NoUpgradeDebugInfo("disable-upgrade-debug-info",
128                                         cl::desc("Generate invalid output"),
129                                         cl::ReallyHidden);
130 
131 static cl::opt<bool> VerifyEach("verify-each",
132                                 cl::desc("Verify after each transform"));
133 
134 static cl::opt<bool>
135     DisableDITypeMap("disable-debug-info-type-map",
136                      cl::desc("Don't use a uniquing type map for debug info"));
137 
138 static cl::opt<bool>
139 StripDebug("strip-debug",
140            cl::desc("Strip debugger symbol info from translation unit"));
141 
142 static cl::opt<bool>
143     StripNamedMetadata("strip-named-metadata",
144                        cl::desc("Strip module-level named metadata"));
145 
146 
147 
148 static cl::opt<bool>
149     OptLevelO0("O0", cl::desc("Optimization level 0. Similar to clang -O0. "
150                               "Use -passes='default<O0>' for the new PM"));
151 
152 static cl::opt<bool>
153     OptLevelO1("O1", cl::desc("Optimization level 1. Similar to clang -O1. "
154                               "Use -passes='default<O1>' for the new PM"));
155 
156 static cl::opt<bool>
157     OptLevelO2("O2", cl::desc("Optimization level 2. Similar to clang -O2. "
158                               "Use -passes='default<O2>' for the new PM"));
159 
160 static cl::opt<bool>
161     OptLevelOs("Os", cl::desc("Like -O2 but size-conscious. Similar to clang "
162                               "-Os. Use -passes='default<Os>' for the new PM"));
163 
164 static cl::opt<bool> OptLevelOz(
165     "Oz",
166     cl::desc("Like -O2 but optimize for code size above all else. Similar to "
167              "clang -Oz. Use -passes='default<Oz>' for the new PM"));
168 
169 static cl::opt<bool>
170     OptLevelO3("O3", cl::desc("Optimization level 3. Similar to clang -O3. "
171                               "Use -passes='default<O3>' for the new PM"));
172 
173 static cl::opt<unsigned> CodeGenOptLevel(
174     "codegen-opt-level",
175     cl::desc("Override optimization level for codegen hooks, legacy PM only"));
176 
177 static cl::opt<std::string>
178 TargetTriple("mtriple", cl::desc("Override target triple for module"));
179 
180 cl::opt<bool> DisableLoopUnrolling(
181     "disable-loop-unrolling",
182     cl::desc("Disable loop unrolling in all relevant passes"), cl::init(false));
183 
184 static cl::opt<bool> EmitSummaryIndex("module-summary",
185                                       cl::desc("Emit module summary index"),
186                                       cl::init(false));
187 
188 static cl::opt<bool> EmitModuleHash("module-hash", cl::desc("Emit module hash"),
189                                     cl::init(false));
190 
191 static cl::opt<bool>
192 DisableSimplifyLibCalls("disable-simplify-libcalls",
193                         cl::desc("Disable simplify-libcalls"));
194 
195 static cl::list<std::string>
196 DisableBuiltins("disable-builtin",
197                 cl::desc("Disable specific target library builtin function"),
198                 cl::ZeroOrMore);
199 
200 static cl::opt<bool>
201     AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization. "
202                                     "Legacy pass manager only."));
203 
204 static cl::opt<bool> EnableDebugify(
205     "enable-debugify",
206     cl::desc(
207         "Start the pipeline with debugify and end it with check-debugify"));
208 
209 static cl::opt<bool> VerifyDebugInfoPreserve(
210     "verify-debuginfo-preserve",
211     cl::desc("Start the pipeline with collecting and end it with checking of "
212              "debug info preservation."));
213 
214 static cl::opt<bool> VerifyEachDebugInfoPreserve(
215     "verify-each-debuginfo-preserve",
216     cl::desc("Start each pass with collecting and end it with checking of "
217              "debug info preservation."));
218 
219 static cl::opt<std::string>
220     VerifyDIPreserveExport("verify-di-preserve-export",
221                    cl::desc("Export debug info preservation failures into "
222                             "specified (JSON) file (should be abs path as we use"
223                             " append mode to insert new JSON objects)"),
224                    cl::value_desc("filename"), cl::init(""));
225 
226 static cl::opt<bool>
227 PrintBreakpoints("print-breakpoints-for-testing",
228                  cl::desc("Print select breakpoints location for testing"));
229 
230 static cl::opt<std::string> ClDataLayout("data-layout",
231                                          cl::desc("data layout string to use"),
232                                          cl::value_desc("layout-string"),
233                                          cl::init(""));
234 
235 static cl::opt<bool> PreserveBitcodeUseListOrder(
236     "preserve-bc-uselistorder",
237     cl::desc("Preserve use-list order when writing LLVM bitcode."),
238     cl::init(true), cl::Hidden);
239 
240 static cl::opt<bool> PreserveAssemblyUseListOrder(
241     "preserve-ll-uselistorder",
242     cl::desc("Preserve use-list order when writing LLVM assembly."),
243     cl::init(false), cl::Hidden);
244 
245 static cl::opt<bool> RunTwice("run-twice",
246                               cl::desc("Run all passes twice, re-using the "
247                                        "same pass manager (legacy PM only)."),
248                               cl::init(false), cl::Hidden);
249 
250 static cl::opt<bool> DiscardValueNames(
251     "discard-value-names",
252     cl::desc("Discard names from Value (other than GlobalValue)."),
253     cl::init(false), cl::Hidden);
254 
255 static cl::opt<bool> Coroutines(
256   "enable-coroutines",
257   cl::desc("Enable coroutine passes."),
258   cl::init(false), cl::Hidden);
259 
260 static cl::opt<bool> TimeTrace(
261     "time-trace",
262     cl::desc("Record time trace"));
263 
264 static cl::opt<unsigned> TimeTraceGranularity(
265     "time-trace-granularity",
266     cl::desc("Minimum time granularity (in microseconds) traced by time profiler"),
267     cl::init(500), cl::Hidden);
268 
269 static cl::opt<std::string>
270     TimeTraceFile("time-trace-file",
271                     cl::desc("Specify time trace file destination"),
272                     cl::value_desc("filename"));
273 
274 static cl::opt<bool> RemarksWithHotness(
275     "pass-remarks-with-hotness",
276     cl::desc("With PGO, include profile count in optimization remarks"),
277     cl::Hidden);
278 
279 static cl::opt<Optional<uint64_t>, false, remarks::HotnessThresholdParser>
280     RemarksHotnessThreshold(
281         "pass-remarks-hotness-threshold",
282         cl::desc("Minimum profile count required for "
283                  "an optimization remark to be output. "
284                  "Use 'auto' to apply the threshold from profile summary."),
285         cl::value_desc("N or 'auto'"), cl::init(0), cl::Hidden);
286 
287 static cl::opt<std::string>
288     RemarksFilename("pass-remarks-output",
289                     cl::desc("Output filename for pass remarks"),
290                     cl::value_desc("filename"));
291 
292 static cl::opt<std::string>
293     RemarksPasses("pass-remarks-filter",
294                   cl::desc("Only record optimization remarks from passes whose "
295                            "names match the given regular expression"),
296                   cl::value_desc("regex"));
297 
298 static cl::opt<std::string> RemarksFormat(
299     "pass-remarks-format",
300     cl::desc("The format used for serializing remarks (default: YAML)"),
301     cl::value_desc("format"), cl::init("yaml"));
302 
303 namespace llvm {
304 cl::opt<PGOKind>
305     PGOKindFlag("pgo-kind", cl::init(NoPGO), cl::Hidden,
306                 cl::desc("The kind of profile guided optimization"),
307                 cl::values(clEnumValN(NoPGO, "nopgo", "Do not use PGO."),
308                            clEnumValN(InstrGen, "pgo-instr-gen-pipeline",
309                                       "Instrument the IR to generate profile."),
310                            clEnumValN(InstrUse, "pgo-instr-use-pipeline",
311                                       "Use instrumented profile to guide PGO."),
312                            clEnumValN(SampleUse, "pgo-sample-use-pipeline",
313                                       "Use sampled profile to guide PGO.")));
314 cl::opt<std::string> ProfileFile("profile-file",
315                                  cl::desc("Path to the profile."), cl::Hidden);
316 
317 cl::opt<CSPGOKind> CSPGOKindFlag(
318     "cspgo-kind", cl::init(NoCSPGO), cl::Hidden,
319     cl::desc("The kind of context sensitive profile guided optimization"),
320     cl::values(
321         clEnumValN(NoCSPGO, "nocspgo", "Do not use CSPGO."),
322         clEnumValN(
323             CSInstrGen, "cspgo-instr-gen-pipeline",
324             "Instrument (context sensitive) the IR to generate profile."),
325         clEnumValN(
326             CSInstrUse, "cspgo-instr-use-pipeline",
327             "Use instrumented (context sensitive) profile to guide PGO.")));
328 cl::opt<std::string> CSProfileGenFile(
329     "cs-profilegen-file",
330     cl::desc("Path to the instrumented context sensitive profile."),
331     cl::Hidden);
332 } // namespace llvm
333 
334 static inline void addPass(legacy::PassManagerBase &PM, Pass *P) {
335   // Add the pass to the pass manager...
336   PM.add(P);
337 
338   // If we are verifying all of the intermediate steps, add the verifier...
339   if (VerifyEach)
340     PM.add(createVerifierPass());
341 }
342 
343 /// This routine adds optimization passes based on selected optimization level,
344 /// OptLevel.
345 ///
346 /// OptLevel - Optimization Level
347 static void AddOptimizationPasses(legacy::PassManagerBase &MPM,
348                                   legacy::FunctionPassManager &FPM,
349                                   TargetMachine *TM, unsigned OptLevel,
350                                   unsigned SizeLevel) {
351   if (!NoVerify || VerifyEach)
352     FPM.add(createVerifierPass()); // Verify that input is correct
353 
354   PassManagerBuilder Builder;
355   Builder.OptLevel = OptLevel;
356   Builder.SizeLevel = SizeLevel;
357 
358   if (OptLevel > 1) {
359     Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel, false);
360   } else {
361     Builder.Inliner = createAlwaysInlinerLegacyPass();
362   }
363   Builder.DisableUnrollLoops = (DisableLoopUnrolling.getNumOccurrences() > 0) ?
364                                DisableLoopUnrolling : OptLevel == 0;
365 
366   Builder.LoopVectorize = OptLevel > 1 && SizeLevel < 2;
367 
368   Builder.SLPVectorize = OptLevel > 1 && SizeLevel < 2;
369 
370   if (TM)
371     TM->adjustPassManager(Builder);
372 
373   if (Coroutines)
374     addCoroutinePassesToExtensionPoints(Builder);
375 
376   switch (PGOKindFlag) {
377   case InstrGen:
378     Builder.EnablePGOInstrGen = true;
379     Builder.PGOInstrGen = ProfileFile;
380     break;
381   case InstrUse:
382     Builder.PGOInstrUse = ProfileFile;
383     break;
384   case SampleUse:
385     Builder.PGOSampleUse = ProfileFile;
386     break;
387   default:
388     break;
389   }
390 
391   switch (CSPGOKindFlag) {
392   case CSInstrGen:
393     Builder.EnablePGOCSInstrGen = true;
394     break;
395   case CSInstrUse:
396     Builder.EnablePGOCSInstrUse = true;
397     break;
398   default:
399     break;
400   }
401 
402   Builder.populateFunctionPassManager(FPM);
403   Builder.populateModulePassManager(MPM);
404 }
405 
406 //===----------------------------------------------------------------------===//
407 // CodeGen-related helper functions.
408 //
409 
410 static CodeGenOpt::Level GetCodeGenOptLevel() {
411   if (CodeGenOptLevel.getNumOccurrences())
412     return static_cast<CodeGenOpt::Level>(unsigned(CodeGenOptLevel));
413   if (OptLevelO1)
414     return CodeGenOpt::Less;
415   if (OptLevelO2)
416     return CodeGenOpt::Default;
417   if (OptLevelO3)
418     return CodeGenOpt::Aggressive;
419   return CodeGenOpt::None;
420 }
421 
422 // Returns the TargetMachine instance or zero if no triple is provided.
423 static TargetMachine* GetTargetMachine(Triple TheTriple, StringRef CPUStr,
424                                        StringRef FeaturesStr,
425                                        const TargetOptions &Options) {
426   std::string Error;
427   const Target *TheTarget =
428       TargetRegistry::lookupTarget(codegen::getMArch(), TheTriple, Error);
429   // Some modules don't specify a triple, and this is okay.
430   if (!TheTarget) {
431     return nullptr;
432   }
433 
434   return TheTarget->createTargetMachine(
435       TheTriple.getTriple(), codegen::getCPUStr(), codegen::getFeaturesStr(),
436       Options, codegen::getExplicitRelocModel(),
437       codegen::getExplicitCodeModel(), GetCodeGenOptLevel());
438 }
439 
440 #ifdef BUILD_EXAMPLES
441 void initializeExampleIRTransforms(llvm::PassRegistry &Registry);
442 #endif
443 
444 struct TimeTracerRAII {
445   TimeTracerRAII(StringRef ProgramName) {
446     if (TimeTrace)
447       timeTraceProfilerInitialize(TimeTraceGranularity, ProgramName);
448   }
449   ~TimeTracerRAII() {
450     if (TimeTrace) {
451       if (auto E = timeTraceProfilerWrite(TimeTraceFile, OutputFilename)) {
452         handleAllErrors(std::move(E), [&](const StringError &SE) {
453           errs() << SE.getMessage() << "\n";
454         });
455         return;
456       }
457       timeTraceProfilerCleanup();
458     }
459   }
460 };
461 
462 // For use in NPM transition. Currently this contains most codegen-specific
463 // passes. Remove passes from here when porting to the NPM.
464 // TODO: use a codegen version of PassRegistry.def/PassBuilder::is*Pass() once
465 // it exists.
466 static bool shouldPinPassToLegacyPM(StringRef Pass) {
467   std::vector<StringRef> PassNameExactToIgnore = {
468       "nvvm-reflect",
469       "nvvm-intr-range",
470       "amdgpu-simplifylib",
471       "amdgpu-usenative",
472       "amdgpu-promote-alloca",
473       "amdgpu-promote-alloca-to-vector",
474       "amdgpu-lower-kernel-attributes",
475       "amdgpu-propagate-attributes-early",
476       "amdgpu-propagate-attributes-late",
477       "amdgpu-unify-metadata",
478       "amdgpu-printf-runtime-binding",
479       "amdgpu-always-inline"};
480   if (llvm::is_contained(PassNameExactToIgnore, Pass))
481     return false;
482 
483   std::vector<StringRef> PassNamePrefix = {
484       "x86-",    "xcore-", "wasm-",  "systemz-", "ppc-",    "nvvm-",
485       "nvptx-",  "mips-",  "lanai-", "hexagon-", "bpf-",    "avr-",
486       "thumb2-", "arm-",   "si-",    "gcn-",     "amdgpu-", "aarch64-",
487       "amdgcn-", "polly-", "riscv-"};
488   std::vector<StringRef> PassNameContain = {"ehprepare"};
489   std::vector<StringRef> PassNameExact = {
490       "safe-stack",           "cost-model",
491       "codegenprepare",       "interleaved-load-combine",
492       "unreachableblockelim", "verify-safepoint-ir",
493       "atomic-expand",        "expandvp",
494       "hardware-loops",       "type-promotion",
495       "mve-tail-predication", "interleaved-access",
496       "global-merge",         "pre-isel-intrinsic-lowering",
497       "expand-reductions",    "indirectbr-expand",
498       "generic-to-nvvm",      "expandmemcmp",
499       "loop-reduce",          "lower-amx-type",
500       "pre-amx-config",       "lower-amx-intrinsics",
501       "polyhedral-info",      "replace-with-veclib"};
502   for (const auto &P : PassNamePrefix)
503     if (Pass.startswith(P))
504       return true;
505   for (const auto &P : PassNameContain)
506     if (Pass.contains(P))
507       return true;
508   return llvm::is_contained(PassNameExact, Pass);
509 }
510 
511 // For use in NPM transition.
512 static bool shouldForceLegacyPM() {
513   for (const auto &P : PassList) {
514     StringRef Arg = P->getPassArgument();
515     if (shouldPinPassToLegacyPM(Arg))
516       return true;
517   }
518   return false;
519 }
520 
521 //===----------------------------------------------------------------------===//
522 // main for opt
523 //
524 int main(int argc, char **argv) {
525   InitLLVM X(argc, argv);
526 
527   // Enable debug stream buffering.
528   EnableDebugBuffering = true;
529 
530   InitializeAllTargets();
531   InitializeAllTargetMCs();
532   InitializeAllAsmPrinters();
533   InitializeAllAsmParsers();
534 
535   // Initialize passes
536   PassRegistry &Registry = *PassRegistry::getPassRegistry();
537   initializeCore(Registry);
538   initializeCoroutines(Registry);
539   initializeScalarOpts(Registry);
540   initializeObjCARCOpts(Registry);
541   initializeVectorization(Registry);
542   initializeIPO(Registry);
543   initializeAnalysis(Registry);
544   initializeTransformUtils(Registry);
545   initializeInstCombine(Registry);
546   initializeAggressiveInstCombine(Registry);
547   initializeInstrumentation(Registry);
548   initializeTarget(Registry);
549   // For codegen passes, only passes that do IR to IR transformation are
550   // supported.
551   initializeExpandMemCmpPassPass(Registry);
552   initializeScalarizeMaskedMemIntrinLegacyPassPass(Registry);
553   initializeCodeGenPreparePass(Registry);
554   initializeAtomicExpandPass(Registry);
555   initializeRewriteSymbolsLegacyPassPass(Registry);
556   initializeWinEHPreparePass(Registry);
557   initializeDwarfEHPrepareLegacyPassPass(Registry);
558   initializeSafeStackLegacyPassPass(Registry);
559   initializeSjLjEHPreparePass(Registry);
560   initializePreISelIntrinsicLoweringLegacyPassPass(Registry);
561   initializeGlobalMergePass(Registry);
562   initializeIndirectBrExpandPassPass(Registry);
563   initializeInterleavedLoadCombinePass(Registry);
564   initializeInterleavedAccessPass(Registry);
565   initializeEntryExitInstrumenterPass(Registry);
566   initializePostInlineEntryExitInstrumenterPass(Registry);
567   initializeUnreachableBlockElimLegacyPassPass(Registry);
568   initializeExpandReductionsPass(Registry);
569   initializeExpandVectorPredicationPass(Registry);
570   initializeWasmEHPreparePass(Registry);
571   initializeWriteBitcodePassPass(Registry);
572   initializeHardwareLoopsPass(Registry);
573   initializeTypePromotionPass(Registry);
574   initializeReplaceWithVeclibLegacyPass(Registry);
575 
576 #ifdef BUILD_EXAMPLES
577   initializeExampleIRTransforms(Registry);
578 #endif
579 
580   cl::ParseCommandLineOptions(argc, argv,
581     "llvm .bc -> .bc modular optimizer and analysis printer\n");
582 
583   LLVMContext Context;
584 
585   if (AnalyzeOnly && NoOutput) {
586     errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n";
587     return 1;
588   }
589 
590   // FIXME: once the legacy PM code is deleted, move runPassPipeline() here and
591   // construct the PassBuilder before parsing IR so we can reuse the same
592   // PassBuilder for print passes.
593   if (PrintPasses) {
594     printPasses(outs());
595     return 0;
596   }
597 
598   TimeTracerRAII TimeTracer(argv[0]);
599 
600   SMDiagnostic Err;
601 
602   Context.setDiscardValueNames(DiscardValueNames);
603   if (!DisableDITypeMap)
604     Context.enableDebugTypeODRUniquing();
605 
606   Expected<std::unique_ptr<ToolOutputFile>> RemarksFileOrErr =
607       setupLLVMOptimizationRemarks(Context, RemarksFilename, RemarksPasses,
608                                    RemarksFormat, RemarksWithHotness,
609                                    RemarksHotnessThreshold);
610   if (Error E = RemarksFileOrErr.takeError()) {
611     errs() << toString(std::move(E)) << '\n';
612     return 1;
613   }
614   std::unique_ptr<ToolOutputFile> RemarksFile = std::move(*RemarksFileOrErr);
615 
616   // Load the input module...
617   auto SetDataLayout = [](StringRef) -> Optional<std::string> {
618     if (ClDataLayout.empty())
619       return None;
620     return ClDataLayout;
621   };
622   std::unique_ptr<Module> M;
623   if (NoUpgradeDebugInfo)
624     M = parseAssemblyFileWithIndexNoUpgradeDebugInfo(
625             InputFilename, Err, Context, nullptr, SetDataLayout)
626             .Mod;
627   else
628     M = parseIRFile(InputFilename, Err, Context, SetDataLayout);
629 
630   if (!M) {
631     Err.print(argv[0], errs());
632     return 1;
633   }
634 
635   // Strip debug info before running the verifier.
636   if (StripDebug)
637     StripDebugInfo(*M);
638 
639   // Erase module-level named metadata, if requested.
640   if (StripNamedMetadata) {
641     while (!M->named_metadata_empty()) {
642       NamedMDNode *NMD = &*M->named_metadata_begin();
643       M->eraseNamedMetadata(NMD);
644     }
645   }
646 
647   // If we are supposed to override the target triple or data layout, do so now.
648   if (!TargetTriple.empty())
649     M->setTargetTriple(Triple::normalize(TargetTriple));
650 
651   // Immediately run the verifier to catch any problems before starting up the
652   // pass pipelines.  Otherwise we can crash on broken code during
653   // doInitialization().
654   if (!NoVerify && verifyModule(*M, &errs())) {
655     errs() << argv[0] << ": " << InputFilename
656            << ": error: input module is broken!\n";
657     return 1;
658   }
659 
660   // Enable testing of whole program devirtualization on this module by invoking
661   // the facility for updating public visibility to linkage unit visibility when
662   // specified by an internal option. This is normally done during LTO which is
663   // not performed via opt.
664   updateVCallVisibilityInModule(*M,
665                                 /* WholeProgramVisibilityEnabledInLTO */ false,
666                                 /* DynamicExportSymbols */ {});
667 
668   // Figure out what stream we are supposed to write to...
669   std::unique_ptr<ToolOutputFile> Out;
670   std::unique_ptr<ToolOutputFile> ThinLinkOut;
671   if (NoOutput) {
672     if (!OutputFilename.empty())
673       errs() << "WARNING: The -o (output filename) option is ignored when\n"
674                 "the --disable-output option is used.\n";
675   } else {
676     // Default to standard output.
677     if (OutputFilename.empty())
678       OutputFilename = "-";
679 
680     std::error_code EC;
681     sys::fs::OpenFlags Flags =
682         OutputAssembly ? sys::fs::OF_TextWithCRLF : sys::fs::OF_None;
683     Out.reset(new ToolOutputFile(OutputFilename, EC, Flags));
684     if (EC) {
685       errs() << EC.message() << '\n';
686       return 1;
687     }
688 
689     if (!ThinLinkBitcodeFile.empty()) {
690       ThinLinkOut.reset(
691           new ToolOutputFile(ThinLinkBitcodeFile, EC, sys::fs::OF_None));
692       if (EC) {
693         errs() << EC.message() << '\n';
694         return 1;
695       }
696     }
697   }
698 
699   Triple ModuleTriple(M->getTargetTriple());
700   std::string CPUStr, FeaturesStr;
701   TargetMachine *Machine = nullptr;
702   const TargetOptions Options =
703       codegen::InitTargetOptionsFromCodeGenFlags(ModuleTriple);
704 
705   if (ModuleTriple.getArch()) {
706     CPUStr = codegen::getCPUStr();
707     FeaturesStr = codegen::getFeaturesStr();
708     Machine = GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr, Options);
709   } else if (ModuleTriple.getArchName() != "unknown" &&
710              ModuleTriple.getArchName() != "") {
711     errs() << argv[0] << ": unrecognized architecture '"
712            << ModuleTriple.getArchName() << "' provided.\n";
713     return 1;
714   }
715 
716   std::unique_ptr<TargetMachine> TM(Machine);
717 
718   // Override function attributes based on CPUStr, FeaturesStr, and command line
719   // flags.
720   codegen::setFunctionAttributes(CPUStr, FeaturesStr, *M);
721 
722   // If the output is set to be emitted to standard out, and standard out is a
723   // console, print out a warning message and refuse to do it.  We don't
724   // impress anyone by spewing tons of binary goo to a terminal.
725   if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly)
726     if (CheckBitcodeOutputToConsole(Out->os()))
727       NoOutput = true;
728 
729   if (OutputThinLTOBC)
730     M->addModuleFlag(Module::Error, "EnableSplitLTOUnit", SplitLTOUnit);
731 
732   // Add an appropriate TargetLibraryInfo pass for the module's triple.
733   TargetLibraryInfoImpl TLII(ModuleTriple);
734 
735   // The -disable-simplify-libcalls flag actually disables all builtin optzns.
736   if (DisableSimplifyLibCalls)
737     TLII.disableAllFunctions();
738   else {
739     // Disable individual builtin functions in TargetLibraryInfo.
740     LibFunc F;
741     for (auto &FuncName : DisableBuiltins)
742       if (TLII.getLibFunc(FuncName, F))
743         TLII.setUnavailable(F);
744       else {
745         errs() << argv[0] << ": cannot disable nonexistent builtin function "
746                << FuncName << '\n';
747         return 1;
748       }
749   }
750 
751   // If `-passes=` is specified, use NPM.
752   // If `-enable-new-pm` is specified and there are no codegen passes, use NPM.
753   // e.g. `-enable-new-pm -sroa` will use NPM.
754   // but `-enable-new-pm -codegenprepare` will still revert to legacy PM.
755   if ((EnableNewPassManager && !shouldForceLegacyPM()) ||
756       PassPipeline.getNumOccurrences() > 0) {
757     if (AnalyzeOnly) {
758       errs() << "Cannot specify -analyze under new pass manager, either "
759                 "specify '-enable-new-pm=0', or use the corresponding new pass "
760                 "manager pass, e.g. '-passes=print<scalar-evolution>'. For a "
761                 "full list of passes, see the '--print-passes' flag.\n";
762       return 1;
763     }
764     if (legacy::debugPassSpecified()) {
765       errs()
766           << "-debug-pass does not work with the new PM, either use "
767              "-debug-pass-manager, or use the legacy PM (-enable-new-pm=0)\n";
768       return 1;
769     }
770     if (PassPipeline.getNumOccurrences() > 0 && PassList.size() > 0) {
771       errs()
772           << "Cannot specify passes via both -foo-pass and --passes=foo-pass\n";
773       return 1;
774     }
775     auto NumOLevel = OptLevelO0 + OptLevelO1 + OptLevelO2 + OptLevelO3 +
776                      OptLevelOs + OptLevelOz;
777     if (NumOLevel > 1) {
778       errs() << "Cannot specify multiple -O#\n";
779       return 1;
780     }
781     if (NumOLevel > 0 && PassPipeline.getNumOccurrences() > 0) {
782       errs() << "Cannot specify -O# and --passes=, use "
783                 "-passes='default<O#>,other-pass'\n";
784       return 1;
785     }
786     std::string Pipeline = PassPipeline;
787 
788     SmallVector<StringRef, 4> Passes;
789     if (OptLevelO0)
790       Pipeline = "default<O0>";
791     if (OptLevelO1)
792       Pipeline = "default<O1>";
793     if (OptLevelO2)
794       Pipeline = "default<O2>";
795     if (OptLevelO3)
796       Pipeline = "default<O3>";
797     if (OptLevelOs)
798       Pipeline = "default<Os>";
799     if (OptLevelOz)
800       Pipeline = "default<Oz>";
801     for (const auto &P : PassList)
802       Passes.push_back(P->getPassArgument());
803     OutputKind OK = OK_NoOutput;
804     if (!NoOutput)
805       OK = OutputAssembly
806                ? OK_OutputAssembly
807                : (OutputThinLTOBC ? OK_OutputThinLTOBitcode : OK_OutputBitcode);
808 
809     VerifierKind VK = VK_VerifyInAndOut;
810     if (NoVerify)
811       VK = VK_NoVerifier;
812     else if (VerifyEach)
813       VK = VK_VerifyEachPass;
814 
815     // The user has asked to use the new pass manager and provided a pipeline
816     // string. Hand off the rest of the functionality to the new code for that
817     // layer.
818     return runPassPipeline(argv[0], *M, TM.get(), &TLII, Out.get(),
819                            ThinLinkOut.get(), RemarksFile.get(), Pipeline,
820                            Passes, OK, VK, PreserveAssemblyUseListOrder,
821                            PreserveBitcodeUseListOrder, EmitSummaryIndex,
822                            EmitModuleHash, EnableDebugify)
823                ? 0
824                : 1;
825   }
826 
827   // Create a PassManager to hold and optimize the collection of passes we are
828   // about to build. If the -debugify-each option is set, wrap each pass with
829   // the (-check)-debugify passes.
830   DebugifyCustomPassManager Passes;
831   DebugifyStatsMap DIStatsMap;
832   DebugInfoPerPassMap DIPreservationMap;
833   if (DebugifyEach) {
834     Passes.setDebugifyMode(DebugifyMode::SyntheticDebugInfo);
835     Passes.setDIStatsMap(DIStatsMap);
836   } else if (VerifyEachDebugInfoPreserve) {
837     Passes.setDebugifyMode(DebugifyMode::OriginalDebugInfo);
838     Passes.setDIPreservationMap(DIPreservationMap);
839     if (!VerifyDIPreserveExport.empty())
840       Passes.setOrigDIVerifyBugsReportFilePath(VerifyDIPreserveExport);
841   }
842 
843   bool AddOneTimeDebugifyPasses =
844       (EnableDebugify && !DebugifyEach) ||
845       (VerifyDebugInfoPreserve && !VerifyEachDebugInfoPreserve);
846 
847   Passes.add(new TargetLibraryInfoWrapperPass(TLII));
848 
849   // Add internal analysis passes from the target machine.
850   Passes.add(createTargetTransformInfoWrapperPass(TM ? TM->getTargetIRAnalysis()
851                                                      : TargetIRAnalysis()));
852 
853   if (AddOneTimeDebugifyPasses) {
854     if (EnableDebugify) {
855       Passes.setDIStatsMap(DIStatsMap);
856       Passes.add(createDebugifyModulePass());
857     } else if (VerifyDebugInfoPreserve) {
858       Passes.setDIPreservationMap(DIPreservationMap);
859       Passes.add(createDebugifyModulePass(
860           DebugifyMode::OriginalDebugInfo, "",
861           &(Passes.getDebugInfoPerPassMap())));
862     }
863   }
864 
865   std::unique_ptr<legacy::FunctionPassManager> FPasses;
866   if (OptLevelO0 || OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz ||
867       OptLevelO3) {
868     FPasses.reset(new legacy::FunctionPassManager(M.get()));
869     FPasses->add(createTargetTransformInfoWrapperPass(
870         TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()));
871   }
872 
873   if (PrintBreakpoints) {
874     // Default to standard output.
875     if (!Out) {
876       if (OutputFilename.empty())
877         OutputFilename = "-";
878 
879       std::error_code EC;
880       Out = std::make_unique<ToolOutputFile>(OutputFilename, EC,
881                                               sys::fs::OF_None);
882       if (EC) {
883         errs() << EC.message() << '\n';
884         return 1;
885       }
886     }
887     Passes.add(createBreakpointPrinter(Out->os()));
888     NoOutput = true;
889   }
890 
891   if (TM) {
892     // FIXME: We should dyn_cast this when supported.
893     auto &LTM = static_cast<LLVMTargetMachine &>(*TM);
894     Pass *TPC = LTM.createPassConfig(Passes);
895     Passes.add(TPC);
896   }
897 
898   // Create a new optimization pass for each one specified on the command line
899   for (unsigned i = 0; i < PassList.size(); ++i) {
900     if (OptLevelO0 && OptLevelO0.getPosition() < PassList.getPosition(i)) {
901       AddOptimizationPasses(Passes, *FPasses, TM.get(), 0, 0);
902       OptLevelO0 = false;
903     }
904 
905     if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) {
906       AddOptimizationPasses(Passes, *FPasses, TM.get(), 1, 0);
907       OptLevelO1 = false;
908     }
909 
910     if (OptLevelO2 && OptLevelO2.getPosition() < PassList.getPosition(i)) {
911       AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 0);
912       OptLevelO2 = false;
913     }
914 
915     if (OptLevelOs && OptLevelOs.getPosition() < PassList.getPosition(i)) {
916       AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 1);
917       OptLevelOs = false;
918     }
919 
920     if (OptLevelOz && OptLevelOz.getPosition() < PassList.getPosition(i)) {
921       AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 2);
922       OptLevelOz = false;
923     }
924 
925     if (OptLevelO3 && OptLevelO3.getPosition() < PassList.getPosition(i)) {
926       AddOptimizationPasses(Passes, *FPasses, TM.get(), 3, 0);
927       OptLevelO3 = false;
928     }
929 
930     const PassInfo *PassInf = PassList[i];
931     Pass *P = nullptr;
932     if (PassInf->getNormalCtor())
933       P = PassInf->getNormalCtor()();
934     else
935       errs() << argv[0] << ": cannot create pass: "
936              << PassInf->getPassName() << "\n";
937     if (P) {
938       PassKind Kind = P->getPassKind();
939       addPass(Passes, P);
940 
941       if (AnalyzeOnly) {
942         switch (Kind) {
943         case PT_Region:
944           Passes.add(createRegionPassPrinter(PassInf, Out->os()));
945           break;
946         case PT_Loop:
947           Passes.add(createLoopPassPrinter(PassInf, Out->os()));
948           break;
949         case PT_Function:
950           Passes.add(createFunctionPassPrinter(PassInf, Out->os()));
951           break;
952         case PT_CallGraphSCC:
953           Passes.add(createCallGraphPassPrinter(PassInf, Out->os()));
954           break;
955         default:
956           Passes.add(createModulePassPrinter(PassInf, Out->os()));
957           break;
958         }
959       }
960     }
961   }
962 
963   if (OptLevelO0)
964     AddOptimizationPasses(Passes, *FPasses, TM.get(), 0, 0);
965 
966   if (OptLevelO1)
967     AddOptimizationPasses(Passes, *FPasses, TM.get(), 1, 0);
968 
969   if (OptLevelO2)
970     AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 0);
971 
972   if (OptLevelOs)
973     AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 1);
974 
975   if (OptLevelOz)
976     AddOptimizationPasses(Passes, *FPasses, TM.get(), 2, 2);
977 
978   if (OptLevelO3)
979     AddOptimizationPasses(Passes, *FPasses, TM.get(), 3, 0);
980 
981   if (FPasses) {
982     FPasses->doInitialization();
983     for (Function &F : *M)
984       FPasses->run(F);
985     FPasses->doFinalization();
986   }
987 
988   // Check that the module is well formed on completion of optimization
989   if (!NoVerify && !VerifyEach)
990     Passes.add(createVerifierPass());
991 
992   if (AddOneTimeDebugifyPasses) {
993     if (EnableDebugify)
994       Passes.add(createCheckDebugifyModulePass(false));
995     else if (VerifyDebugInfoPreserve) {
996       if (!VerifyDIPreserveExport.empty())
997         Passes.setOrigDIVerifyBugsReportFilePath(VerifyDIPreserveExport);
998       Passes.add(createCheckDebugifyModulePass(
999           false, "", nullptr, DebugifyMode::OriginalDebugInfo,
1000           &(Passes.getDebugInfoPerPassMap()), VerifyDIPreserveExport));
1001     }
1002   }
1003 
1004   // In run twice mode, we want to make sure the output is bit-by-bit
1005   // equivalent if we run the pass manager again, so setup two buffers and
1006   // a stream to write to them. Note that llc does something similar and it
1007   // may be worth to abstract this out in the future.
1008   SmallVector<char, 0> Buffer;
1009   SmallVector<char, 0> FirstRunBuffer;
1010   std::unique_ptr<raw_svector_ostream> BOS;
1011   raw_ostream *OS = nullptr;
1012 
1013   const bool ShouldEmitOutput = !NoOutput && !AnalyzeOnly;
1014 
1015   // Write bitcode or assembly to the output as the last step...
1016   if (ShouldEmitOutput || RunTwice) {
1017     assert(Out);
1018     OS = &Out->os();
1019     if (RunTwice) {
1020       BOS = std::make_unique<raw_svector_ostream>(Buffer);
1021       OS = BOS.get();
1022     }
1023     if (OutputAssembly) {
1024       if (EmitSummaryIndex)
1025         report_fatal_error("Text output is incompatible with -module-summary");
1026       if (EmitModuleHash)
1027         report_fatal_error("Text output is incompatible with -module-hash");
1028       Passes.add(createPrintModulePass(*OS, "", PreserveAssemblyUseListOrder));
1029     } else if (OutputThinLTOBC)
1030       Passes.add(createWriteThinLTOBitcodePass(
1031           *OS, ThinLinkOut ? &ThinLinkOut->os() : nullptr));
1032     else
1033       Passes.add(createBitcodeWriterPass(*OS, PreserveBitcodeUseListOrder,
1034                                          EmitSummaryIndex, EmitModuleHash));
1035   }
1036 
1037   // Before executing passes, print the final values of the LLVM options.
1038   cl::PrintOptionValues();
1039 
1040   if (!RunTwice) {
1041     // Now that we have all of the passes ready, run them.
1042     Passes.run(*M);
1043   } else {
1044     // If requested, run all passes twice with the same pass manager to catch
1045     // bugs caused by persistent state in the passes.
1046     std::unique_ptr<Module> M2(CloneModule(*M));
1047     // Run all passes on the original module first, so the second run processes
1048     // the clone to catch CloneModule bugs.
1049     Passes.run(*M);
1050     FirstRunBuffer = Buffer;
1051     Buffer.clear();
1052 
1053     Passes.run(*M2);
1054 
1055     // Compare the two outputs and make sure they're the same
1056     assert(Out);
1057     if (Buffer.size() != FirstRunBuffer.size() ||
1058         (memcmp(Buffer.data(), FirstRunBuffer.data(), Buffer.size()) != 0)) {
1059       errs()
1060           << "Running the pass manager twice changed the output.\n"
1061              "Writing the result of the second run to the specified output.\n"
1062              "To generate the one-run comparison binary, just run without\n"
1063              "the compile-twice option\n";
1064       if (ShouldEmitOutput) {
1065         Out->os() << BOS->str();
1066         Out->keep();
1067       }
1068       if (RemarksFile)
1069         RemarksFile->keep();
1070       return 1;
1071     }
1072     if (ShouldEmitOutput)
1073       Out->os() << BOS->str();
1074   }
1075 
1076   if (DebugifyEach && !DebugifyExport.empty())
1077     exportDebugifyStats(DebugifyExport, Passes.getDebugifyStatsMap());
1078 
1079   // Declare success.
1080   if (!NoOutput || PrintBreakpoints)
1081     Out->keep();
1082 
1083   if (RemarksFile)
1084     RemarksFile->keep();
1085 
1086   if (ThinLinkOut)
1087     ThinLinkOut->keep();
1088 
1089   return 0;
1090 }
1091