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