opt.cpp revision 235633
1193323Sed//===- opt.cpp - The LLVM Modular Optimizer -------------------------------===// 2193323Sed// 3193323Sed// The LLVM Compiler Infrastructure 4193323Sed// 5193323Sed// This file is distributed under the University of Illinois Open Source 6193323Sed// License. See LICENSE.TXT for details. 7193323Sed// 8193323Sed//===----------------------------------------------------------------------===// 9193323Sed// 10193323Sed// Optimizations may be specified an arbitrary number of times on the command 11193323Sed// line, They are run in the order specified. 12193323Sed// 13193323Sed//===----------------------------------------------------------------------===// 14193323Sed 15195340Sed#include "llvm/LLVMContext.h" 16193323Sed#include "llvm/Module.h" 17193323Sed#include "llvm/PassManager.h" 18193323Sed#include "llvm/CallGraphSCCPass.h" 19193323Sed#include "llvm/Bitcode/ReaderWriter.h" 20193323Sed#include "llvm/Assembly/PrintModulePass.h" 21218885Sdim#include "llvm/Analysis/DebugInfo.h" 22193323Sed#include "llvm/Analysis/Verifier.h" 23193323Sed#include "llvm/Analysis/LoopPass.h" 24218885Sdim#include "llvm/Analysis/RegionPass.h" 25193323Sed#include "llvm/Analysis/CallGraph.h" 26193323Sed#include "llvm/Target/TargetData.h" 27218885Sdim#include "llvm/Target/TargetLibraryInfo.h" 28193323Sed#include "llvm/Target/TargetMachine.h" 29221337Sdim#include "llvm/ADT/StringSet.h" 30218885Sdim#include "llvm/ADT/Triple.h" 31193323Sed#include "llvm/Support/PassNameParser.h" 32218885Sdim#include "llvm/Support/Signals.h" 33202375Srdivacky#include "llvm/Support/Debug.h" 34198090Srdivacky#include "llvm/Support/IRReader.h" 35193323Sed#include "llvm/Support/ManagedStatic.h" 36193323Sed#include "llvm/Support/PluginLoader.h" 37200581Srdivacky#include "llvm/Support/PrettyStackTrace.h" 38193323Sed#include "llvm/Support/SystemUtils.h" 39218885Sdim#include "llvm/Support/ToolOutputFile.h" 40193323Sed#include "llvm/LinkAllPasses.h" 41193323Sed#include "llvm/LinkAllVMCore.h" 42226584Sdim#include "llvm/Transforms/IPO/PassManagerBuilder.h" 43193323Sed#include <memory> 44193323Sed#include <algorithm> 45193323Sedusing namespace llvm; 46193323Sed 47193323Sed// The OptimizationList is automatically populated with registered Passes by the 48193323Sed// PassNameParser. 49193323Sed// 50193323Sedstatic cl::list<const PassInfo*, bool, PassNameParser> 51193323SedPassList(cl::desc("Optimizations available:")); 52193323Sed 53193323Sed// Other command line options... 54193323Sed// 55193323Sedstatic cl::opt<std::string> 56198090SrdivackyInputFilename(cl::Positional, cl::desc("<input bitcode file>"), 57193323Sed cl::init("-"), cl::value_desc("filename")); 58193323Sed 59193323Sedstatic cl::opt<std::string> 60193323SedOutputFilename("o", cl::desc("Override output filename"), 61212793Sdim cl::value_desc("filename")); 62193323Sed 63193323Sedstatic cl::opt<bool> 64198090SrdivackyForce("f", cl::desc("Enable binary output on terminals")); 65193323Sed 66193323Sedstatic cl::opt<bool> 67193323SedPrintEachXForm("p", cl::desc("Print module after each transformation")); 68193323Sed 69193323Sedstatic cl::opt<bool> 70193323SedNoOutput("disable-output", 71193323Sed cl::desc("Do not write result bitcode file"), cl::Hidden); 72193323Sed 73193323Sedstatic cl::opt<bool> 74198113SrdivackyOutputAssembly("S", cl::desc("Write output as LLVM assembly")); 75198090Srdivacky 76198090Srdivackystatic cl::opt<bool> 77193323SedNoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden); 78193323Sed 79193323Sedstatic cl::opt<bool> 80193323SedVerifyEach("verify-each", cl::desc("Verify after each transform")); 81193323Sed 82193323Sedstatic cl::opt<bool> 83193323SedStripDebug("strip-debug", 84193323Sed cl::desc("Strip debugger symbol info from translation unit")); 85193323Sed 86193323Sedstatic cl::opt<bool> 87193323SedDisableInline("disable-inlining", cl::desc("Do not run the inliner pass")); 88193323Sed 89198090Srdivackystatic cl::opt<bool> 90198090SrdivackyDisableOptimizations("disable-opt", 91193323Sed cl::desc("Do not run any optimization passes")); 92193323Sed 93193323Sedstatic cl::opt<bool> 94198090SrdivackyDisableInternalize("disable-internalize", 95198090Srdivacky cl::desc("Do not mark all symbols as internal")); 96198090Srdivacky 97198090Srdivackystatic cl::opt<bool> 98198090SrdivackyStandardCompileOpts("std-compile-opts", 99193323Sed cl::desc("Include the standard compile time optimizations")); 100193323Sed 101193323Sedstatic cl::opt<bool> 102198090SrdivackyStandardLinkOpts("std-link-opts", 103198090Srdivacky cl::desc("Include the standard link time optimizations")); 104198090Srdivacky 105198090Srdivackystatic cl::opt<bool> 106193323SedOptLevelO1("O1", 107193323Sed cl::desc("Optimization level 1. Similar to llvm-gcc -O1")); 108193323Sed 109193323Sedstatic cl::opt<bool> 110193323SedOptLevelO2("O2", 111193323Sed cl::desc("Optimization level 2. Similar to llvm-gcc -O2")); 112193323Sed 113193323Sedstatic cl::opt<bool> 114193323SedOptLevelO3("O3", 115193323Sed cl::desc("Optimization level 3. Similar to llvm-gcc -O3")); 116193323Sed 117235633Sdimstatic cl::opt<std::string> 118235633SdimTargetTriple("mtriple", cl::desc("Override target triple for module")); 119235633Sdim 120193323Sedstatic cl::opt<bool> 121193323SedUnitAtATime("funit-at-a-time", 122198090Srdivacky cl::desc("Enable IPO. This is same as llvm-gcc's -funit-at-a-time"), 123210006Srdivacky cl::init(true)); 124193323Sed 125193323Sedstatic cl::opt<bool> 126193323SedDisableSimplifyLibCalls("disable-simplify-libcalls", 127193323Sed cl::desc("Disable simplify-libcalls")); 128193323Sed 129193323Sedstatic cl::opt<bool> 130193323SedQuiet("q", cl::desc("Obsolete option"), cl::Hidden); 131193323Sed 132193323Sedstatic cl::alias 133193323SedQuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet)); 134193323Sed 135193323Sedstatic cl::opt<bool> 136193323SedAnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization")); 137193323Sed 138218885Sdimstatic cl::opt<bool> 139221337SdimPrintBreakpoints("print-breakpoints-for-testing", 140218885Sdim cl::desc("Print select breakpoints location for testing")); 141218885Sdim 142198396Srdivackystatic cl::opt<std::string> 143221337SdimDefaultDataLayout("default-data-layout", 144198396Srdivacky cl::desc("data layout string to use if not specified by module"), 145198396Srdivacky cl::value_desc("layout-string"), cl::init("")); 146198396Srdivacky 147193323Sed// ---------- Define Printers for module and function passes ------------ 148193323Sednamespace { 149193323Sed 150193323Sedstruct CallGraphSCCPassPrinter : public CallGraphSCCPass { 151193323Sed static char ID; 152193323Sed const PassInfo *PassToPrint; 153212793Sdim raw_ostream &Out; 154218885Sdim std::string PassName; 155218885Sdim 156212793Sdim CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out) : 157218885Sdim CallGraphSCCPass(ID), PassToPrint(PI), Out(out) { 158218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 159218885Sdim PassName = "CallGraphSCCPass Printer: " + PassToPrintName; 160218885Sdim } 161193323Sed 162207618Srdivacky virtual bool runOnSCC(CallGraphSCC &SCC) { 163218885Sdim if (!Quiet) 164212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; 165193323Sed 166218885Sdim // Get and print pass... 167218885Sdim for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 168218885Sdim Function *F = (*I)->getFunction(); 169218885Sdim if (F) 170218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 171218885Sdim F->getParent()); 172193323Sed } 173193323Sed return false; 174193323Sed } 175198090Srdivacky 176218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 177193323Sed 178193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 179212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 180193323Sed AU.setPreservesAll(); 181193323Sed } 182193323Sed}; 183193323Sed 184193323Sedchar CallGraphSCCPassPrinter::ID = 0; 185193323Sed 186193323Sedstruct ModulePassPrinter : public ModulePass { 187193323Sed static char ID; 188193323Sed const PassInfo *PassToPrint; 189212793Sdim raw_ostream &Out; 190218885Sdim std::string PassName; 191218885Sdim 192212793Sdim ModulePassPrinter(const PassInfo *PI, raw_ostream &out) 193218885Sdim : ModulePass(ID), PassToPrint(PI), Out(out) { 194218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 195218885Sdim PassName = "ModulePass Printer: " + PassToPrintName; 196218885Sdim } 197193323Sed 198193323Sed virtual bool runOnModule(Module &M) { 199218885Sdim if (!Quiet) 200212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; 201193323Sed 202193323Sed // Get and print pass... 203218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M); 204193323Sed return false; 205193323Sed } 206193323Sed 207218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 208193323Sed 209193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 210212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 211193323Sed AU.setPreservesAll(); 212193323Sed } 213193323Sed}; 214193323Sed 215193323Sedchar ModulePassPrinter::ID = 0; 216193323Sedstruct FunctionPassPrinter : public FunctionPass { 217193323Sed const PassInfo *PassToPrint; 218212793Sdim raw_ostream &Out; 219193323Sed static char ID; 220218885Sdim std::string PassName; 221218885Sdim 222212793Sdim FunctionPassPrinter(const PassInfo *PI, raw_ostream &out) 223218885Sdim : FunctionPass(ID), PassToPrint(PI), Out(out) { 224218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 225218885Sdim PassName = "FunctionPass Printer: " + PassToPrintName; 226218885Sdim } 227193323Sed 228193323Sed virtual bool runOnFunction(Function &F) { 229218885Sdim if (!Quiet) 230212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() 231212793Sdim << "' for function '" << F.getName() << "':\n"; 232218885Sdim 233193323Sed // Get and print pass... 234212793Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 235212793Sdim F.getParent()); 236193323Sed return false; 237193323Sed } 238193323Sed 239218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 240193323Sed 241193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 242212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 243193323Sed AU.setPreservesAll(); 244193323Sed } 245193323Sed}; 246193323Sed 247193323Sedchar FunctionPassPrinter::ID = 0; 248193323Sed 249193323Sedstruct LoopPassPrinter : public LoopPass { 250193323Sed static char ID; 251193323Sed const PassInfo *PassToPrint; 252212793Sdim raw_ostream &Out; 253218885Sdim std::string PassName; 254218885Sdim 255212793Sdim LoopPassPrinter(const PassInfo *PI, raw_ostream &out) : 256218885Sdim LoopPass(ID), PassToPrint(PI), Out(out) { 257218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 258218885Sdim PassName = "LoopPass Printer: " + PassToPrintName; 259218885Sdim } 260193323Sed 261218885Sdim 262193323Sed virtual bool runOnLoop(Loop *L, LPPassManager &LPM) { 263218885Sdim if (!Quiet) 264212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; 265218885Sdim 266193323Sed // Get and print pass... 267218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 268218885Sdim L->getHeader()->getParent()->getParent()); 269193323Sed return false; 270193323Sed } 271198090Srdivacky 272218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 273193323Sed 274193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 275212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 276193323Sed AU.setPreservesAll(); 277193323Sed } 278193323Sed}; 279193323Sed 280193323Sedchar LoopPassPrinter::ID = 0; 281193323Sed 282218885Sdimstruct RegionPassPrinter : public RegionPass { 283218885Sdim static char ID; 284218885Sdim const PassInfo *PassToPrint; 285218885Sdim raw_ostream &Out; 286218885Sdim std::string PassName; 287218885Sdim 288218885Sdim RegionPassPrinter(const PassInfo *PI, raw_ostream &out) : RegionPass(ID), 289218885Sdim PassToPrint(PI), Out(out) { 290218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 291218885Sdim PassName = "RegionPass Printer: " + PassToPrintName; 292218885Sdim } 293218885Sdim 294218885Sdim virtual bool runOnRegion(Region *R, RGPassManager &RGM) { 295218885Sdim if (!Quiet) { 296218885Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "' for " 297235633Sdim << "region: '" << R->getNameStr() << "' in function '" 298235633Sdim << R->getEntry()->getParent()->getName() << "':\n"; 299218885Sdim } 300218885Sdim // Get and print pass... 301218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 302218885Sdim R->getEntry()->getParent()->getParent()); 303218885Sdim return false; 304218885Sdim } 305218885Sdim 306218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 307218885Sdim 308218885Sdim virtual void getAnalysisUsage(AnalysisUsage &AU) const { 309218885Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 310218885Sdim AU.setPreservesAll(); 311218885Sdim } 312218885Sdim}; 313218885Sdim 314218885Sdimchar RegionPassPrinter::ID = 0; 315218885Sdim 316193323Sedstruct BasicBlockPassPrinter : public BasicBlockPass { 317193323Sed const PassInfo *PassToPrint; 318212793Sdim raw_ostream &Out; 319193323Sed static char ID; 320218885Sdim std::string PassName; 321218885Sdim 322212793Sdim BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out) 323218885Sdim : BasicBlockPass(ID), PassToPrint(PI), Out(out) { 324218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 325218885Sdim PassName = "BasicBlockPass Printer: " + PassToPrintName; 326218885Sdim } 327193323Sed 328193323Sed virtual bool runOnBasicBlock(BasicBlock &BB) { 329218885Sdim if (!Quiet) 330212793Sdim Out << "Printing Analysis info for BasicBlock '" << BB.getName() 331212793Sdim << "': Pass " << PassToPrint->getPassName() << ":\n"; 332193323Sed 333193323Sed // Get and print pass... 334221337Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 335212793Sdim BB.getParent()->getParent()); 336193323Sed return false; 337193323Sed } 338193323Sed 339218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 340193323Sed 341193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 342212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 343193323Sed AU.setPreservesAll(); 344193323Sed } 345193323Sed}; 346193323Sed 347193323Sedchar BasicBlockPassPrinter::ID = 0; 348218885Sdim 349221337Sdimstruct BreakpointPrinter : public ModulePass { 350218885Sdim raw_ostream &Out; 351218885Sdim static char ID; 352218885Sdim 353218885Sdim BreakpointPrinter(raw_ostream &out) 354221337Sdim : ModulePass(ID), Out(out) { 355218885Sdim } 356218885Sdim 357221337Sdim void getContextName(DIDescriptor Context, std::string &N) { 358221337Sdim if (Context.isNameSpace()) { 359221337Sdim DINameSpace NS(Context); 360221337Sdim if (!NS.getName().empty()) { 361221337Sdim getContextName(NS.getContext(), N); 362221337Sdim N = N + NS.getName().str() + "::"; 363218885Sdim } 364221337Sdim } else if (Context.isType()) { 365221337Sdim DIType TY(Context); 366221337Sdim if (!TY.getName().empty()) { 367221337Sdim getContextName(TY.getContext(), N); 368221337Sdim N = N + TY.getName().str() + "::"; 369221337Sdim } 370221337Sdim } 371221337Sdim } 372221337Sdim 373221337Sdim virtual bool runOnModule(Module &M) { 374221337Sdim StringSet<> Processed; 375221337Sdim if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp")) 376221337Sdim for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 377221337Sdim std::string Name; 378221337Sdim DISubprogram SP(NMD->getOperand(i)); 379221337Sdim if (SP.Verify()) 380221337Sdim getContextName(SP.getContext(), Name); 381221337Sdim Name = Name + SP.getDisplayName().str(); 382221337Sdim if (!Name.empty() && Processed.insert(Name)) { 383221337Sdim Out << Name << "\n"; 384221337Sdim } 385221337Sdim } 386218885Sdim return false; 387218885Sdim } 388218885Sdim 389218885Sdim virtual void getAnalysisUsage(AnalysisUsage &AU) const { 390218885Sdim AU.setPreservesAll(); 391218885Sdim } 392218885Sdim}; 393223013Sdim 394223013Sdim} // anonymous namespace 395218885Sdim 396218885Sdimchar BreakpointPrinter::ID = 0; 397218885Sdim 398223013Sdimstatic inline void addPass(PassManagerBase &PM, Pass *P) { 399193323Sed // Add the pass to the pass manager... 400193323Sed PM.add(P); 401193323Sed 402193323Sed // If we are verifying all of the intermediate steps, add the verifier... 403193323Sed if (VerifyEach) PM.add(createVerifierPass()); 404193323Sed} 405193323Sed 406198090Srdivacky/// AddOptimizationPasses - This routine adds optimization passes 407198090Srdivacky/// based on selected optimization level, OptLevel. This routine 408193323Sed/// duplicates llvm-gcc behaviour. 409193323Sed/// 410193323Sed/// OptLevel - Optimization Level 411223013Sdimstatic void AddOptimizationPasses(PassManagerBase &MPM,FunctionPassManager &FPM, 412223013Sdim unsigned OptLevel) { 413235633Sdim FPM.add(createVerifierPass()); // Verify that input is correct 414235633Sdim 415223013Sdim PassManagerBuilder Builder; 416223013Sdim Builder.OptLevel = OptLevel; 417193323Sed 418202878Srdivacky if (DisableInline) { 419202878Srdivacky // No inlining pass 420223013Sdim } else if (OptLevel > 1) { 421218885Sdim unsigned Threshold = 225; 422202878Srdivacky if (OptLevel > 2) 423218885Sdim Threshold = 275; 424223013Sdim Builder.Inliner = createFunctionInliningPass(Threshold); 425202878Srdivacky } else { 426223013Sdim Builder.Inliner = createAlwaysInlinerPass(); 427202878Srdivacky } 428223013Sdim Builder.DisableUnitAtATime = !UnitAtATime; 429223013Sdim Builder.DisableUnrollLoops = OptLevel == 0; 430223013Sdim Builder.DisableSimplifyLibCalls = DisableSimplifyLibCalls; 431223013Sdim 432223013Sdim Builder.populateFunctionPassManager(FPM); 433223013Sdim Builder.populateModulePassManager(MPM); 434193323Sed} 435193323Sed 436223013Sdimstatic void AddStandardCompilePasses(PassManagerBase &PM) { 437193323Sed PM.add(createVerifierPass()); // Verify that input is correct 438193323Sed 439193323Sed // If the -strip-debug command line option was specified, do it. 440193323Sed if (StripDebug) 441193323Sed addPass(PM, createStripSymbolsPass(true)); 442193323Sed 443193323Sed if (DisableOptimizations) return; 444193323Sed 445193399Sed // -std-compile-opts adds the same module passes as -O3. 446223013Sdim PassManagerBuilder Builder; 447223013Sdim if (!DisableInline) 448223013Sdim Builder.Inliner = createFunctionInliningPass(); 449223013Sdim Builder.OptLevel = 3; 450223013Sdim Builder.DisableSimplifyLibCalls = DisableSimplifyLibCalls; 451223013Sdim Builder.populateModulePassManager(PM); 452193323Sed} 453193323Sed 454223013Sdimstatic void AddStandardLinkPasses(PassManagerBase &PM) { 455198090Srdivacky PM.add(createVerifierPass()); // Verify that input is correct 456198090Srdivacky 457198090Srdivacky // If the -strip-debug command line option was specified, do it. 458198090Srdivacky if (StripDebug) 459198090Srdivacky addPass(PM, createStripSymbolsPass(true)); 460198090Srdivacky 461198090Srdivacky if (DisableOptimizations) return; 462198090Srdivacky 463223013Sdim PassManagerBuilder Builder; 464223013Sdim Builder.populateLTOPassManager(PM, /*Internalize=*/ !DisableInternalize, 465223013Sdim /*RunInliner=*/ !DisableInline); 466198090Srdivacky} 467198090Srdivacky 468193323Sed 469193323Sed//===----------------------------------------------------------------------===// 470193323Sed// main for opt 471193323Sed// 472193323Sedint main(int argc, char **argv) { 473200581Srdivacky sys::PrintStackTraceOnErrorSignal(); 474200581Srdivacky llvm::PrettyStackTraceProgram X(argc, argv); 475212793Sdim 476202375Srdivacky // Enable debug stream buffering. 477202375Srdivacky EnableDebugBuffering = true; 478202375Srdivacky 479200581Srdivacky llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 480198090Srdivacky LLVMContext &Context = getGlobalContext(); 481221337Sdim 482218885Sdim // Initialize passes 483218885Sdim PassRegistry &Registry = *PassRegistry::getPassRegistry(); 484218885Sdim initializeCore(Registry); 485218885Sdim initializeScalarOpts(Registry); 486235633Sdim initializeVectorization(Registry); 487218885Sdim initializeIPO(Registry); 488218885Sdim initializeAnalysis(Registry); 489218885Sdim initializeIPA(Registry); 490218885Sdim initializeTransformUtils(Registry); 491218885Sdim initializeInstCombine(Registry); 492218885Sdim initializeInstrumentation(Registry); 493218885Sdim initializeTarget(Registry); 494221337Sdim 495198396Srdivacky cl::ParseCommandLineOptions(argc, argv, 496198396Srdivacky "llvm .bc -> .bc modular optimizer and analysis printer\n"); 497193323Sed 498218885Sdim if (AnalyzeOnly && NoOutput) { 499218885Sdim errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n"; 500218885Sdim return 1; 501218885Sdim } 502218885Sdim 503198396Srdivacky // Allocate a full target machine description only if necessary. 504198396Srdivacky // FIXME: The choice of target should be controllable on the command line. 505198396Srdivacky std::auto_ptr<TargetMachine> target; 506193323Sed 507198396Srdivacky SMDiagnostic Err; 508193323Sed 509198396Srdivacky // Load the input module... 510198396Srdivacky std::auto_ptr<Module> M; 511198396Srdivacky M.reset(ParseIRFile(InputFilename, Err, Context)); 512198090Srdivacky 513198396Srdivacky if (M.get() == 0) { 514235633Sdim Err.print(argv[0], errs()); 515198396Srdivacky return 1; 516198396Srdivacky } 517193323Sed 518235633Sdim // If we are supposed to override the target triple, do so now. 519235633Sdim if (!TargetTriple.empty()) 520235633Sdim M->setTargetTriple(Triple::normalize(TargetTriple)); 521235633Sdim 522198396Srdivacky // Figure out what stream we are supposed to write to... 523212793Sdim OwningPtr<tool_output_file> Out; 524212793Sdim if (NoOutput) { 525212793Sdim if (!OutputFilename.empty()) 526212793Sdim errs() << "WARNING: The -o (output filename) option is ignored when\n" 527212793Sdim "the --disable-output option is used.\n"; 528212793Sdim } else { 529212793Sdim // Default to standard output. 530212793Sdim if (OutputFilename.empty()) 531212793Sdim OutputFilename = "-"; 532193323Sed 533212793Sdim std::string ErrorInfo; 534212793Sdim Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo, 535212793Sdim raw_fd_ostream::F_Binary)); 536212793Sdim if (!ErrorInfo.empty()) { 537212793Sdim errs() << ErrorInfo << '\n'; 538212793Sdim return 1; 539193323Sed } 540198396Srdivacky } 541193323Sed 542198396Srdivacky // If the output is set to be emitted to standard out, and standard out is a 543198396Srdivacky // console, print out a warning message and refuse to do it. We don't 544198396Srdivacky // impress anyone by spewing tons of binary goo to a terminal. 545202878Srdivacky if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly) 546212793Sdim if (CheckBitcodeOutputToConsole(Out->os(), !Quiet)) 547198396Srdivacky NoOutput = true; 548193323Sed 549198396Srdivacky // Create a PassManager to hold and optimize the collection of passes we are 550218885Sdim // about to build. 551198396Srdivacky // 552198396Srdivacky PassManager Passes; 553193323Sed 554218885Sdim // Add an appropriate TargetLibraryInfo pass for the module's triple. 555218885Sdim TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple())); 556221337Sdim 557218885Sdim // The -disable-simplify-libcalls flag actually disables all builtin optzns. 558218885Sdim if (DisableSimplifyLibCalls) 559218885Sdim TLI->disableAllFunctions(); 560218885Sdim Passes.add(TLI); 561221337Sdim 562218885Sdim // Add an appropriate TargetData instance for this module. 563198396Srdivacky TargetData *TD = 0; 564198396Srdivacky const std::string &ModuleDataLayout = M.get()->getDataLayout(); 565198396Srdivacky if (!ModuleDataLayout.empty()) 566198396Srdivacky TD = new TargetData(ModuleDataLayout); 567198892Srdivacky else if (!DefaultDataLayout.empty()) 568198396Srdivacky TD = new TargetData(DefaultDataLayout); 569193323Sed 570198396Srdivacky if (TD) 571198396Srdivacky Passes.add(TD); 572198090Srdivacky 573223013Sdim OwningPtr<FunctionPassManager> FPasses; 574198396Srdivacky if (OptLevelO1 || OptLevelO2 || OptLevelO3) { 575223013Sdim FPasses.reset(new FunctionPassManager(M.get())); 576198396Srdivacky if (TD) 577198396Srdivacky FPasses->add(new TargetData(*TD)); 578198396Srdivacky } 579193323Sed 580218885Sdim if (PrintBreakpoints) { 581218885Sdim // Default to standard output. 582218885Sdim if (!Out) { 583218885Sdim if (OutputFilename.empty()) 584218885Sdim OutputFilename = "-"; 585221337Sdim 586218885Sdim std::string ErrorInfo; 587218885Sdim Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo, 588218885Sdim raw_fd_ostream::F_Binary)); 589218885Sdim if (!ErrorInfo.empty()) { 590218885Sdim errs() << ErrorInfo << '\n'; 591218885Sdim return 1; 592218885Sdim } 593218885Sdim } 594218885Sdim Passes.add(new BreakpointPrinter(Out->os())); 595218885Sdim NoOutput = true; 596218885Sdim } 597218885Sdim 598198396Srdivacky // If the -strip-debug command line option was specified, add it. If 599198396Srdivacky // -std-compile-opts was also specified, it will handle StripDebug. 600198396Srdivacky if (StripDebug && !StandardCompileOpts) 601198396Srdivacky addPass(Passes, createStripSymbolsPass(true)); 602198090Srdivacky 603198396Srdivacky // Create a new optimization pass for each one specified on the command line 604198396Srdivacky for (unsigned i = 0; i < PassList.size(); ++i) { 605198396Srdivacky // Check to see if -std-compile-opts was specified before this option. If 606198396Srdivacky // so, handle it. 607198396Srdivacky if (StandardCompileOpts && 608198396Srdivacky StandardCompileOpts.getPosition() < PassList.getPosition(i)) { 609193323Sed AddStandardCompilePasses(Passes); 610193323Sed StandardCompileOpts = false; 611198090Srdivacky } 612193323Sed 613198396Srdivacky if (StandardLinkOpts && 614198396Srdivacky StandardLinkOpts.getPosition() < PassList.getPosition(i)) { 615198090Srdivacky AddStandardLinkPasses(Passes); 616198090Srdivacky StandardLinkOpts = false; 617198090Srdivacky } 618198090Srdivacky 619198396Srdivacky if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) { 620198090Srdivacky AddOptimizationPasses(Passes, *FPasses, 1); 621198396Srdivacky OptLevelO1 = false; 622198090Srdivacky } 623193323Sed 624198396Srdivacky if (OptLevelO2 && OptLevelO2.getPosition() < PassList.getPosition(i)) { 625198090Srdivacky AddOptimizationPasses(Passes, *FPasses, 2); 626198396Srdivacky OptLevelO2 = false; 627198090Srdivacky } 628193323Sed 629198396Srdivacky if (OptLevelO3 && OptLevelO3.getPosition() < PassList.getPosition(i)) { 630198090Srdivacky AddOptimizationPasses(Passes, *FPasses, 3); 631198396Srdivacky OptLevelO3 = false; 632198090Srdivacky } 633193323Sed 634198396Srdivacky const PassInfo *PassInf = PassList[i]; 635198396Srdivacky Pass *P = 0; 636198396Srdivacky if (PassInf->getNormalCtor()) 637198396Srdivacky P = PassInf->getNormalCtor()(); 638198396Srdivacky else 639198396Srdivacky errs() << argv[0] << ": cannot create pass: " 640198396Srdivacky << PassInf->getPassName() << "\n"; 641198396Srdivacky if (P) { 642204642Srdivacky PassKind Kind = P->getPassKind(); 643198396Srdivacky addPass(Passes, P); 644193323Sed 645198396Srdivacky if (AnalyzeOnly) { 646204642Srdivacky switch (Kind) { 647202878Srdivacky case PT_BasicBlock: 648212793Sdim Passes.add(new BasicBlockPassPrinter(PassInf, Out->os())); 649202878Srdivacky break; 650218885Sdim case PT_Region: 651218885Sdim Passes.add(new RegionPassPrinter(PassInf, Out->os())); 652218885Sdim break; 653202878Srdivacky case PT_Loop: 654212793Sdim Passes.add(new LoopPassPrinter(PassInf, Out->os())); 655202878Srdivacky break; 656202878Srdivacky case PT_Function: 657212793Sdim Passes.add(new FunctionPassPrinter(PassInf, Out->os())); 658202878Srdivacky break; 659202878Srdivacky case PT_CallGraphSCC: 660212793Sdim Passes.add(new CallGraphSCCPassPrinter(PassInf, Out->os())); 661202878Srdivacky break; 662202878Srdivacky default: 663212793Sdim Passes.add(new ModulePassPrinter(PassInf, Out->os())); 664202878Srdivacky break; 665202878Srdivacky } 666198396Srdivacky } 667198090Srdivacky } 668193323Sed 669198396Srdivacky if (PrintEachXForm) 670198396Srdivacky Passes.add(createPrintModulePass(&errs())); 671198396Srdivacky } 672193323Sed 673198396Srdivacky // If -std-compile-opts was specified at the end of the pass list, add them. 674198396Srdivacky if (StandardCompileOpts) { 675198396Srdivacky AddStandardCompilePasses(Passes); 676198396Srdivacky StandardCompileOpts = false; 677198396Srdivacky } 678193323Sed 679198396Srdivacky if (StandardLinkOpts) { 680198396Srdivacky AddStandardLinkPasses(Passes); 681198396Srdivacky StandardLinkOpts = false; 682193323Sed } 683198396Srdivacky 684198396Srdivacky if (OptLevelO1) 685198396Srdivacky AddOptimizationPasses(Passes, *FPasses, 1); 686198396Srdivacky 687198396Srdivacky if (OptLevelO2) 688198396Srdivacky AddOptimizationPasses(Passes, *FPasses, 2); 689198396Srdivacky 690198396Srdivacky if (OptLevelO3) 691198396Srdivacky AddOptimizationPasses(Passes, *FPasses, 3); 692198396Srdivacky 693223013Sdim if (OptLevelO1 || OptLevelO2 || OptLevelO3) { 694223013Sdim FPasses->doInitialization(); 695223013Sdim for (Module::iterator F = M->begin(), E = M->end(); F != E; ++F) 696223013Sdim FPasses->run(*F); 697223013Sdim FPasses->doFinalization(); 698223013Sdim } 699198396Srdivacky 700198396Srdivacky // Check that the module is well formed on completion of optimization 701198396Srdivacky if (!NoVerify && !VerifyEach) 702198396Srdivacky Passes.add(createVerifierPass()); 703198396Srdivacky 704212793Sdim // Write bitcode or assembly to the output as the last step... 705198396Srdivacky if (!NoOutput && !AnalyzeOnly) { 706198396Srdivacky if (OutputAssembly) 707212793Sdim Passes.add(createPrintModulePass(&Out->os())); 708198396Srdivacky else 709212793Sdim Passes.add(createBitcodeWriterPass(Out->os())); 710198396Srdivacky } 711198396Srdivacky 712221337Sdim // Before executing passes, print the final values of the LLVM options. 713221337Sdim cl::PrintOptionValues(); 714221337Sdim 715198396Srdivacky // Now that we have all of the passes ready, run them. 716198396Srdivacky Passes.run(*M.get()); 717198396Srdivacky 718212793Sdim // Declare success. 719218885Sdim if (!NoOutput || PrintBreakpoints) 720212793Sdim Out->keep(); 721212793Sdim 722198396Srdivacky return 0; 723193323Sed} 724