opt.cpp revision 195340 
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>
42using namespace llvm;
43
44// The OptimizationList is automatically populated with registered Passes by the
45// PassNameParser.
46//
47static cl::list<const PassInfo*, bool, PassNameParser>
48PassList(cl::desc("Optimizations available:"));
49
50// Other command line options...
51//
52static cl::opt<std::string>
53InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
54    cl::init("-"), cl::value_desc("filename"));
55
56static cl::opt<std::string>
57OutputFilename("o", cl::desc("Override output filename"),
58               cl::value_desc("filename"), cl::init("-"));
59
60static cl::opt<bool>
61Force("f", cl::desc("Overwrite output files"));
62
63static cl::opt<bool>
64PrintEachXForm("p", cl::desc("Print module after each transformation"));
65
66static cl::opt<bool>
67NoOutput("disable-output",
68         cl::desc("Do not write result bitcode file"), cl::Hidden);
69
70static cl::opt<bool>
71NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden);
72
73static cl::opt<bool>
74VerifyEach("verify-each", cl::desc("Verify after each transform"));
75
76static cl::opt<bool>
77StripDebug("strip-debug",
78           cl::desc("Strip debugger symbol info from translation unit"));
79
80static cl::opt<bool>
81DisableInline("disable-inlining", cl::desc("Do not run the inliner pass"));
82
83static cl::opt<bool>
84DisableOptimizations("disable-opt",
85                     cl::desc("Do not run any optimization passes"));
86
87static cl::opt<bool>
88StandardCompileOpts("std-compile-opts",
89                   cl::desc("Include the standard compile time optimizations"));
90
91static cl::opt<bool>
92OptLevelO1("O1",
93           cl::desc("Optimization level 1. Similar to llvm-gcc -O1"));
94
95static cl::opt<bool>
96OptLevelO2("O2",
97           cl::desc("Optimization level 2. Similar to llvm-gcc -O2"));
98
99static cl::opt<bool>
100OptLevelO3("O3",
101           cl::desc("Optimization level 3. Similar to llvm-gcc -O3"));
102
103static cl::opt<bool>
104UnitAtATime("funit-at-a-time",
105            cl::desc("Enable IPO. This is same as llvm-gcc's -funit-at-a-time"));
106
107static cl::opt<bool>
108DisableSimplifyLibCalls("disable-simplify-libcalls",
109                        cl::desc("Disable simplify-libcalls"));
110
111static cl::opt<bool>
112Quiet("q", cl::desc("Obsolete option"), cl::Hidden);
113
114static cl::alias
115QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
116
117static cl::opt<bool>
118AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
119
120// ---------- Define Printers for module and function passes ------------
121namespace {
122
123struct 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
151char CallGraphSCCPassPrinter::ID = 0;
152
153struct 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
177char ModulePassPrinter::ID = 0;
178struct 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
202char FunctionPassPrinter::ID = 0;
203
204struct 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
228char LoopPassPrinter::ID = 0;
229
230struct 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
255char BasicBlockPassPrinter::ID = 0;
256inline 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
269void 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
283void 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//
312int 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}
500