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 15252723Sdim#include "llvm/IR/LLVMContext.h" 16252723Sdim#include "llvm/ADT/StringSet.h" 17252723Sdim#include "llvm/ADT/Triple.h" 18252723Sdim#include "llvm/Analysis/CallGraph.h" 19252723Sdim#include "llvm/Analysis/CallGraphSCCPass.h" 20252723Sdim#include "llvm/Analysis/LoopPass.h" 21252723Sdim#include "llvm/Analysis/RegionPass.h" 22252723Sdim#include "llvm/Analysis/Verifier.h" 23252723Sdim#include "llvm/Assembly/PrintModulePass.h" 24252723Sdim#include "llvm/Bitcode/ReaderWriter.h" 25252723Sdim#include "llvm/CodeGen/CommandFlags.h" 26245431Sdim#include "llvm/DebugInfo.h" 27252723Sdim#include "llvm/IR/DataLayout.h" 28252723Sdim#include "llvm/IR/Module.h" 29252723Sdim#include "llvm/IRReader/IRReader.h" 30252723Sdim#include "llvm/LinkAllIR.h" 31252723Sdim#include "llvm/LinkAllPasses.h" 32252723Sdim#include "llvm/MC/SubtargetFeature.h" 33193323Sed#include "llvm/PassManager.h" 34202375Srdivacky#include "llvm/Support/Debug.h" 35193323Sed#include "llvm/Support/ManagedStatic.h" 36252723Sdim#include "llvm/Support/PassNameParser.h" 37193323Sed#include "llvm/Support/PluginLoader.h" 38200581Srdivacky#include "llvm/Support/PrettyStackTrace.h" 39252723Sdim#include "llvm/Support/Signals.h" 40252723Sdim#include "llvm/Support/SourceMgr.h" 41193323Sed#include "llvm/Support/SystemUtils.h" 42245431Sdim#include "llvm/Support/TargetRegistry.h" 43252723Sdim#include "llvm/Support/TargetSelect.h" 44218885Sdim#include "llvm/Support/ToolOutputFile.h" 45252723Sdim#include "llvm/Target/TargetLibraryInfo.h" 46252723Sdim#include "llvm/Target/TargetMachine.h" 47226584Sdim#include "llvm/Transforms/IPO/PassManagerBuilder.h" 48252723Sdim#include <algorithm> 49193323Sed#include <memory> 50193323Sedusing namespace llvm; 51193323Sed 52193323Sed// The OptimizationList is automatically populated with registered Passes by the 53193323Sed// PassNameParser. 54193323Sed// 55193323Sedstatic cl::list<const PassInfo*, bool, PassNameParser> 56193323SedPassList(cl::desc("Optimizations available:")); 57193323Sed 58193323Sed// Other command line options... 59193323Sed// 60193323Sedstatic cl::opt<std::string> 61198090SrdivackyInputFilename(cl::Positional, cl::desc("<input bitcode file>"), 62193323Sed cl::init("-"), cl::value_desc("filename")); 63193323Sed 64193323Sedstatic cl::opt<std::string> 65193323SedOutputFilename("o", cl::desc("Override output filename"), 66212793Sdim cl::value_desc("filename")); 67193323Sed 68193323Sedstatic cl::opt<bool> 69198090SrdivackyForce("f", cl::desc("Enable binary output on terminals")); 70193323Sed 71193323Sedstatic cl::opt<bool> 72193323SedPrintEachXForm("p", cl::desc("Print module after each transformation")); 73193323Sed 74193323Sedstatic cl::opt<bool> 75193323SedNoOutput("disable-output", 76193323Sed cl::desc("Do not write result bitcode file"), cl::Hidden); 77193323Sed 78193323Sedstatic cl::opt<bool> 79198113SrdivackyOutputAssembly("S", cl::desc("Write output as LLVM assembly")); 80198090Srdivacky 81198090Srdivackystatic cl::opt<bool> 82193323SedNoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden); 83193323Sed 84193323Sedstatic cl::opt<bool> 85193323SedVerifyEach("verify-each", cl::desc("Verify after each transform")); 86193323Sed 87193323Sedstatic cl::opt<bool> 88193323SedStripDebug("strip-debug", 89193323Sed cl::desc("Strip debugger symbol info from translation unit")); 90193323Sed 91193323Sedstatic cl::opt<bool> 92193323SedDisableInline("disable-inlining", cl::desc("Do not run the inliner pass")); 93193323Sed 94198090Srdivackystatic cl::opt<bool> 95198090SrdivackyDisableOptimizations("disable-opt", 96193323Sed cl::desc("Do not run any optimization passes")); 97193323Sed 98193323Sedstatic cl::opt<bool> 99198090SrdivackyDisableInternalize("disable-internalize", 100198090Srdivacky cl::desc("Do not mark all symbols as internal")); 101198090Srdivacky 102198090Srdivackystatic cl::opt<bool> 103198090SrdivackyStandardCompileOpts("std-compile-opts", 104193323Sed cl::desc("Include the standard compile time optimizations")); 105193323Sed 106193323Sedstatic cl::opt<bool> 107198090SrdivackyStandardLinkOpts("std-link-opts", 108198090Srdivacky cl::desc("Include the standard link time optimizations")); 109198090Srdivacky 110198090Srdivackystatic cl::opt<bool> 111193323SedOptLevelO1("O1", 112245431Sdim cl::desc("Optimization level 1. Similar to clang -O1")); 113193323Sed 114193323Sedstatic cl::opt<bool> 115193323SedOptLevelO2("O2", 116245431Sdim cl::desc("Optimization level 2. Similar to clang -O2")); 117193323Sed 118193323Sedstatic cl::opt<bool> 119245431SdimOptLevelOs("Os", 120245431Sdim cl::desc("Like -O2 with extra optimizations for size. Similar to clang -Os")); 121245431Sdim 122245431Sdimstatic cl::opt<bool> 123245431SdimOptLevelOz("Oz", 124245431Sdim cl::desc("Like -Os but reduces code size further. Similar to clang -Oz")); 125245431Sdim 126245431Sdimstatic cl::opt<bool> 127193323SedOptLevelO3("O3", 128245431Sdim cl::desc("Optimization level 3. Similar to clang -O3")); 129193323Sed 130235633Sdimstatic cl::opt<std::string> 131235633SdimTargetTriple("mtriple", cl::desc("Override target triple for module")); 132235633Sdim 133193323Sedstatic cl::opt<bool> 134193323SedUnitAtATime("funit-at-a-time", 135198090Srdivacky cl::desc("Enable IPO. This is same as llvm-gcc's -funit-at-a-time"), 136210006Srdivacky cl::init(true)); 137193323Sed 138193323Sedstatic cl::opt<bool> 139263509SdimDisableLoopUnrolling("disable-loop-unrolling", 140263509Sdim cl::desc("Disable loop unrolling in all relevant passes"), 141263509Sdim cl::init(false)); 142263509Sdimstatic cl::opt<bool> 143263509SdimDisableLoopVectorization("disable-loop-vectorization", 144263509Sdim cl::desc("Disable the loop vectorization pass"), 145263509Sdim cl::init(false)); 146263509Sdim 147263509Sdimstatic cl::opt<bool> 148263509SdimDisableSLPVectorization("disable-slp-vectorization", 149263509Sdim cl::desc("Disable the slp vectorization pass"), 150263509Sdim cl::init(false)); 151263509Sdim 152263509Sdim 153263509Sdimstatic cl::opt<bool> 154193323SedDisableSimplifyLibCalls("disable-simplify-libcalls", 155193323Sed cl::desc("Disable simplify-libcalls")); 156193323Sed 157193323Sedstatic cl::opt<bool> 158193323SedQuiet("q", cl::desc("Obsolete option"), cl::Hidden); 159193323Sed 160193323Sedstatic cl::alias 161193323SedQuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet)); 162193323Sed 163193323Sedstatic cl::opt<bool> 164193323SedAnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization")); 165193323Sed 166218885Sdimstatic cl::opt<bool> 167221337SdimPrintBreakpoints("print-breakpoints-for-testing", 168218885Sdim cl::desc("Print select breakpoints location for testing")); 169218885Sdim 170198396Srdivackystatic cl::opt<std::string> 171221337SdimDefaultDataLayout("default-data-layout", 172198396Srdivacky cl::desc("data layout string to use if not specified by module"), 173198396Srdivacky cl::value_desc("layout-string"), cl::init("")); 174198396Srdivacky 175193323Sed// ---------- Define Printers for module and function passes ------------ 176193323Sednamespace { 177193323Sed 178193323Sedstruct CallGraphSCCPassPrinter : public CallGraphSCCPass { 179193323Sed static char ID; 180193323Sed const PassInfo *PassToPrint; 181212793Sdim raw_ostream &Out; 182218885Sdim std::string PassName; 183218885Sdim 184212793Sdim CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out) : 185218885Sdim CallGraphSCCPass(ID), PassToPrint(PI), Out(out) { 186218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 187218885Sdim PassName = "CallGraphSCCPass Printer: " + PassToPrintName; 188218885Sdim } 189193323Sed 190207618Srdivacky virtual bool runOnSCC(CallGraphSCC &SCC) { 191218885Sdim if (!Quiet) 192212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; 193193323Sed 194218885Sdim // Get and print pass... 195218885Sdim for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 196218885Sdim Function *F = (*I)->getFunction(); 197218885Sdim if (F) 198218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 199218885Sdim F->getParent()); 200193323Sed } 201193323Sed return false; 202193323Sed } 203198090Srdivacky 204218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 205193323Sed 206193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 207212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 208193323Sed AU.setPreservesAll(); 209193323Sed } 210193323Sed}; 211193323Sed 212193323Sedchar CallGraphSCCPassPrinter::ID = 0; 213193323Sed 214193323Sedstruct ModulePassPrinter : public ModulePass { 215193323Sed static char ID; 216193323Sed const PassInfo *PassToPrint; 217212793Sdim raw_ostream &Out; 218218885Sdim std::string PassName; 219218885Sdim 220212793Sdim ModulePassPrinter(const PassInfo *PI, raw_ostream &out) 221218885Sdim : ModulePass(ID), PassToPrint(PI), Out(out) { 222218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 223218885Sdim PassName = "ModulePass Printer: " + PassToPrintName; 224218885Sdim } 225193323Sed 226193323Sed virtual bool runOnModule(Module &M) { 227218885Sdim if (!Quiet) 228212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; 229193323Sed 230193323Sed // Get and print pass... 231218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M); 232193323Sed return false; 233193323Sed } 234193323Sed 235218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 236193323Sed 237193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 238212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 239193323Sed AU.setPreservesAll(); 240193323Sed } 241193323Sed}; 242193323Sed 243193323Sedchar ModulePassPrinter::ID = 0; 244193323Sedstruct FunctionPassPrinter : public FunctionPass { 245193323Sed const PassInfo *PassToPrint; 246212793Sdim raw_ostream &Out; 247193323Sed static char ID; 248218885Sdim std::string PassName; 249218885Sdim 250212793Sdim FunctionPassPrinter(const PassInfo *PI, raw_ostream &out) 251218885Sdim : FunctionPass(ID), PassToPrint(PI), Out(out) { 252218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 253218885Sdim PassName = "FunctionPass Printer: " + PassToPrintName; 254218885Sdim } 255193323Sed 256193323Sed virtual bool runOnFunction(Function &F) { 257218885Sdim if (!Quiet) 258212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() 259212793Sdim << "' for function '" << F.getName() << "':\n"; 260218885Sdim 261193323Sed // Get and print pass... 262212793Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 263212793Sdim F.getParent()); 264193323Sed return false; 265193323Sed } 266193323Sed 267218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 268193323Sed 269193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 270212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 271193323Sed AU.setPreservesAll(); 272193323Sed } 273193323Sed}; 274193323Sed 275193323Sedchar FunctionPassPrinter::ID = 0; 276193323Sed 277193323Sedstruct LoopPassPrinter : public LoopPass { 278193323Sed static char ID; 279193323Sed const PassInfo *PassToPrint; 280212793Sdim raw_ostream &Out; 281218885Sdim std::string PassName; 282218885Sdim 283212793Sdim LoopPassPrinter(const PassInfo *PI, raw_ostream &out) : 284218885Sdim LoopPass(ID), PassToPrint(PI), Out(out) { 285218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 286218885Sdim PassName = "LoopPass Printer: " + PassToPrintName; 287218885Sdim } 288193323Sed 289218885Sdim 290193323Sed virtual bool runOnLoop(Loop *L, LPPassManager &LPM) { 291218885Sdim if (!Quiet) 292212793Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; 293218885Sdim 294193323Sed // Get and print pass... 295218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 296218885Sdim L->getHeader()->getParent()->getParent()); 297193323Sed return false; 298193323Sed } 299198090Srdivacky 300218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 301193323Sed 302193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 303212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 304193323Sed AU.setPreservesAll(); 305193323Sed } 306193323Sed}; 307193323Sed 308193323Sedchar LoopPassPrinter::ID = 0; 309193323Sed 310218885Sdimstruct RegionPassPrinter : public RegionPass { 311218885Sdim static char ID; 312218885Sdim const PassInfo *PassToPrint; 313218885Sdim raw_ostream &Out; 314218885Sdim std::string PassName; 315218885Sdim 316218885Sdim RegionPassPrinter(const PassInfo *PI, raw_ostream &out) : RegionPass(ID), 317218885Sdim PassToPrint(PI), Out(out) { 318218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 319218885Sdim PassName = "RegionPass Printer: " + PassToPrintName; 320218885Sdim } 321218885Sdim 322218885Sdim virtual bool runOnRegion(Region *R, RGPassManager &RGM) { 323218885Sdim if (!Quiet) { 324218885Sdim Out << "Printing analysis '" << PassToPrint->getPassName() << "' for " 325235633Sdim << "region: '" << R->getNameStr() << "' in function '" 326235633Sdim << R->getEntry()->getParent()->getName() << "':\n"; 327218885Sdim } 328218885Sdim // Get and print pass... 329218885Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 330218885Sdim R->getEntry()->getParent()->getParent()); 331218885Sdim return false; 332218885Sdim } 333218885Sdim 334218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 335218885Sdim 336218885Sdim virtual void getAnalysisUsage(AnalysisUsage &AU) const { 337218885Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 338218885Sdim AU.setPreservesAll(); 339218885Sdim } 340218885Sdim}; 341218885Sdim 342218885Sdimchar RegionPassPrinter::ID = 0; 343218885Sdim 344193323Sedstruct BasicBlockPassPrinter : public BasicBlockPass { 345193323Sed const PassInfo *PassToPrint; 346212793Sdim raw_ostream &Out; 347193323Sed static char ID; 348218885Sdim std::string PassName; 349218885Sdim 350212793Sdim BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out) 351218885Sdim : BasicBlockPass(ID), PassToPrint(PI), Out(out) { 352218885Sdim std::string PassToPrintName = PassToPrint->getPassName(); 353218885Sdim PassName = "BasicBlockPass Printer: " + PassToPrintName; 354218885Sdim } 355193323Sed 356193323Sed virtual bool runOnBasicBlock(BasicBlock &BB) { 357218885Sdim if (!Quiet) 358212793Sdim Out << "Printing Analysis info for BasicBlock '" << BB.getName() 359212793Sdim << "': Pass " << PassToPrint->getPassName() << ":\n"; 360193323Sed 361193323Sed // Get and print pass... 362221337Sdim getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, 363212793Sdim BB.getParent()->getParent()); 364193323Sed return false; 365193323Sed } 366193323Sed 367218885Sdim virtual const char *getPassName() const { return PassName.c_str(); } 368193323Sed 369193323Sed virtual void getAnalysisUsage(AnalysisUsage &AU) const { 370212793Sdim AU.addRequiredID(PassToPrint->getTypeInfo()); 371193323Sed AU.setPreservesAll(); 372193323Sed } 373193323Sed}; 374193323Sed 375193323Sedchar BasicBlockPassPrinter::ID = 0; 376218885Sdim 377221337Sdimstruct BreakpointPrinter : public ModulePass { 378218885Sdim raw_ostream &Out; 379218885Sdim static char ID; 380263509Sdim DITypeIdentifierMap TypeIdentifierMap; 381218885Sdim 382218885Sdim BreakpointPrinter(raw_ostream &out) 383221337Sdim : ModulePass(ID), Out(out) { 384218885Sdim } 385218885Sdim 386221337Sdim void getContextName(DIDescriptor Context, std::string &N) { 387221337Sdim if (Context.isNameSpace()) { 388221337Sdim DINameSpace NS(Context); 389221337Sdim if (!NS.getName().empty()) { 390221337Sdim getContextName(NS.getContext(), N); 391221337Sdim N = N + NS.getName().str() + "::"; 392218885Sdim } 393221337Sdim } else if (Context.isType()) { 394221337Sdim DIType TY(Context); 395221337Sdim if (!TY.getName().empty()) { 396263509Sdim getContextName(TY.getContext().resolve(TypeIdentifierMap), N); 397221337Sdim N = N + TY.getName().str() + "::"; 398221337Sdim } 399221337Sdim } 400221337Sdim } 401221337Sdim 402221337Sdim virtual bool runOnModule(Module &M) { 403263509Sdim TypeIdentifierMap.clear(); 404263509Sdim NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu"); 405263509Sdim if (CU_Nodes) 406263509Sdim TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes); 407263509Sdim 408221337Sdim StringSet<> Processed; 409221337Sdim if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp")) 410221337Sdim for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { 411221337Sdim std::string Name; 412221337Sdim DISubprogram SP(NMD->getOperand(i)); 413263509Sdim assert((!SP || SP.isSubprogram()) && 414263509Sdim "A MDNode in llvm.dbg.sp should be null or a DISubprogram."); 415263509Sdim if (!SP) 416263509Sdim continue; 417263509Sdim getContextName(SP.getContext().resolve(TypeIdentifierMap), Name); 418221337Sdim Name = Name + SP.getDisplayName().str(); 419221337Sdim if (!Name.empty() && Processed.insert(Name)) { 420221337Sdim Out << Name << "\n"; 421221337Sdim } 422221337Sdim } 423218885Sdim return false; 424218885Sdim } 425218885Sdim 426218885Sdim virtual void getAnalysisUsage(AnalysisUsage &AU) const { 427218885Sdim AU.setPreservesAll(); 428218885Sdim } 429218885Sdim}; 430263509Sdim 431223013Sdim} // anonymous namespace 432218885Sdim 433218885Sdimchar BreakpointPrinter::ID = 0; 434218885Sdim 435223013Sdimstatic inline void addPass(PassManagerBase &PM, Pass *P) { 436193323Sed // Add the pass to the pass manager... 437193323Sed PM.add(P); 438193323Sed 439193323Sed // If we are verifying all of the intermediate steps, add the verifier... 440193323Sed if (VerifyEach) PM.add(createVerifierPass()); 441193323Sed} 442193323Sed 443198090Srdivacky/// AddOptimizationPasses - This routine adds optimization passes 444198090Srdivacky/// based on selected optimization level, OptLevel. This routine 445193323Sed/// duplicates llvm-gcc behaviour. 446193323Sed/// 447193323Sed/// OptLevel - Optimization Level 448223013Sdimstatic void AddOptimizationPasses(PassManagerBase &MPM,FunctionPassManager &FPM, 449245431Sdim unsigned OptLevel, unsigned SizeLevel) { 450235633Sdim FPM.add(createVerifierPass()); // Verify that input is correct 451235633Sdim 452223013Sdim PassManagerBuilder Builder; 453223013Sdim Builder.OptLevel = OptLevel; 454245431Sdim Builder.SizeLevel = SizeLevel; 455193323Sed 456202878Srdivacky if (DisableInline) { 457202878Srdivacky // No inlining pass 458223013Sdim } else if (OptLevel > 1) { 459218885Sdim unsigned Threshold = 225; 460245431Sdim if (SizeLevel == 1) // -Os 461245431Sdim Threshold = 75; 462245431Sdim else if (SizeLevel == 2) // -Oz 463245431Sdim Threshold = 25; 464202878Srdivacky if (OptLevel > 2) 465218885Sdim Threshold = 275; 466223013Sdim Builder.Inliner = createFunctionInliningPass(Threshold); 467202878Srdivacky } else { 468223013Sdim Builder.Inliner = createAlwaysInlinerPass(); 469202878Srdivacky } 470223013Sdim Builder.DisableUnitAtATime = !UnitAtATime; 471263509Sdim Builder.DisableUnrollLoops = (DisableLoopUnrolling.getNumOccurrences() > 0) ? 472263509Sdim DisableLoopUnrolling : OptLevel == 0; 473263509Sdim 474263509Sdim Builder.LoopVectorize = 475263509Sdim DisableLoopVectorization ? false : OptLevel > 1 && SizeLevel < 2; 476263509Sdim Builder.SLPVectorize = 477263509Sdim DisableSLPVectorization ? false : OptLevel > 1 && SizeLevel < 2; 478263509Sdim 479223013Sdim Builder.populateFunctionPassManager(FPM); 480223013Sdim Builder.populateModulePassManager(MPM); 481193323Sed} 482193323Sed 483223013Sdimstatic void AddStandardCompilePasses(PassManagerBase &PM) { 484193323Sed PM.add(createVerifierPass()); // Verify that input is correct 485193323Sed 486193323Sed // If the -strip-debug command line option was specified, do it. 487193323Sed if (StripDebug) 488193323Sed addPass(PM, createStripSymbolsPass(true)); 489193323Sed 490193323Sed if (DisableOptimizations) return; 491193323Sed 492193399Sed // -std-compile-opts adds the same module passes as -O3. 493223013Sdim PassManagerBuilder Builder; 494223013Sdim if (!DisableInline) 495223013Sdim Builder.Inliner = createFunctionInliningPass(); 496223013Sdim Builder.OptLevel = 3; 497223013Sdim Builder.populateModulePassManager(PM); 498193323Sed} 499193323Sed 500223013Sdimstatic void AddStandardLinkPasses(PassManagerBase &PM) { 501198090Srdivacky PM.add(createVerifierPass()); // Verify that input is correct 502198090Srdivacky 503198090Srdivacky // If the -strip-debug command line option was specified, do it. 504198090Srdivacky if (StripDebug) 505198090Srdivacky addPass(PM, createStripSymbolsPass(true)); 506198090Srdivacky 507198090Srdivacky if (DisableOptimizations) return; 508198090Srdivacky 509223013Sdim PassManagerBuilder Builder; 510223013Sdim Builder.populateLTOPassManager(PM, /*Internalize=*/ !DisableInternalize, 511223013Sdim /*RunInliner=*/ !DisableInline); 512198090Srdivacky} 513198090Srdivacky 514245431Sdim//===----------------------------------------------------------------------===// 515245431Sdim// CodeGen-related helper functions. 516245431Sdim// 517245431Sdimstatic TargetOptions GetTargetOptions() { 518245431Sdim TargetOptions Options; 519245431Sdim Options.LessPreciseFPMADOption = EnableFPMAD; 520245431Sdim Options.NoFramePointerElim = DisableFPElim; 521245431Sdim Options.AllowFPOpFusion = FuseFPOps; 522245431Sdim Options.UnsafeFPMath = EnableUnsafeFPMath; 523245431Sdim Options.NoInfsFPMath = EnableNoInfsFPMath; 524245431Sdim Options.NoNaNsFPMath = EnableNoNaNsFPMath; 525245431Sdim Options.HonorSignDependentRoundingFPMathOption = 526245431Sdim EnableHonorSignDependentRoundingFPMath; 527245431Sdim Options.UseSoftFloat = GenerateSoftFloatCalls; 528245431Sdim if (FloatABIForCalls != FloatABI::Default) 529245431Sdim Options.FloatABIType = FloatABIForCalls; 530245431Sdim Options.NoZerosInBSS = DontPlaceZerosInBSS; 531245431Sdim Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt; 532245431Sdim Options.DisableTailCalls = DisableTailCalls; 533245431Sdim Options.StackAlignmentOverride = OverrideStackAlignment; 534245431Sdim Options.TrapFuncName = TrapFuncName; 535245431Sdim Options.PositionIndependentExecutable = EnablePIE; 536245431Sdim Options.EnableSegmentedStacks = SegmentedStacks; 537245431Sdim Options.UseInitArray = UseInitArray; 538245431Sdim return Options; 539245431Sdim} 540193323Sed 541245431SdimCodeGenOpt::Level GetCodeGenOptLevel() { 542245431Sdim if (OptLevelO1) 543245431Sdim return CodeGenOpt::Less; 544245431Sdim if (OptLevelO2) 545245431Sdim return CodeGenOpt::Default; 546245431Sdim if (OptLevelO3) 547245431Sdim return CodeGenOpt::Aggressive; 548245431Sdim return CodeGenOpt::None; 549245431Sdim} 550245431Sdim 551245431Sdim// Returns the TargetMachine instance or zero if no triple is provided. 552252723Sdimstatic TargetMachine* GetTargetMachine(Triple TheTriple) { 553245431Sdim std::string Error; 554245431Sdim const Target *TheTarget = TargetRegistry::lookupTarget(MArch, TheTriple, 555245431Sdim Error); 556252723Sdim // Some modules don't specify a triple, and this is okay. 557245431Sdim if (!TheTarget) { 558245431Sdim return 0; 559245431Sdim } 560245431Sdim 561245431Sdim // Package up features to be passed to target/subtarget 562245431Sdim std::string FeaturesStr; 563245431Sdim if (MAttrs.size()) { 564245431Sdim SubtargetFeatures Features; 565245431Sdim for (unsigned i = 0; i != MAttrs.size(); ++i) 566245431Sdim Features.AddFeature(MAttrs[i]); 567245431Sdim FeaturesStr = Features.getString(); 568245431Sdim } 569245431Sdim 570245431Sdim return TheTarget->createTargetMachine(TheTriple.getTriple(), 571245431Sdim MCPU, FeaturesStr, GetTargetOptions(), 572245431Sdim RelocModel, CMModel, 573245431Sdim GetCodeGenOptLevel()); 574245431Sdim} 575245431Sdim 576193323Sed//===----------------------------------------------------------------------===// 577193323Sed// main for opt 578193323Sed// 579193323Sedint main(int argc, char **argv) { 580200581Srdivacky sys::PrintStackTraceOnErrorSignal(); 581200581Srdivacky llvm::PrettyStackTraceProgram X(argc, argv); 582212793Sdim 583202375Srdivacky // Enable debug stream buffering. 584202375Srdivacky EnableDebugBuffering = true; 585202375Srdivacky 586200581Srdivacky llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 587198090Srdivacky LLVMContext &Context = getGlobalContext(); 588221337Sdim 589245431Sdim InitializeAllTargets(); 590245431Sdim InitializeAllTargetMCs(); 591245431Sdim 592218885Sdim // Initialize passes 593218885Sdim PassRegistry &Registry = *PassRegistry::getPassRegistry(); 594218885Sdim initializeCore(Registry); 595263509Sdim initializeDebugIRPass(Registry); 596218885Sdim initializeScalarOpts(Registry); 597252723Sdim initializeObjCARCOpts(Registry); 598235633Sdim initializeVectorization(Registry); 599218885Sdim initializeIPO(Registry); 600218885Sdim initializeAnalysis(Registry); 601218885Sdim initializeIPA(Registry); 602218885Sdim initializeTransformUtils(Registry); 603218885Sdim initializeInstCombine(Registry); 604218885Sdim initializeInstrumentation(Registry); 605218885Sdim initializeTarget(Registry); 606221337Sdim 607198396Srdivacky cl::ParseCommandLineOptions(argc, argv, 608198396Srdivacky "llvm .bc -> .bc modular optimizer and analysis printer\n"); 609193323Sed 610218885Sdim if (AnalyzeOnly && NoOutput) { 611218885Sdim errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n"; 612218885Sdim return 1; 613218885Sdim } 614218885Sdim 615198396Srdivacky SMDiagnostic Err; 616193323Sed 617198396Srdivacky // Load the input module... 618252723Sdim OwningPtr<Module> M; 619198396Srdivacky M.reset(ParseIRFile(InputFilename, Err, Context)); 620198090Srdivacky 621198396Srdivacky if (M.get() == 0) { 622235633Sdim Err.print(argv[0], errs()); 623198396Srdivacky return 1; 624198396Srdivacky } 625193323Sed 626235633Sdim // If we are supposed to override the target triple, do so now. 627235633Sdim if (!TargetTriple.empty()) 628235633Sdim M->setTargetTriple(Triple::normalize(TargetTriple)); 629235633Sdim 630198396Srdivacky // Figure out what stream we are supposed to write to... 631212793Sdim OwningPtr<tool_output_file> Out; 632212793Sdim if (NoOutput) { 633212793Sdim if (!OutputFilename.empty()) 634212793Sdim errs() << "WARNING: The -o (output filename) option is ignored when\n" 635212793Sdim "the --disable-output option is used.\n"; 636212793Sdim } else { 637212793Sdim // Default to standard output. 638212793Sdim if (OutputFilename.empty()) 639212793Sdim OutputFilename = "-"; 640193323Sed 641212793Sdim std::string ErrorInfo; 642212793Sdim Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo, 643263509Sdim sys::fs::F_Binary)); 644212793Sdim if (!ErrorInfo.empty()) { 645212793Sdim errs() << ErrorInfo << '\n'; 646212793Sdim return 1; 647193323Sed } 648198396Srdivacky } 649193323Sed 650198396Srdivacky // If the output is set to be emitted to standard out, and standard out is a 651198396Srdivacky // console, print out a warning message and refuse to do it. We don't 652198396Srdivacky // impress anyone by spewing tons of binary goo to a terminal. 653202878Srdivacky if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly) 654212793Sdim if (CheckBitcodeOutputToConsole(Out->os(), !Quiet)) 655198396Srdivacky NoOutput = true; 656193323Sed 657198396Srdivacky // Create a PassManager to hold and optimize the collection of passes we are 658218885Sdim // about to build. 659198396Srdivacky // 660198396Srdivacky PassManager Passes; 661193323Sed 662218885Sdim // Add an appropriate TargetLibraryInfo pass for the module's triple. 663218885Sdim TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple())); 664221337Sdim 665218885Sdim // The -disable-simplify-libcalls flag actually disables all builtin optzns. 666218885Sdim if (DisableSimplifyLibCalls) 667218885Sdim TLI->disableAllFunctions(); 668218885Sdim Passes.add(TLI); 669221337Sdim 670245431Sdim // Add an appropriate DataLayout instance for this module. 671245431Sdim DataLayout *TD = 0; 672198396Srdivacky const std::string &ModuleDataLayout = M.get()->getDataLayout(); 673198396Srdivacky if (!ModuleDataLayout.empty()) 674245431Sdim TD = new DataLayout(ModuleDataLayout); 675198892Srdivacky else if (!DefaultDataLayout.empty()) 676245431Sdim TD = new DataLayout(DefaultDataLayout); 677193323Sed 678198396Srdivacky if (TD) 679198396Srdivacky Passes.add(TD); 680198090Srdivacky 681252723Sdim Triple ModuleTriple(M->getTargetTriple()); 682252723Sdim TargetMachine *Machine = 0; 683252723Sdim if (ModuleTriple.getArch()) 684252723Sdim Machine = GetTargetMachine(Triple(ModuleTriple)); 685252723Sdim OwningPtr<TargetMachine> TM(Machine); 686245431Sdim 687252723Sdim // Add internal analysis passes from the target machine. 688252723Sdim if (TM.get()) 689252723Sdim TM->addAnalysisPasses(Passes); 690252723Sdim 691223013Sdim OwningPtr<FunctionPassManager> FPasses; 692245431Sdim if (OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) { 693223013Sdim FPasses.reset(new FunctionPassManager(M.get())); 694198396Srdivacky if (TD) 695245431Sdim FPasses->add(new DataLayout(*TD)); 696263509Sdim if (TM.get()) 697263509Sdim TM->addAnalysisPasses(*FPasses); 698263509Sdim 699198396Srdivacky } 700193323Sed 701218885Sdim if (PrintBreakpoints) { 702218885Sdim // Default to standard output. 703218885Sdim if (!Out) { 704218885Sdim if (OutputFilename.empty()) 705218885Sdim OutputFilename = "-"; 706221337Sdim 707218885Sdim std::string ErrorInfo; 708218885Sdim Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo, 709263509Sdim sys::fs::F_Binary)); 710218885Sdim if (!ErrorInfo.empty()) { 711218885Sdim errs() << ErrorInfo << '\n'; 712218885Sdim return 1; 713218885Sdim } 714218885Sdim } 715218885Sdim Passes.add(new BreakpointPrinter(Out->os())); 716218885Sdim NoOutput = true; 717218885Sdim } 718218885Sdim 719198396Srdivacky // If the -strip-debug command line option was specified, add it. If 720198396Srdivacky // -std-compile-opts was also specified, it will handle StripDebug. 721198396Srdivacky if (StripDebug && !StandardCompileOpts) 722198396Srdivacky addPass(Passes, createStripSymbolsPass(true)); 723198090Srdivacky 724198396Srdivacky // Create a new optimization pass for each one specified on the command line 725198396Srdivacky for (unsigned i = 0; i < PassList.size(); ++i) { 726198396Srdivacky // Check to see if -std-compile-opts was specified before this option. If 727198396Srdivacky // so, handle it. 728198396Srdivacky if (StandardCompileOpts && 729198396Srdivacky StandardCompileOpts.getPosition() < PassList.getPosition(i)) { 730193323Sed AddStandardCompilePasses(Passes); 731193323Sed StandardCompileOpts = false; 732198090Srdivacky } 733193323Sed 734198396Srdivacky if (StandardLinkOpts && 735198396Srdivacky StandardLinkOpts.getPosition() < PassList.getPosition(i)) { 736198090Srdivacky AddStandardLinkPasses(Passes); 737198090Srdivacky StandardLinkOpts = false; 738198090Srdivacky } 739198090Srdivacky 740198396Srdivacky if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) { 741245431Sdim AddOptimizationPasses(Passes, *FPasses, 1, 0); 742198396Srdivacky OptLevelO1 = false; 743198090Srdivacky } 744193323Sed 745198396Srdivacky if (OptLevelO2 && OptLevelO2.getPosition() < PassList.getPosition(i)) { 746245431Sdim AddOptimizationPasses(Passes, *FPasses, 2, 0); 747198396Srdivacky OptLevelO2 = false; 748198090Srdivacky } 749193323Sed 750245431Sdim if (OptLevelOs && OptLevelOs.getPosition() < PassList.getPosition(i)) { 751245431Sdim AddOptimizationPasses(Passes, *FPasses, 2, 1); 752245431Sdim OptLevelOs = false; 753245431Sdim } 754245431Sdim 755245431Sdim if (OptLevelOz && OptLevelOz.getPosition() < PassList.getPosition(i)) { 756245431Sdim AddOptimizationPasses(Passes, *FPasses, 2, 2); 757245431Sdim OptLevelOz = false; 758245431Sdim } 759245431Sdim 760198396Srdivacky if (OptLevelO3 && OptLevelO3.getPosition() < PassList.getPosition(i)) { 761245431Sdim AddOptimizationPasses(Passes, *FPasses, 3, 0); 762198396Srdivacky OptLevelO3 = false; 763198090Srdivacky } 764193323Sed 765198396Srdivacky const PassInfo *PassInf = PassList[i]; 766198396Srdivacky Pass *P = 0; 767198396Srdivacky if (PassInf->getNormalCtor()) 768198396Srdivacky P = PassInf->getNormalCtor()(); 769198396Srdivacky else 770198396Srdivacky errs() << argv[0] << ": cannot create pass: " 771198396Srdivacky << PassInf->getPassName() << "\n"; 772198396Srdivacky if (P) { 773204642Srdivacky PassKind Kind = P->getPassKind(); 774198396Srdivacky addPass(Passes, P); 775193323Sed 776198396Srdivacky if (AnalyzeOnly) { 777204642Srdivacky switch (Kind) { 778202878Srdivacky case PT_BasicBlock: 779212793Sdim Passes.add(new BasicBlockPassPrinter(PassInf, Out->os())); 780202878Srdivacky break; 781218885Sdim case PT_Region: 782218885Sdim Passes.add(new RegionPassPrinter(PassInf, Out->os())); 783218885Sdim break; 784202878Srdivacky case PT_Loop: 785212793Sdim Passes.add(new LoopPassPrinter(PassInf, Out->os())); 786202878Srdivacky break; 787202878Srdivacky case PT_Function: 788212793Sdim Passes.add(new FunctionPassPrinter(PassInf, Out->os())); 789202878Srdivacky break; 790202878Srdivacky case PT_CallGraphSCC: 791212793Sdim Passes.add(new CallGraphSCCPassPrinter(PassInf, Out->os())); 792202878Srdivacky break; 793202878Srdivacky default: 794212793Sdim Passes.add(new ModulePassPrinter(PassInf, Out->os())); 795202878Srdivacky break; 796202878Srdivacky } 797198396Srdivacky } 798198090Srdivacky } 799193323Sed 800198396Srdivacky if (PrintEachXForm) 801198396Srdivacky Passes.add(createPrintModulePass(&errs())); 802198396Srdivacky } 803193323Sed 804198396Srdivacky // If -std-compile-opts was specified at the end of the pass list, add them. 805198396Srdivacky if (StandardCompileOpts) { 806198396Srdivacky AddStandardCompilePasses(Passes); 807198396Srdivacky StandardCompileOpts = false; 808198396Srdivacky } 809193323Sed 810198396Srdivacky if (StandardLinkOpts) { 811198396Srdivacky AddStandardLinkPasses(Passes); 812198396Srdivacky StandardLinkOpts = false; 813193323Sed } 814198396Srdivacky 815198396Srdivacky if (OptLevelO1) 816245431Sdim AddOptimizationPasses(Passes, *FPasses, 1, 0); 817198396Srdivacky 818198396Srdivacky if (OptLevelO2) 819245431Sdim AddOptimizationPasses(Passes, *FPasses, 2, 0); 820198396Srdivacky 821245431Sdim if (OptLevelOs) 822245431Sdim AddOptimizationPasses(Passes, *FPasses, 2, 1); 823245431Sdim 824245431Sdim if (OptLevelOz) 825245431Sdim AddOptimizationPasses(Passes, *FPasses, 2, 2); 826245431Sdim 827198396Srdivacky if (OptLevelO3) 828245431Sdim AddOptimizationPasses(Passes, *FPasses, 3, 0); 829198396Srdivacky 830245431Sdim if (OptLevelO1 || OptLevelO2 || OptLevelOs || OptLevelOz || OptLevelO3) { 831223013Sdim FPasses->doInitialization(); 832223013Sdim for (Module::iterator F = M->begin(), E = M->end(); F != E; ++F) 833223013Sdim FPasses->run(*F); 834223013Sdim FPasses->doFinalization(); 835223013Sdim } 836198396Srdivacky 837198396Srdivacky // Check that the module is well formed on completion of optimization 838198396Srdivacky if (!NoVerify && !VerifyEach) 839198396Srdivacky Passes.add(createVerifierPass()); 840198396Srdivacky 841212793Sdim // Write bitcode or assembly to the output as the last step... 842198396Srdivacky if (!NoOutput && !AnalyzeOnly) { 843198396Srdivacky if (OutputAssembly) 844212793Sdim Passes.add(createPrintModulePass(&Out->os())); 845198396Srdivacky else 846212793Sdim Passes.add(createBitcodeWriterPass(Out->os())); 847198396Srdivacky } 848198396Srdivacky 849221337Sdim // Before executing passes, print the final values of the LLVM options. 850221337Sdim cl::PrintOptionValues(); 851221337Sdim 852198396Srdivacky // Now that we have all of the passes ready, run them. 853198396Srdivacky Passes.run(*M.get()); 854198396Srdivacky 855212793Sdim // Declare success. 856218885Sdim if (!NoOutput || PrintBreakpoints) 857212793Sdim Out->keep(); 858212793Sdim 859198396Srdivacky return 0; 860193323Sed} 861