tools/opt/opt.cpp

   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/Module.h"
  17 #include "llvm/ModuleProvider.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/CallGraph.h"
  25 #include "llvm/Target/TargetData.h"
  26 #include "llvm/Target/TargetMachine.h"
  27 #include "llvm/Support/PassNameParser.h"
  28 #include "llvm/System/Signals.h"
  29 #include "llvm/Support/ManagedStatic.h"
  30 #include "llvm/Support/MemoryBuffer.h"
  31 #include "llvm/Support/PluginLoader.h"
  32 #include "llvm/Support/StandardPasses.h"
  33 #include "llvm/Support/Streams.h"
  34 #include "llvm/Support/SystemUtils.h"
  35 #include "llvm/Support/raw_ostream.h"
  36 #include "llvm/LinkAllPasses.h"
  37 #include "llvm/LinkAllVMCore.h"
  38 #include <iostream>
  39 #include <fstream>
  40 #include <memory>
  41 #include <algorithm>
  42 using namespace llvm;
  43
  44 // The OptimizationList is automatically populated with registered Passes by the
  45 // PassNameParser.
  46 //
  47 static cl::list<const PassInfo*, bool, PassNameParser>
  48 PassList(cl::desc("Optimizations available:"));
  49
  50 // Other command line options...
  51 //
  52 static cl::opt<std::string>
  53 InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
  54     cl::init("-"), cl::value_desc("filename"));
  55
  56 static cl::opt<std::string>
  57 OutputFilename("o", cl::desc("Override output filename"),
  58                cl::value_desc("filename"), cl::init("-"));
  59
  60 static cl::opt<bool>
  61 Force("f", cl::desc("Overwrite output files"));
  62
  63 static cl::opt<bool>
  64 PrintEachXForm("p", cl::desc("Print module after each transformation"));
  65
  66 static cl::opt<bool>
  67 NoOutput("disable-output",
  68          cl::desc("Do not write result bitcode file"), cl::Hidden);
  69
  70 static cl::opt<bool>
  71 NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden);
  72
  73 static cl::opt<bool>
  74 VerifyEach("verify-each", cl::desc("Verify after each transform"));
  75
  76 static cl::opt<bool>
  77 StripDebug("strip-debug",
  78            cl::desc("Strip debugger symbol info from translation unit"));
  79
  80 static cl::opt<bool>
  81 DisableInline("disable-inlining", cl::desc("Do not run the inliner pass"));
  82
  83 static cl::opt<bool>
  84 DisableOptimizations("disable-opt",
  85                      cl::desc("Do not run any optimization passes"));
  86
  87 static cl::opt<bool>
  88 StandardCompileOpts("std-compile-opts",
  89                    cl::desc("Include the standard compile time optimizations"));
  90
  91 static cl::opt<bool>
  92 OptLevelO1("O1",
  93            cl::desc("Optimization level 1. Similar to llvm-gcc -O1"));
  94
  95 static cl::opt<bool>
  96 OptLevelO2("O2",
  97            cl::desc("Optimization level 2. Similar to llvm-gcc -O2"));
  98
  99 static cl::opt<bool>
 100 OptLevelO3("O3",
 101            cl::desc("Optimization level 3. Similar to llvm-gcc -O3"));
 102
 103 static cl::opt<bool>
 104 UnitAtATime("funit-at-a-time",
 105             cl::desc("Enable IPO. This is same as llvm-gcc's -funit-at-a-time"));
 106
 107 static cl::opt<bool>
 108 DisableSimplifyLibCalls("disable-simplify-libcalls",
 109                         cl::desc("Disable simplify-libcalls"));
 110
 111 static cl::opt<bool>
 112 Quiet("q", cl::desc("Obsolete option"), cl::Hidden);
 113
 114 static cl::alias
 115 QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
 116
 117 static cl::opt<bool>
 118 AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
 119
 120 // ---------- Define Printers for module and function passes ------------
 121 namespace {
 122
 123 struct CallGraphSCCPassPrinter : public CallGraphSCCPass {
 124   static char ID;
 125   const PassInfo *PassToPrint;
 126   CallGraphSCCPassPrinter(const PassInfo *PI) :
 127     CallGraphSCCPass(&ID), PassToPrint(PI) {}
 128
 129   virtual bool runOnSCC(const std::vector<CallGraphNode *>&SCC) {
 130     if (!Quiet) {
 131       cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
 132
 133       for (unsigned i = 0, e = SCC.size(); i != e; ++i) {
 134         Function *F = SCC[i]->getFunction();
 135         if (F)
 136           getAnalysisID<Pass>(PassToPrint).print(cout, F->getParent());
 137       }
 138     }
 139     // Get and print pass...
 140     return false;
 141   }
 142
 143   virtual const char *getPassName() const { return "'Pass' Printer"; }
 144
 145   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 146     AU.addRequiredID(PassToPrint);
 147     AU.setPreservesAll();
 148   }
 149 };
 150
 151 char CallGraphSCCPassPrinter::ID = 0;
 152
 153 struct ModulePassPrinter : public ModulePass {
 154   static char ID;
 155   const PassInfo *PassToPrint;
 156   ModulePassPrinter(const PassInfo *PI) : ModulePass(&ID),
 157                                           PassToPrint(PI) {}
 158
 159   virtual bool runOnModule(Module &M) {
 160     if (!Quiet) {
 161       cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
 162       getAnalysisID<Pass>(PassToPrint).print(cout, &M);
 163     }
 164
 165     // Get and print pass...
 166     return false;
 167   }
 168
 169   virtual const char *getPassName() const { return "'Pass' Printer"; }
 170
 171   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 172     AU.addRequiredID(PassToPrint);
 173     AU.setPreservesAll();
 174   }
 175 };
 176
 177 char ModulePassPrinter::ID = 0;
 178 struct FunctionPassPrinter : public FunctionPass {
 179   const PassInfo *PassToPrint;
 180   static char ID;
 181   FunctionPassPrinter(const PassInfo *PI) : FunctionPass(&ID),
 182                                             PassToPrint(PI) {}
 183
 184   virtual bool runOnFunction(Function &F) {
 185     if (!Quiet) {
 186       cout << "Printing analysis '" << PassToPrint->getPassName()
 187            << "' for function '" << F.getName() << "':\n";
 188     }
 189     // Get and print pass...
 190     getAnalysisID<Pass>(PassToPrint).print(cout, F.getParent());
 191     return false;
 192   }
 193
 194   virtual const char *getPassName() const { return "FunctionPass Printer"; }
 195
 196   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 197     AU.addRequiredID(PassToPrint);
 198     AU.setPreservesAll();
 199   }
 200 };
 201
 202 char FunctionPassPrinter::ID = 0;
 203
 204 struct LoopPassPrinter : public LoopPass {
 205   static char ID;
 206   const PassInfo *PassToPrint;
 207   LoopPassPrinter(const PassInfo *PI) :
 208     LoopPass(&ID), PassToPrint(PI) {}
 209
 210   virtual bool runOnLoop(Loop *L, LPPassManager &LPM) {
 211     if (!Quiet) {
 212       cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
 213       getAnalysisID<Pass>(PassToPrint).print(cout,
 214                                   L->getHeader()->getParent()->getParent());
 215     }
 216     // Get and print pass...
 217     return false;
 218   }
 219
 220   virtual const char *getPassName() const { return "'Pass' Printer"; }
 221
 222   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 223     AU.addRequiredID(PassToPrint);
 224     AU.setPreservesAll();
 225   }
 226 };
 227
 228 char LoopPassPrinter::ID = 0;
 229
 230 struct BasicBlockPassPrinter : public BasicBlockPass {
 231   const PassInfo *PassToPrint;
 232   static char ID;
 233   BasicBlockPassPrinter(const PassInfo *PI)
 234     : BasicBlockPass(&ID), PassToPrint(PI) {}
 235
 236   virtual bool runOnBasicBlock(BasicBlock &BB) {
 237     if (!Quiet) {
 238       cout << "Printing Analysis info for BasicBlock '" << BB.getName()
 239            << "': Pass " << PassToPrint->getPassName() << ":\n";
 240     }
 241
 242     // Get and print pass...
 243     getAnalysisID<Pass>(PassToPrint).print(cout, BB.getParent()->getParent());
 244     return false;
 245   }
 246
 247   virtual const char *getPassName() const { return "BasicBlockPass Printer"; }
 248
 249   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
 250     AU.addRequiredID(PassToPrint);
 251     AU.setPreservesAll();
 252   }
 253 };
 254
 255 char BasicBlockPassPrinter::ID = 0;
 256 inline void addPass(PassManager &PM, Pass *P) {
 257   // Add the pass to the pass manager...
 258   PM.add(P);
 259
 260   // If we are verifying all of the intermediate steps, add the verifier...
 261   if (VerifyEach) PM.add(createVerifierPass());
 262 }
 263
 264 /// AddOptimizationPasses - This routine adds optimization passes
 265 /// based on selected optimization level, OptLevel. This routine
 266 /// duplicates llvm-gcc behaviour.
 267 ///
 268 /// OptLevel - Optimization Level
 269 void AddOptimizationPasses(PassManager &MPM, FunctionPassManager &FPM,
 270                            unsigned OptLevel) {
 271   createStandardFunctionPasses(&FPM, OptLevel);
 272
 273   llvm::Pass *InliningPass = OptLevel > 1 ? createFunctionInliningPass() : 0;
 274   createStandardModulePasses(&MPM, OptLevel,
 275                              /*OptimizeSize=*/ false,
 276                              UnitAtATime,
 277                              /*UnrollLoops=*/ OptLevel > 1,
 278                              !DisableSimplifyLibCalls,
 279                              /*HaveExceptions=*/ true,
 280                              InliningPass);
 281 }
 282
 283 void AddStandardCompilePasses(PassManager &PM) {
 284   PM.add(createVerifierPass());                  // Verify that input is correct
 285
 286   addPass(PM, createLowerSetJmpPass());          // Lower llvm.setjmp/.longjmp
 287
 288   // If the -strip-debug command line option was specified, do it.
 289   if (StripDebug)
 290     addPass(PM, createStripSymbolsPass(true));
 291
 292   if (DisableOptimizations) return;
 293
 294   llvm::Pass *InliningPass = !DisableInline ? createFunctionInliningPass() : 0;
 295
 296   // -std-compile-opts adds the same module passes as -O3.
 297   createStandardModulePasses(&PM, 3,
 298                              /*OptimizeSize=*/ false,
 299                              /*UnitAtATime=*/ true,
 300                              /*UnrollLoops=*/ true,
 301                              /*SimplifyLibCalls=*/ true,
 302                              /*HaveExceptions=*/ true,
 303                              InliningPass);
 304 }
 305
 306 } // anonymous namespace
 307
 308
 309 //===----------------------------------------------------------------------===//
 310 // main for opt
 311 //
 312 int main(int argc, char **argv) {
 313   llvm_shutdown_obj X;  // Call llvm_shutdown() on exit.
 314   LLVMContext Context;
 315   try {
 316     cl::ParseCommandLineOptions(argc, argv,
 317       "llvm .bc -> .bc modular optimizer and analysis printer\n");
 318     sys::PrintStackTraceOnErrorSignal();
 319
 320     // Allocate a full target machine description only if necessary.
 321     // FIXME: The choice of target should be controllable on the command line.
 322     std::auto_ptr<TargetMachine> target;
 323
 324     std::string ErrorMessage;
 325
 326     // Load the input module...
 327     std::auto_ptr<Module> M;
 328     if (MemoryBuffer *Buffer
 329           = MemoryBuffer::getFileOrSTDIN(InputFilename, &ErrorMessage)) {
 330       M.reset(ParseBitcodeFile(Buffer, &Context, &ErrorMessage));
 331       delete Buffer;
 332     }
 333
 334     if (M.get() == 0) {
 335       cerr << argv[0] << ": ";
 336       if (ErrorMessage.size())
 337         cerr << ErrorMessage << "\n";
 338       else
 339         cerr << "bitcode didn't read correctly.\n";
 340       return 1;
 341     }
 342
 343     // Figure out what stream we are supposed to write to...
 344     // FIXME: cout is not binary!
 345     std::ostream *Out = &std::cout;  // Default to printing to stdout...
 346     if (OutputFilename != "-") {
 347       if (!Force && std::ifstream(OutputFilename.c_str())) {
 348         // If force is not specified, make sure not to overwrite a file!
 349         cerr << argv[0] << ": error opening '" << OutputFilename
 350              << "': file exists!\n"
 351              << "Use -f command line argument to force output\n";
 352         return 1;
 353       }
 354       std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
 355                                    std::ios::binary;
 356       Out = new std::ofstream(OutputFilename.c_str(), io_mode);
 357
 358       if (!Out->good()) {
 359         cerr << argv[0] << ": error opening " << OutputFilename << "!\n";
 360         return 1;
 361       }
 362
 363       // Make sure that the Output file gets unlinked from the disk if we get a
 364       // SIGINT
 365       sys::RemoveFileOnSignal(sys::Path(OutputFilename));
 366     }
 367
 368     // If the output is set to be emitted to standard out, and standard out is a
 369     // console, print out a warning message and refuse to do it.  We don't
 370     // impress anyone by spewing tons of binary goo to a terminal.
 371     if (!Force && !NoOutput && CheckBitcodeOutputToConsole(Out,!Quiet)) {
 372       NoOutput = true;
 373     }
 374
 375     // Create a PassManager to hold and optimize the collection of passes we are
 376     // about to build...
 377     //
 378     PassManager Passes;
 379
 380     // Add an appropriate TargetData instance for this module...
 381     Passes.add(new TargetData(M.get()));
 382
 383     FunctionPassManager *FPasses = NULL;
 384     if (OptLevelO1 || OptLevelO2 || OptLevelO3) {
 385       FPasses = new FunctionPassManager(new ExistingModuleProvider(M.get()));
 386       FPasses->add(new TargetData(M.get()));
 387     }
 388
 389     // If the -strip-debug command line option was specified, add it.  If
 390     // -std-compile-opts was also specified, it will handle StripDebug.
 391     if (StripDebug && !StandardCompileOpts)
 392       addPass(Passes, createStripSymbolsPass(true));
 393
 394     // Create a new optimization pass for each one specified on the command line
 395     for (unsigned i = 0; i < PassList.size(); ++i) {
 396       // Check to see if -std-compile-opts was specified before this option.  If
 397       // so, handle it.
 398       if (StandardCompileOpts &&
 399           StandardCompileOpts.getPosition() < PassList.getPosition(i)) {
 400         AddStandardCompilePasses(Passes);
 401         StandardCompileOpts = false;
 402       }
 403
 404       if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) {
 405         AddOptimizationPasses(Passes, *FPasses, 1);
 406         OptLevelO1 = false;
 407       }
 408
 409       if (OptLevelO2 && OptLevelO2.getPosition() < PassList.getPosition(i)) {
 410         AddOptimizationPasses(Passes, *FPasses, 2);
 411         OptLevelO2 = false;
 412       }
 413
 414       if (OptLevelO3 && OptLevelO3.getPosition() < PassList.getPosition(i)) {
 415         AddOptimizationPasses(Passes, *FPasses, 3);
 416         OptLevelO3 = false;
 417       }
 418
 419       const PassInfo *PassInf = PassList[i];
 420       Pass *P = 0;
 421       if (PassInf->getNormalCtor())
 422         P = PassInf->getNormalCtor()();
 423       else
 424         cerr << argv[0] << ": cannot create pass: "
 425              << PassInf->getPassName() << "\n";
 426       if (P) {
 427         bool isBBPass = dynamic_cast<BasicBlockPass*>(P) != 0;
 428         bool isLPass = !isBBPass && dynamic_cast<LoopPass*>(P) != 0;
 429         bool isFPass = !isLPass && dynamic_cast<FunctionPass*>(P) != 0;
 430         bool isCGSCCPass = !isFPass && dynamic_cast<CallGraphSCCPass*>(P) != 0;
 431
 432         addPass(Passes, P);
 433
 434         if (AnalyzeOnly) {
 435           if (isBBPass)
 436             Passes.add(new BasicBlockPassPrinter(PassInf));
 437           else if (isLPass)
 438             Passes.add(new LoopPassPrinter(PassInf));
 439           else if (isFPass)
 440             Passes.add(new FunctionPassPrinter(PassInf));
 441           else if (isCGSCCPass)
 442             Passes.add(new CallGraphSCCPassPrinter(PassInf));
 443           else
 444             Passes.add(new ModulePassPrinter(PassInf));
 445         }
 446       }
 447
 448       if (PrintEachXForm)
 449         Passes.add(createPrintModulePass(&errs()));
 450     }
 451
 452     // If -std-compile-opts was specified at the end of the pass list, add them.
 453     if (StandardCompileOpts) {
 454       AddStandardCompilePasses(Passes);
 455       StandardCompileOpts = false;
 456     }
 457
 458     if (OptLevelO1) {
 459         AddOptimizationPasses(Passes, *FPasses, 1);
 460       }
 461
 462     if (OptLevelO2) {
 463         AddOptimizationPasses(Passes, *FPasses, 2);
 464       }
 465
 466     if (OptLevelO3) {
 467         AddOptimizationPasses(Passes, *FPasses, 3);
 468       }
 469
 470     if (OptLevelO1 || OptLevelO2 || OptLevelO3) {
 471       for (Module::iterator I = M.get()->begin(), E = M.get()->end();
 472            I != E; ++I)
 473         FPasses->run(*I);
 474     }
 475
 476     // Check that the module is well formed on completion of optimization
 477     if (!NoVerify && !VerifyEach)
 478       Passes.add(createVerifierPass());
 479
 480     // Write bitcode out to disk or cout as the last step...
 481     if (!NoOutput && !AnalyzeOnly)
 482       Passes.add(CreateBitcodeWriterPass(*Out));
 483
 484     // Now that we have all of the passes ready, run them.
 485     Passes.run(*M.get());
 486
 487     // Delete the ofstream.
 488     if (Out != &std::cout)
 489       delete Out;
 490     return 0;
 491
 492   } catch (const std::string& msg) {
 493     cerr << argv[0] << ": " << msg << "\n";
 494   } catch (...) {
 495     cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
 496   }
 497   llvm_shutdown();
 498   return 1;
 499 }