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