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