Home | History | Annotate | Download | only in opt 
      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>
     50 using namespace llvm;
     51 
     52 // The OptimizationList is automatically populated with registered Passes by the
     53 // PassNameParser.
     54 //
     55 static cl::list<const PassInfo*, bool, PassNameParser>
     56 PassList(cl::desc("Optimizations available:"));
     57 
     58 // Other command line options...
     59 //
     60 static cl::opt<std::string>
     61 InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
     62     cl::init("-"), cl::value_desc("filename"));
     63 
     64 static cl::opt<std::string>
     65 OutputFilename("o", cl::desc("Override output filename"),
     66                cl::value_desc("filename"));
     67 
     68 static cl::opt<bool>
     69 Force("f", cl::desc("Enable binary output on terminals"));
     70 
     71 static cl::opt<bool>
     72 PrintEachXForm("p", cl::desc("Print module after each transformation"));
     73 
     74 static cl::opt<bool>
     75 NoOutput("disable-output",
     76          cl::desc("Do not write result bitcode file"), cl::Hidden);
     77 
     78 static cl::opt<bool>
     79 OutputAssembly("S", cl::desc("Write output as LLVM assembly"));
     80 
     81 static cl::opt<bool>
     82 NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden);
     83 
     84 static cl::opt<bool>
     85 VerifyEach("verify-each", cl::desc("Verify after each transform"));
     86 
     87 static cl::opt<bool>
     88 StripDebug("strip-debug",
     89            cl::desc("Strip debugger symbol info from translation unit"));
     90 
     91 static cl::opt<bool>
     92 DisableInline("disable-inlining", cl::desc("Do not run the inliner pass"));
     93 
     94 static cl::opt<bool>
     95 DisableOptimizations("disable-opt",
     96                      cl::desc("Do not run any optimization passes"));
     97 
     98 static cl::opt<bool>
     99 DisableInternalize("disable-internalize",
    100                    cl::desc("Do not mark all symbols as internal"));
    101 
    102 static cl::opt<bool>
    103 StandardCompileOpts("std-compile-opts",
    104                    cl::desc("Include the standard compile time optimizations"));
    105 
    106 static cl::opt<bool>
    107 StandardLinkOpts("std-link-opts",
    108                  cl::desc("Include the standard link time optimizations"));
    109 
    110 static cl::opt<bool>
    111 OptLevelO1("O1",
    112            cl::desc("Optimization level 1. Similar to clang -O1"));
    113 
    114 static cl::opt<bool>
    115 OptLevelO2("O2",
    116            cl::desc("Optimization level 2. Similar to clang -O2"));
    117 
    118 static cl::opt<bool>
    119 OptLevelOs("Os",
    120            cl::desc("Like -O2 with extra optimizations for size. Similar to clang -Os"));
    121 
    122 static cl::opt<bool>
    123 OptLevelOz("Oz",
    124            cl::desc("Like -Os but reduces code size further. Similar to clang -Oz"));
    125 
    126 static cl::opt<bool>
    127 OptLevelO3("O3",
    128            cl::desc("Optimization level 3. Similar to clang -O3"));
    129 
    130 static cl::opt<std::string>
    131 TargetTriple("mtriple", cl::desc("Override target triple for module"));
    132 
    133 static cl::opt<bool>
    134 UnitAtATime("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 
    138 static cl::opt<bool>
    139 DisableSimplifyLibCalls("disable-simplify-libcalls",
    140                         cl::desc("Disable simplify-libcalls"));
    141 
    142 static cl::opt<bool>
    143 Quiet("q", cl::desc("Obsolete option"), cl::Hidden);
    144 
    145 static cl::alias
    146 QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
    147 
    148 static cl::opt<bool>
    149 AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
    150 
    151 static cl::opt<bool>
    152 PrintBreakpoints("print-breakpoints-for-testing",
    153                  cl::desc("Print select breakpoints location for testing"));
    154 
    155 static cl::opt<std::string>
    156 DefaultDataLayout("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 ------------
    161 namespace {
    162 
    163 struct 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 
    197 char CallGraphSCCPassPrinter::ID = 0;
    198 
    199 struct 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 
    228 char ModulePassPrinter::ID = 0;
    229 struct 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 
    260 char FunctionPassPrinter::ID = 0;
    261 
    262 struct 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 
    293 char LoopPassPrinter::ID = 0;
    294 
    295 struct 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 
    327 char RegionPassPrinter::ID = 0;
    328 
    329 struct 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 
    360 char BasicBlockPassPrinter::ID = 0;
    361 
    362 struct 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 
    412 char BreakpointPrinter::ID = 0;
    413 
    414 static 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
    427 static 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 
    456 static 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 
    473 static 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 //
    490 static 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 
    514 CodeGenOpt::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.
    525 static 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 //
    552 int 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