tools/analyze/analyze.cpp

   1 //===----------------------------------------------------------------------===//
   2 // The LLVM analyze utility
   3 //
   4 // This utility is designed to print out the results of running various analysis
   5 // passes on a program.  This is useful for understanding a program, or for
   6 // debugging an analysis pass.
   7 //
   8 //  analyze --help           - Output information about command line switches
   9 //  analyze --quiet          - Do not print analysis name before output
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Module.h"
  14 #include "llvm/PassManager.h"
  15 #include "llvm/Bytecode/Reader.h"
  16 #include "llvm/Assembly/Parser.h"
  17 #include "llvm/Support/PassNameParser.h"
  18 #include <algorithm>
  19
  20
  21 struct ModulePassPrinter : public Pass {
  22   const PassInfo *PassToPrint;
  23   ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
  24
  25   virtual bool run(Module &M) {
  26     std::cout << "Printing Analysis info for Pass "
  27               << PassToPrint->getPassName() << ":\n";
  28     getAnalysis<Pass>(PassToPrint).print(std::cout, &M);
  29
  30     // Get and print pass...
  31     return false;
  32   }
  33
  34   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  35     AU.addRequired(PassToPrint);
  36     AU.setPreservesAll();
  37   }
  38 };
  39
  40 struct FunctionPassPrinter : public FunctionPass {
  41   const PassInfo *PassToPrint;
  42   FunctionPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
  43
  44   virtual bool runOnFunction(Function &F) {
  45     std::cout << "Printing Analysis info for function '" << F.getName()
  46               << "': Pass " << PassToPrint->getPassName() << ":\n";
  47     getAnalysis<Pass>(PassToPrint).print(std::cout, F.getParent());
  48
  49     // Get and print pass...
  50     return false;
  51   }
  52
  53   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  54     AU.addRequired(PassToPrint);
  55     AU.setPreservesAll();
  56   }
  57 };
  58
  59 struct BasicBlockPassPrinter : public BasicBlockPass {
  60   const PassInfo *PassToPrint;
  61   BasicBlockPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
  62
  63   virtual bool runOnBasicBlock(BasicBlock &BB) {
  64     std::cout << "Printing Analysis info for BasicBlock '" << BB.getName()
  65               << "': Pass " << PassToPrint->getPassName() << ":\n";
  66     getAnalysis<Pass>(PassToPrint).print(std::cout, BB.getParent()->getParent());
  67
  68     // Get and print pass...
  69     return false;
  70   }
  71
  72   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
  73     AU.addRequired(PassToPrint);
  74     AU.setPreservesAll();
  75   }
  76 };
  77
  78
  79
  80
  81 static cl::opt<std::string>
  82 InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"),
  83               cl::value_desc("filename"));
  84
  85 static cl::opt<bool> Quiet("q", cl::desc("Don't print analysis pass names"));
  86 static cl::alias    QuietA("quiet", cl::desc("Alias for -q"),
  87                            cl::aliasopt(Quiet));
  88
  89 // The AnalysesList is automatically populated with registered Passes by the
  90 // PassNameParser.
  91 //
  92 static cl::list<const PassInfo*, bool,
  93                 FilteredPassNameParser<PassInfo::Analysis> >
  94 AnalysesList(cl::desc("Analyses available:"));
  95
  96
  97 int main(int argc, char **argv) {
  98   cl::ParseCommandLineOptions(argc, argv, " llvm analysis printer tool\n");
  99
 100   Module *CurMod = 0;
 101   try {
 102     CurMod = ParseBytecodeFile(InputFilename);
 103     if (!CurMod && !(CurMod = ParseAssemblyFile(InputFilename))){
 104       std::cerr << argv[0] << ": input file didn't read correctly.\n";
 105       return 1;
 106     }
 107   } catch (const ParseException &E) {
 108     std::cerr << argv[0] << ": " << E.getMessage() << "\n";
 109     return 1;
 110   }
 111
 112   // Create a PassManager to hold and optimize the collection of passes we are
 113   // about to build...
 114   //
 115   PassManager Passes;
 116
 117   // Create a new optimization pass for each one specified on the command line
 118   for (unsigned i = 0; i < AnalysesList.size(); ++i) {
 119     const PassInfo *Analysis = AnalysesList[i];
 120
 121     if (Analysis->getNormalCtor()) {
 122       Pass *P = Analysis->getNormalCtor()();
 123       Passes.add(P);
 124
 125       if (BasicBlockPass *BBP = dynamic_cast<BasicBlockPass*>(P))
 126         Passes.add(new BasicBlockPassPrinter(Analysis));
 127       else if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P))
 128         Passes.add(new FunctionPassPrinter(Analysis));
 129       else
 130         Passes.add(new ModulePassPrinter(Analysis));
 131
 132     } else
 133       cerr << argv[0] << ": cannot create pass: "
 134            << Analysis->getPassName() << "\n";
 135   }
 136
 137   Passes.run(*CurMod);
 138
 139   delete CurMod;
 140   return 0;
 141 }