tools/analyze/analyze.cpp

   1 //===- analyze.cpp - The LLVM analyze utility -----------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This utility is designed to print out the results of running various analysis
  11 // passes on a program.  This is useful for understanding a program, or for
  12 // debugging an analysis pass.
  13 //
  14 //  analyze --help           - Output information about command line switches
  15 //  analyze --quiet          - Do not print analysis name before output
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "llvm/Module.h"
  20 #include "llvm/PassManager.h"
  21 #include "llvm/Bytecode/Reader.h"
  22 #include "llvm/Assembly/Parser.h"
  23 #include "llvm/Analysis/Verifier.h"
  24 #include "llvm/Target/TargetData.h"
  25 #include "llvm/Support/PassNameParser.h"
  26 #include "llvm/System/Signals.h"
  27 #include "Support/PluginLoader.h"
  28 #include "Support/Timer.h"
  29 #include <algorithm>
  30
  31 using namespace llvm;
  32
  33 struct ModulePassPrinter : public Pass {
  34   const PassInfo *PassToPrint;
  35   ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
  36
  37   virtual bool run(Module &M) {
  38     std::cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
  39     getAnalysisID<Pass>(PassToPrint).print(std::cout, &M);
  40
  41     // Get and print pass...
  42     return false;
  43   }
  44
  45   virtual const char *getPassName() const { return "'Pass' Printer"; }
  46
  47   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  48     AU.addRequiredID(PassToPrint);
  49     AU.setPreservesAll();
  50   }
  51 };
  52
  53 struct FunctionPassPrinter : public FunctionPass {
  54   const PassInfo *PassToPrint;
  55   FunctionPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
  56
  57   virtual bool runOnFunction(Function &F) {
  58     std::cout << "Printing analysis '" << PassToPrint->getPassName()
  59               << "' for function '" << F.getName() << "':\n";
  60     getAnalysisID<Pass>(PassToPrint).print(std::cout, F.getParent());
  61
  62     // Get and print pass...
  63     return false;
  64   }
  65
  66   virtual const char *getPassName() const { return "FunctionPass Printer"; }
  67
  68   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  69     AU.addRequiredID(PassToPrint);
  70     AU.setPreservesAll();
  71   }
  72 };
  73
  74 struct BasicBlockPassPrinter : public BasicBlockPass {
  75   const PassInfo *PassToPrint;
  76   BasicBlockPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
  77
  78   virtual bool runOnBasicBlock(BasicBlock &BB) {
  79     std::cout << "Printing Analysis info for BasicBlock '" << BB.getName()
  80               << "': Pass " << PassToPrint->getPassName() << ":\n";
  81     getAnalysisID<Pass>(PassToPrint).print(std::cout, BB.getParent()->getParent());
  82
  83     // Get and print pass...
  84     return false;
  85   }
  86
  87   virtual const char *getPassName() const { return "BasicBlockPass Printer"; }
  88
  89   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  90     AU.addRequiredID(PassToPrint);
  91     AU.setPreservesAll();
  92   }
  93 };
  94
  95
  96
  97 namespace {
  98   cl::opt<std::string>
  99   InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"),
 100                 cl::value_desc("filename"));
 101
 102   cl::opt<bool> Quiet("q", cl::desc("Don't print analysis pass names"));
 103   cl::alias    QuietA("quiet", cl::desc("Alias for -q"),
 104                       cl::aliasopt(Quiet));
 105
 106   cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
 107                          cl::desc("Do not verify input module"));
 108
 109   // The AnalysesList is automatically populated with registered Passes by the
 110   // PassNameParser.
 111   //
 112   cl::list<const PassInfo*, bool, FilteredPassNameParser<PassInfo::Analysis> >
 113   AnalysesList(cl::desc("Analyses available:"));
 114
 115   Timer BytecodeLoadTimer("Bytecode Loader");
 116 }
 117
 118 int main(int argc, char **argv) {
 119   cl::ParseCommandLineOptions(argc, argv, " llvm analysis printer tool\n");
 120   sys::PrintStackTraceOnErrorSignal();
 121
 122   Module *CurMod = 0;
 123   try {
 124 #if 0
 125     TimeRegion RegionTimer(BytecodeLoadTimer);
 126 #endif
 127     CurMod = ParseBytecodeFile(InputFilename);
 128     if (!CurMod && !(CurMod = ParseAssemblyFile(InputFilename))){
 129       std::cerr << argv[0] << ": input file didn't read correctly.\n";
 130       return 1;
 131     }
 132   } catch (const ParseException &E) {
 133     std::cerr << argv[0] << ": " << E.getMessage() << "\n";
 134     return 1;
 135   }
 136
 137   // Create a PassManager to hold and optimize the collection of passes we are
 138   // about to build...
 139   //
 140   PassManager Passes;
 141
 142   // Add an appropriate TargetData instance for this module...
 143   Passes.add(new TargetData("analyze", CurMod));
 144
 145   // Make sure the input LLVM is well formed.
 146   if (!NoVerify)
 147     Passes.add(createVerifierPass());
 148
 149   // Create a new optimization pass for each one specified on the command line
 150   for (unsigned i = 0; i < AnalysesList.size(); ++i) {
 151     const PassInfo *Analysis = AnalysesList[i];
 152
 153     if (Analysis->getNormalCtor()) {
 154       Pass *P = Analysis->getNormalCtor()();
 155       Passes.add(P);
 156
 157       if (BasicBlockPass *BBP = dynamic_cast<BasicBlockPass*>(P))
 158         Passes.add(new BasicBlockPassPrinter(Analysis));
 159       else if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P))
 160         Passes.add(new FunctionPassPrinter(Analysis));
 161       else
 162         Passes.add(new ModulePassPrinter(Analysis));
 163
 164     } else
 165       std::cerr << argv[0] << ": cannot create pass: "
 166                 << Analysis->getPassName() << "\n";
 167   }
 168
 169   Passes.run(*CurMod);
 170
 171   delete CurMod;
 172   return 0;
 173 }