1//===- opt.cpp - The LLVM Modular Optimizer -------------------------------===//
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//
10// Optimizations may be specified an arbitrary number of times on the command
11// line, They are run in the order specified.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/IR/LLVMContext.h"
16#include "llvm/ADT/StringSet.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/Verifier.h"
23#include "llvm/Assembly/PrintModulePass.h"
24#include "llvm/Bitcode/ReaderWriter.h"
25#include "llvm/CodeGen/CommandFlags.h"
26#include "llvm/DebugInfo.h"
27#include "llvm/IR/DataLayout.h"
28#include "llvm/IR/Module.h"
29#include "llvm/IRReader/IRReader.h"
30#include "llvm/LinkAllIR.h"
31#include "llvm/LinkAllPasses.h"
32#include "llvm/MC/SubtargetFeature.h"
33#include "llvm/PassManager.h"
34#include "llvm/Support/Debug.h"
35#include "llvm/Support/ManagedStatic.h"
36#include "llvm/Support/PassNameParser.h"
37#include "llvm/Support/PluginLoader.h"
38#include "llvm/Support/PrettyStackTrace.h"
39#include "llvm/Support/Signals.h"
40#include "llvm/Support/SourceMgr.h"
41#include "llvm/Support/SystemUtils.h"
42#include "llvm/Support/TargetRegistry.h"
43#include "llvm/Support/TargetSelect.h"
44#include "llvm/Support/ToolOutputFile.h"
45#include "llvm/Target/TargetLibraryInfo.h"
46#include "llvm/Target/TargetMachine.h"
47#include "llvm/Transforms/IPO/PassManagerBuilder.h"
48#include <algorithm>
49#include <memory>
50using namespace llvm;
51
52// The OptimizationList is automatically populated with registered Passes by the
53// PassNameParser.
54//
55static cl::list<const PassInfo*, bool, PassNameParser>
56PassList(cl::desc("Optimizations available:"));
57
58// Other command line options...
59//
60static cl::opt<std::string>
61InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
62    cl::init("-"), cl::value_desc("filename"));
63
64static cl::opt<std::string>
65OutputFilename("o", cl::desc("Override output filename"),
66               cl::value_desc("filename"));
67
68static cl::opt<bool>
69Force("f", cl::desc("Enable binary output on terminals"));
70
71static cl::opt<bool>
72PrintEachXForm("p", cl::desc("Print module after each transformation"));
73
74static cl::opt<bool>
75NoOutput("disable-output",
76         cl::desc("Do not write result bitcode file"), cl::Hidden);
77
78static cl::opt<bool>
79OutputAssembly("S", cl::desc("Write output as LLVM assembly"));
80
81static cl::opt<bool>
82NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden);
83
84static cl::opt<bool>
85VerifyEach("verify-each", cl::desc("Verify after each transform"));
86
87static cl::opt<bool>
88StripDebug("strip-debug",
89           cl::desc("Strip debugger symbol info from translation unit"));
90
91static cl::opt<bool>
92DisableInline("disable-inlining", cl::desc("Do not run the inliner pass"));
93
94static cl::opt<bool>
95DisableOptimizations("disable-opt",
96                     cl::desc("Do not run any optimization passes"));
97
98static cl::opt<bool>
99DisableInternalize("disable-internalize",
100                   cl::desc("Do not mark all symbols as internal"));
101
102static cl::opt<bool>
103StandardCompileOpts("std-compile-opts",
104                   cl::desc("Include the standard compile time optimizations"));
105
106static cl::opt<bool>
107StandardLinkOpts("std-link-opts",
108                 cl::desc("Include the standard link time optimizations"));
109
110static cl::opt<bool>
111OptLevelO1("O1",
112           cl::desc("Optimization level 1. Similar to clang -O1"));
113
114static cl::opt<bool>
115OptLevelO2("O2",
116           cl::desc("Optimization level 2. Similar to clang -O2"));
117
118static cl::opt<bool>
119OptLevelOs("Os",
120           cl::desc("Like -O2 with extra optimizations for size. Similar to clang -Os"));
121
122static cl::opt<bool>
123OptLevelOz("Oz",
124           cl::desc("Like -Os but reduces code size further. Similar to clang -Oz"));
125
126static cl::opt<bool>
127OptLevelO3("O3",
128           cl::desc("Optimization level 3. Similar to clang -O3"));
129
130static cl::opt<std::string>
131TargetTriple("mtriple", cl::desc("Override target triple for module"));
132
133static cl::opt<bool>
134UnitAtATime("funit-at-a-time",
135            cl::desc("Enable IPO. This is same as llvm-gcc's -funit-at-a-time"),
136            cl::init(true));
137
138static cl::opt<bool>
139DisableSimplifyLibCalls("disable-simplify-libcalls",
140                        cl::desc("Disable simplify-libcalls"));
141
142static cl::opt<bool>
143Quiet("q", cl::desc("Obsolete option"), cl::Hidden);
144
145static cl::alias
146QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
147
148static cl::opt<bool>
149AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
150
151static cl::opt<bool>
152PrintBreakpoints("print-breakpoints-for-testing",
153                 cl::desc("Print select breakpoints location for testing"));
154
155static cl::opt<std::string>
156DefaultDataLayout("default-data-layout",
157          cl::desc("data layout string to use if not specified by module"),
158          cl::value_desc("layout-string"), cl::init(""));
159
160// ---------- Define Printers for module and function passes ------------
161namespace {
162
163struct CallGraphSCCPassPrinter : public CallGraphSCCPass {
164  static char ID;
165  const PassInfo *PassToPrint;
166  raw_ostream &Out;
167  std::string PassName;
168
169  CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out) :
170    CallGraphSCCPass(ID), PassToPrint(PI), Out(out) {
171      std::string PassToPrintName =  PassToPrint->getPassName();
172      PassName = "CallGraphSCCPass Printer: " + PassToPrintName;
173    }
174
175  virtual bool runOnSCC(CallGraphSCC &SCC) {
176    if (!Quiet)
177      Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
178
179    // Get and print pass...
180    for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
181      Function *F = (*I)->getFunction();
182      if (F)
183        getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out,
184                                                              F->getParent());
185    }
186    return false;
187  }
188
189  virtual const char *getPassName() const { return PassName.c_str(); }
190
191  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
192    AU.addRequiredID(PassToPrint->getTypeInfo());
193    AU.setPreservesAll();
194  }
195};
196
197char CallGraphSCCPassPrinter::ID = 0;
198
199struct ModulePassPrinter : public ModulePass {
200  static char ID;
201  const PassInfo *PassToPrint;
202  raw_ostream &Out;
203  std::string PassName;
204
205  ModulePassPrinter(const PassInfo *PI, raw_ostream &out)
206    : ModulePass(ID), PassToPrint(PI), Out(out) {
207      std::string PassToPrintName =  PassToPrint->getPassName();
208      PassName = "ModulePass Printer: " + PassToPrintName;
209    }
210
211  virtual bool runOnModule(Module &M) {
212    if (!Quiet)
213      Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
214
215    // Get and print pass...
216    getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M);
217    return false;
218  }
219
220  virtual const char *getPassName() const { return PassName.c_str(); }
221
222  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
223    AU.addRequiredID(PassToPrint->getTypeInfo());
224    AU.setPreservesAll();
225  }
226};
227
228char ModulePassPrinter::ID = 0;
229struct FunctionPassPrinter : public FunctionPass {
230  const PassInfo *PassToPrint;
231  raw_ostream &Out;
232  static char ID;
233  std::string PassName;
234
235  FunctionPassPrinter(const PassInfo *PI, raw_ostream &out)
236    : FunctionPass(ID), PassToPrint(PI), Out(out) {
237      std::string PassToPrintName =  PassToPrint->getPassName();
238      PassName = "FunctionPass Printer: " + PassToPrintName;
239    }
240
241  virtual bool runOnFunction(Function &F) {
242    if (!Quiet)
243      Out << "Printing analysis '" << PassToPrint->getPassName()
244          << "' for function '" << F.getName() << "':\n";
245
246    // Get and print pass...
247    getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out,
248            F.getParent());
249    return false;
250  }
251
252  virtual const char *getPassName() const { return PassName.c_str(); }
253
254  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
255    AU.addRequiredID(PassToPrint->getTypeInfo());
256    AU.setPreservesAll();
257  }
258};
259
260char FunctionPassPrinter::ID = 0;
261
262struct LoopPassPrinter : public LoopPass {
263  static char ID;
264  const PassInfo *PassToPrint;
265  raw_ostream &Out;
266  std::string PassName;
267
268  LoopPassPrinter(const PassInfo *PI, raw_ostream &out) :
269    LoopPass(ID), PassToPrint(PI), Out(out) {
270      std::string PassToPrintName =  PassToPrint->getPassName();
271      PassName = "LoopPass Printer: " + PassToPrintName;
272    }
273
274
275  virtual bool runOnLoop(Loop *L, LPPassManager &LPM) {
276    if (!Quiet)
277      Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
278
279    // Get and print pass...
280    getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out,
281                        L->getHeader()->getParent()->getParent());
282    return false;
283  }
284
285  virtual const char *getPassName() const { return PassName.c_str(); }
286
287  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
288    AU.addRequiredID(PassToPrint->getTypeInfo());
289    AU.setPreservesAll();
290  }
291};
292
293char LoopPassPrinter::ID = 0;
294
295struct RegionPassPrinter : public RegionPass {
296  static char ID;
297  const PassInfo *PassToPrint;
298  raw_ostream &Out;
299  std::string PassName;
300
301  RegionPassPrinter(const PassInfo *PI, raw_ostream &out) : RegionPass(ID),
302    PassToPrint(PI), Out(out) {
303    std::string PassToPrintName =  PassToPrint->getPassName();
304    PassName = "RegionPass Printer: " + PassToPrintName;
305  }
306
307  virtual bool runOnRegion(Region *R, RGPassManager &RGM) {
308    if (!Quiet) {
309      Out << "Printing analysis '" << PassToPrint->getPassName() << "' for "
310          << "region: '" << R->getNameStr() << "' in function '"
311          << R->getEntry()->getParent()->getName() << "':\n";
312    }
313    // Get and print pass...
314   getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out,
315                       R->getEntry()->getParent()->getParent());
316    return false;
317  }
318
319  virtual const char *getPassName() const { return PassName.c_str(); }
320
321  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
322    AU.addRequiredID(PassToPrint->getTypeInfo());
323    AU.setPreservesAll();
324  }
325};
326
327char RegionPassPrinter::ID = 0;
328
329struct BasicBlockPassPrinter : public BasicBlockPass {
330  const PassInfo *PassToPrint;
331  raw_ostream &Out;
332  static char ID;
333  std::string PassName;
334
335  BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out)
336    : BasicBlockPass(ID), PassToPrint(PI), Out(out) {
337      std::string PassToPrintName =  PassToPrint->getPassName();
338      PassName = "BasicBlockPass Printer: " + PassToPrintName;
339    }
340
341  virtual bool runOnBasicBlock(BasicBlock &BB) {
342    if (!Quiet)
343      Out << "Printing Analysis info for BasicBlock '" << BB.getName()
344          << "': Pass " << PassToPrint->getPassName() << ":\n";
345
346    // Get and print pass...
347    getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out,
348            BB.getParent()->getParent());
349    return false;
350  }
351
352  virtual const char *getPassName() const { return PassName.c_str(); }
353
354  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
355    AU.addRequiredID(PassToPrint->getTypeInfo());
356    AU.setPreservesAll();
357  }
358};
359
360char BasicBlockPassPrinter::ID = 0;
361
362struct BreakpointPrinter : public ModulePass {
363  raw_ostream &Out;
364  static char ID;
365
366  BreakpointPrinter(raw_ostream &out)
367    : ModulePass(ID), Out(out) {
368    }
369
370  void getContextName(DIDescriptor Context, std::string &N) {
371    if (Context.isNameSpace()) {
372      DINameSpace NS(Context);
373      if (!NS.getName().empty()) {
374        getContextName(NS.getContext(), N);
375        N = N + NS.getName().str() + "::";
376      }
377    } else if (Context.isType()) {
378      DIType TY(Context);
379      if (!TY.getName().empty()) {
380        getContextName(TY.getContext(), N);
381        N = N + TY.getName().str() + "::";
382      }
383    }
384  }
385
386  virtual bool runOnModule(Module &M) {
387    StringSet<> Processed;
388    if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp"))
389      for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
390        std::string Name;
391        DISubprogram SP(NMD->getOperand(i));
392        assert((!SP || SP.isSubprogram()) &&
393          "A MDNode in llvm.dbg.sp should be null or a DISubprogram.");
394        if (!SP)
395          continue;
396        getContextName(SP.getContext(), Name);
397        Name = Name + SP.getDisplayName().str();
398        if (!Name.empty() && Processed.insert(Name)) {
399          Out << Name << "\n";
400        }
401      }
402    return false;
403  }
404
405  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
406    AU.setPreservesAll();
407  }
408};
409
410} // anonymous namespace
411
412char BreakpointPrinter::ID = 0;
413
414static inline void addPass(PassManagerBase &PM, Pass *P) {
415  // Add the pass to the pass manager...
416  PM.add(P);
417
418  // If we are verifying all of the intermediate steps, add the verifier...
419  if (VerifyEach) PM.add(createVerifierPass());
420}
421
422/// AddOptimizationPasses - This routine adds optimization passes
423/// based on selected optimization level, OptLevel. This routine
424/// duplicates llvm-gcc behaviour.
425///
426/// OptLevel - Optimization Level
427static void AddOptimizationPasses(PassManagerBase &MPM,FunctionPassManager &FPM,
428                                  unsigned OptLevel, unsigned SizeLevel) {
429  FPM.add(createVerifierPass());                  // Verify that input is correct
430
431  PassManagerBuilder Builder;
432  Builder.OptLevel = OptLevel;
433  Builder.SizeLevel = SizeLevel;
434
435  if (DisableInline) {
436    // No inlining pass
437  } else if (OptLevel > 1) {
438    unsigned Threshold = 225;
439    if (SizeLevel == 1)      // -Os
440      Threshold = 75;
441    else if (SizeLevel == 2) // -Oz
442      Threshold = 25;
443    if (OptLevel > 2)
444      Threshold = 275;
445    Builder.Inliner = createFunctionInliningPass(Threshold);
446  } else {
447    Builder.Inliner = createAlwaysInlinerPass();
448  }
449  Builder.DisableUnitAtATime = !UnitAtATime;
450  Builder.DisableUnrollLoops = OptLevel == 0;
451
452  Builder.populateFunctionPassManager(FPM);
453  Builder.populateModulePassManager(MPM);
454}
455
456static void AddStandardCompilePasses(PassManagerBase &PM) {
457  PM.add(createVerifierPass());                  // Verify that input is correct
458
459  // If the -strip-debug command line option was specified, do it.
460  if (StripDebug)
461    addPass(PM, createStripSymbolsPass(true));
462
463  if (DisableOptimizations) return;
464
465  // -std-compile-opts adds the same module passes as -O3.
466  PassManagerBuilder Builder;
467  if (!DisableInline)
468    Builder.Inliner = createFunctionInliningPass();
469  Builder.OptLevel = 3;
470  Builder.populateModulePassManager(PM);
471}
472
473static void AddStandardLinkPasses(PassManagerBase &PM) {
474  PM.add(createVerifierPass());                  // Verify that input is correct
475
476  // If the -strip-debug command line option was specified, do it.
477  if (StripDebug)
478    addPass(PM, createStripSymbolsPass(true));
479
480  if (DisableOptimizations) return;
481
482  PassManagerBuilder Builder;
483  Builder.populateLTOPassManager(PM, /*Internalize=*/ !DisableInternalize,
484                                 /*RunInliner=*/ !DisableInline);
485}
486
487//===----------------------------------------------------------------------===//
488// CodeGen-related helper functions.
489//
490static TargetOptions GetTargetOptions() {
491  TargetOptions Options;
492  Options.LessPreciseFPMADOption = EnableFPMAD;
493  Options.NoFramePointerElim = DisableFPElim;
494  Options.AllowFPOpFusion = FuseFPOps;
495  Options.UnsafeFPMath = EnableUnsafeFPMath;
496  Options.NoInfsFPMath = EnableNoInfsFPMath;
497  Options.NoNaNsFPMath = EnableNoNaNsFPMath;
498  Options.HonorSignDependentRoundingFPMathOption =
499  EnableHonorSignDependentRoundingFPMath;
500  Options.UseSoftFloat = GenerateSoftFloatCalls;
501  if (FloatABIForCalls != FloatABI::Default)
502    Options.FloatABIType = FloatABIForCalls;
503  Options.NoZerosInBSS = DontPlaceZerosInBSS;
504  Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
505  Options.DisableTailCalls = DisableTailCalls;
506  Options.StackAlignmentOverride = OverrideStackAlignment;
507  Options.TrapFuncName = TrapFuncName;
508  Options.PositionIndependentExecutable = EnablePIE;
509  Options.EnableSegmentedStacks = SegmentedStacks;
510  Options.UseInitArray = UseInitArray;
511  return Options;
512}
513
514CodeGenOpt::Level GetCodeGenOptLevel() {
515  if (OptLevelO1)
516    return CodeGenOpt::Less;
517  if (OptLevelO2)
518    return CodeGenOpt::Default;
519  if (OptLevelO3)
520    return CodeGenOpt::Aggressive;
521  return CodeGenOpt::None;
522}
523
524// Returns the TargetMachine instance or zero if no triple is provided.
525static TargetMachine* GetTargetMachine(Triple TheTriple) {
526  std::string Error;
527  const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple,
528                                                         Error);
529  // Some modules don't specify a triple, and this is okay.
530  if (!TheTarget) {
531    return 0;
532  }
533
534  // Package up features to be passed to target/subtarget
535  std::string FeaturesStr;
536  if (MAttrs.size()) {
537    SubtargetFeatures Features;
538    for (unsigned i = 0; i != MAttrs.size(); ++i)
539      Features.AddFeature(MAttrs[i]);
540    FeaturesStr = Features.getString();
541  }
542
543  return TheTarget->createTargetMachine(TheTriple.getTriple(),
544                                        MCPU, FeaturesStr, GetTargetOptions(),
545                                        RelocModel, CMModel,
546                                        GetCodeGenOptLevel());
547}
548
549//===----------------------------------------------------------------------===//
550// main for opt
551//
552int main(int argc, char **argv) {
553  sys::PrintStackTraceOnErrorSignal();
554  llvm::PrettyStackTraceProgram X(argc, argv);
555
556  // Enable debug stream buffering.
557  EnableDebugBuffering = true;
558
559  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
560  LLVMContext &Context = getGlobalContext();
561
562  InitializeAllTargets();
563  InitializeAllTargetMCs();
564
565  // Initialize passes
566  PassRegistry &Registry = *PassRegistry::getPassRegistry();
567  initializeCore(Registry);
568  initializeDebugIRPass(Registry);
569  initializeScalarOpts(Registry);
570  initializeObjCARCOpts(Registry);
571  initializeVectorization(Registry);
572  initializeIPO(Registry);
573  initializeAnalysis(Registry);
574  initializeIPA(Registry);
575  initializeTransformUtils(Registry);
576  initializeInstCombine(Registry);
577  initializeInstrumentation(Registry);
578  initializeTarget(Registry);
579
580  cl::ParseCommandLineOptions(argc, argv,
581    "llvm .bc -> .bc modular optimizer and analysis printer\n");
582
583  if (AnalyzeOnly && NoOutput) {
584    errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n";
585    return 1;
586  }
587
588  SMDiagnostic Err;
589
590  // Load the input module...
591  OwningPtr<Module> M;
592  M.reset(ParseIRFile(InputFilename, Err, Context));
593
594  if (M.get() == 0) {
595    Err.print(argv[0], errs());
596    return 1;
597  }
598
599  // If we are supposed to override the target triple, do so now.
600  if (!TargetTriple.empty())
601    M->setTargetTriple(Triple::normalize(TargetTriple));
602
603  // Figure out what stream we are supposed to write to...
604  OwningPtr<tool_output_file> Out;
605  if (NoOutput) {
606    if (!OutputFilename.empty())
607      errs() << "WARNING: The -o (output filename) option is ignored when\n"
608                "the --disable-output option is used.\n";
609  } else {
610    // Default to standard output.
611    if (OutputFilename.empty())
612      OutputFilename = "-";
613
614    std::string ErrorInfo;
615    Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo,
616                                   sys::fs::F_Binary));
617    if (!ErrorInfo.empty()) {
618      errs() << ErrorInfo << '\n';
619      return 1;
620    }
621  }
622
623  // If the output is set to be emitted to standard out, and standard out is a
624  // console, print out a warning message and refuse to do it.  We don't
625  // impress anyone by spewing tons of binary goo to a terminal.
626  if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly)
627    if (CheckBitcodeOutputToConsole(Out->os(), !Quiet))
628      NoOutput = true;
629
630  // Create a PassManager to hold and optimize the collection of passes we are
631  // about to build.
632  //
633  PassManager Passes;
634
635  // Add an appropriate TargetLibraryInfo pass for the module's triple.
636  TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple()));
637
638  // The -disable-simplify-libcalls flag actually disables all builtin optzns.
639  if (DisableSimplifyLibCalls)
640    TLI->disableAllFunctions();
641  Passes.add(TLI);
642
643  // Add an appropriate DataLayout instance for this module.
644  DataLayout *TD = 0;
645  const std::string &ModuleDataLayout = M.get()->getDataLayout();
646  if (!ModuleDataLayout.empty())
647    TD = new DataLayout(ModuleDataLayout);
648  else if (!DefaultDataLayout.empty())
649    TD = new DataLayout(DefaultDataLayout);
650
651  if (TD)
652    Passes.add(TD);
653
654  Triple ModuleTriple(M->getTargetTriple());
655  TargetMachine *Machine = 0;
656  if (ModuleTriple.getArch())
657    Machine = GetTargetMachine(Triple(ModuleTriple));
658  OwningPtr<TargetMachine> TM(Machine);
659
660  // Add internal analysis passes from the target machine.
661  if (TM.get())
662    TM->addAnalysisPasses(Passes);
663
664  OwningPtr<FunctionPassManager> FPasses;
665  if (OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) {
666    FPasses.reset(new FunctionPassManager(M.get()));
667    if (TD)
668      FPasses->add(new DataLayout(*TD));
669    if (TM.get())
670      TM->addAnalysisPasses(*FPasses);
671
672  }
673
674  if (PrintBreakpoints) {
675    // Default to standard output.
676    if (!Out) {
677      if (OutputFilename.empty())
678        OutputFilename = "-";
679
680      std::string ErrorInfo;
681      Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo,
682                                     sys::fs::F_Binary));
683      if (!ErrorInfo.empty()) {
684        errs() << ErrorInfo << '\n';
685        return 1;
686      }
687    }
688    Passes.add(new BreakpointPrinter(Out->os()));
689    NoOutput = true;
690  }
691
692  // If the -strip-debug command line option was specified, add it.  If
693  // -std-compile-opts was also specified, it will handle StripDebug.
694  if (StripDebug && !StandardCompileOpts)
695    addPass(Passes, createStripSymbolsPass(true));
696
697  // Create a new optimization pass for each one specified on the command line
698  for (unsigned i = 0; i < PassList.size(); ++i) {
699    // Check to see if -std-compile-opts was specified before this option.  If
700    // so, handle it.
701    if (StandardCompileOpts &&
702        StandardCompileOpts.getPosition() < PassList.getPosition(i)) {
703      AddStandardCompilePasses(Passes);
704      StandardCompileOpts = false;
705    }
706
707    if (StandardLinkOpts &&
708        StandardLinkOpts.getPosition() < PassList.getPosition(i)) {
709      AddStandardLinkPasses(Passes);
710      StandardLinkOpts = false;
711    }
712
713    if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) {
714      AddOptimizationPasses(Passes, *FPasses, 1, 0);
715      OptLevelO1 = false;
716    }
717
718    if (OptLevelO2 && OptLevelO2.getPosition() < PassList.getPosition(i)) {
719      AddOptimizationPasses(Passes, *FPasses, 2, 0);
720      OptLevelO2 = false;
721    }
722
723    if (OptLevelOs && OptLevelOs.getPosition() < PassList.getPosition(i)) {
724      AddOptimizationPasses(Passes, *FPasses, 2, 1);
725      OptLevelOs = false;
726    }
727
728    if (OptLevelOz && OptLevelOz.getPosition() < PassList.getPosition(i)) {
729      AddOptimizationPasses(Passes, *FPasses, 2, 2);
730      OptLevelOz = false;
731    }
732
733    if (OptLevelO3 && OptLevelO3.getPosition() < PassList.getPosition(i)) {
734      AddOptimizationPasses(Passes, *FPasses, 3, 0);
735      OptLevelO3 = false;
736    }
737
738    const PassInfo *PassInf = PassList[i];
739    Pass *P = 0;
740    if (PassInf->getNormalCtor())
741      P = PassInf->getNormalCtor()();
742    else
743      errs() << argv[0] << ": cannot create pass: "
744             << PassInf->getPassName() << "\n";
745    if (P) {
746      PassKind Kind = P->getPassKind();
747      addPass(Passes, P);
748
749      if (AnalyzeOnly) {
750        switch (Kind) {
751        case PT_BasicBlock:
752          Passes.add(new BasicBlockPassPrinter(PassInf, Out->os()));
753          break;
754        case PT_Region:
755          Passes.add(new RegionPassPrinter(PassInf, Out->os()));
756          break;
757        case PT_Loop:
758          Passes.add(new LoopPassPrinter(PassInf, Out->os()));
759          break;
760        case PT_Function:
761          Passes.add(new FunctionPassPrinter(PassInf, Out->os()));
762          break;
763        case PT_CallGraphSCC:
764          Passes.add(new CallGraphSCCPassPrinter(PassInf, Out->os()));
765          break;
766        default:
767          Passes.add(new ModulePassPrinter(PassInf, Out->os()));
768          break;
769        }
770      }
771    }
772
773    if (PrintEachXForm)
774      Passes.add(createPrintModulePass(&errs()));
775  }
776
777  // If -std-compile-opts was specified at the end of the pass list, add them.
778  if (StandardCompileOpts) {
779    AddStandardCompilePasses(Passes);
780    StandardCompileOpts = false;
781  }
782
783  if (StandardLinkOpts) {
784    AddStandardLinkPasses(Passes);
785    StandardLinkOpts = false;
786  }
787
788  if (OptLevelO1)
789    AddOptimizationPasses(Passes, *FPasses, 1, 0);
790
791  if (OptLevelO2)
792    AddOptimizationPasses(Passes, *FPasses, 2, 0);
793
794  if (OptLevelOs)
795    AddOptimizationPasses(Passes, *FPasses, 2, 1);
796
797  if (OptLevelOz)
798    AddOptimizationPasses(Passes, *FPasses, 2, 2);
799
800  if (OptLevelO3)
801    AddOptimizationPasses(Passes, *FPasses, 3, 0);
802
803  if (OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) {
804    FPasses->doInitialization();
805    for (Module::iterator F = M->begin(), E = M->end(); F != E; ++F)
806      FPasses->run(*F);
807    FPasses->doFinalization();
808  }
809
810  // Check that the module is well formed on completion of optimization
811  if (!NoVerify && !VerifyEach)
812    Passes.add(createVerifierPass());
813
814  // Write bitcode or assembly to the output as the last step...
815  if (!NoOutput && !AnalyzeOnly) {
816    if (OutputAssembly)
817      Passes.add(createPrintModulePass(&Out->os()));
818    else
819      Passes.add(createBitcodeWriterPass(Out->os()));
820  }
821
822  // Before executing passes, print the final values of the LLVM options.
823  cl::PrintOptionValues();
824
825  // Now that we have all of the passes ready, run them.
826  Passes.run(*M.get());
827
828  // Declare success.
829  if (!NoOutput || PrintBreakpoints)
830    Out->keep();
831
832  return 0;
833}
834