Make sure to create a target data that matches the Module's target properties.
[oota-llvm.git] / tools / analyze / analyze.cpp
index 9513e5ebe2d791adc37310f9026d0fe053fb2175..1119fccfa3340cc98f03005a818b7b1bcd41d6b7 100644 (file)
@@ -1,5 +1,5 @@
 //===----------------------------------------------------------------------===//
-// LLVM 'Analyze' UTILITY 
+// The LLVM analyze utility
 //
 // This utility is designed to print out the results of running various analysis
 // passes on a program.  This is useful for understanding a program, or for 
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Instruction.h"
 #include "llvm/Module.h"
-#include "llvm/Method.h"
-#include "llvm/iPHINode.h"
 #include "llvm/PassManager.h"
 #include "llvm/Bytecode/Reader.h"
 #include "llvm/Assembly/Parser.h"
-#include "llvm/Assembly/PrintModulePass.h"
-#include "llvm/Analysis/Writer.h"
-#include "llvm/Analysis/InstForest.h"
-#include "llvm/Analysis/Dominators.h"
-#include "llvm/Analysis/IntervalPartition.h"
-#include "llvm/Analysis/Expressions.h"
-#include "llvm/Analysis/InductionVariable.h"
-#include "llvm/Analysis/CallGraph.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/FindUnsafePointerTypes.h"
-#include "llvm/Analysis/FindUsedTypes.h"
-#include "llvm/Support/InstIterator.h"
-#include "Support/CommandLine.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Support/PassNameParser.h"
+#include "Support/Timer.h"
 #include <algorithm>
-#include <iostream>
 
-using std::cout;
-using std::ostream;
-using std::string;
 
-static Module *CurrentModule;
+struct ModulePassPrinter : public Pass {
+  const PassInfo *PassToPrint;
+  ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
 
-static void operator<<(ostream &O, const FindUsedTypes &FUT) {
-  FUT.printTypes(cout, CurrentModule);
-}
-
-static void operator<<(ostream &O, const FindUnsafePointerTypes &FUPT) {
-  FUPT.printResults(CurrentModule, cout);
-}
-
-
-
-template <class PassType, class PassName>
-class PassPrinter;  // Do not implement
-
-template <class PassName>
-class PassPrinter<Pass, PassName> : public Pass {
-  const string Message;
-  const AnalysisID ID;
-public:
-  PassPrinter(const string &M, AnalysisID id) : Message(M), ID(id) {}
-  
-  virtual bool run(Module *M) {
-    cout << Message << "\n" << getAnalysis<PassName>(ID);
+  virtual bool run(Module &M) {
+    std::cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
+    getAnalysisID<Pass>(PassToPrint).print(std::cout, &M);
+    
+    // Get and print pass...
     return false;
   }
-
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
-    Required.push_back(ID);
-  }
-};
-
-template <class PassName>
-class PassPrinter<MethodPass, PassName> : public MethodPass {
-  const string Message;
-  const AnalysisID ID;
-public:
-  PassPrinter(const string &M, AnalysisID id) : Message(M), ID(id) {}
   
-  virtual bool runOnMethod(Method *M) {
-    cout << Message << " on method '" << M->getName() << "'\n"
-         << getAnalysis<PassName>(ID);
-    return false;
-  }
+  virtual const char *getPassName() const { return "'Pass' Printer"; }
 
-  virtual void getAnalysisUsageInfo(Pass::AnalysisSet &Required,
-                                    Pass::AnalysisSet &Destroyed,
-                                    Pass::AnalysisSet &Provided) {
-    Required.push_back(ID);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addRequiredID(PassToPrint);
+    AU.setPreservesAll();
   }
 };
 
+struct FunctionPassPrinter : public FunctionPass {
+  const PassInfo *PassToPrint;
+  FunctionPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
 
+  virtual bool runOnFunction(Function &F) {
+    std::cout << "Printing analysis '" << PassToPrint->getPassName()
+              << "' for function '" << F.getName() << "':\n";
+    getAnalysisID<Pass>(PassToPrint).print(std::cout, F.getParent());
 
-template <class PassType, class PassName, AnalysisID &ID>
-Pass *New(const string &Message) {
-  return new PassPrinter<PassType, PassName>(Message, ID);
-}
-template <class PassType, class PassName>
-Pass *New(const string &Message) {
-  return new PassPrinter<PassType, PassName>(Message, PassName::ID);
-}
-
+    // Get and print pass...
+    return false;
+  }
 
+  virtual const char *getPassName() const { return "FunctionPass Printer"; }
 
-Pass *NewPrintMethod(const string &Message) {
-  return new PrintMethodPass(Message, &std::cout);
-}
-Pass *NewPrintModule(const string &Message) {
-  return new PrintModulePass(&std::cout);
-}
-
-struct InstForest : public MethodPass {
-  void doit(Method *M) {
-    cout << analysis::InstForest<char>(M);
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addRequiredID(PassToPrint);
+    AU.setPreservesAll();
   }
 };
 
-struct IndVars : public MethodPass {
-  void doit(Method *M) {
-    cfg::LoopInfo &LI = getAnalysis<cfg::LoopInfo>();
-    for (inst_iterator I = inst_begin(M), E = inst_end(M); I != E; ++I)
-      if (PHINode *PN = dyn_cast<PHINode>(*I)) {
-        InductionVariable IV(PN, &LI);
-        if (IV.InductionType != InductionVariable::Unknown)
-          cout << IV;
-      }
-  }
+struct BasicBlockPassPrinter : public BasicBlockPass {
+  const PassInfo *PassToPrint;
+  BasicBlockPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
 
-  void getAnalysisUsageInfo(Pass::AnalysisSet &Req,
-                            Pass::AnalysisSet &, Pass::AnalysisSet &) {
-    Req.push_back(cfg::LoopInfo::ID);
-  }
-};
+  virtual bool runOnBasicBlock(BasicBlock &BB) {
+    std::cout << "Printing Analysis info for BasicBlock '" << BB.getName()
+              << "': Pass " << PassToPrint->getPassName() << ":\n";
+    getAnalysisID<Pass>(PassToPrint).print(std::cout, BB.getParent()->getParent());
 
-struct Exprs : public MethodPass {
-  static void doit(Method *M) {
-    cout << "Classified expressions for: " << M->getName() << "\n";
-    for (inst_iterator I = inst_begin(M), E = inst_end(M); I != E; ++I) {
-      cout << *I;
-      
-      if ((*I)->getType() == Type::VoidTy) continue;
-      analysis::ExprType R = analysis::ClassifyExpression(*I);
-      if (R.Var == *I) continue;  // Doesn't tell us anything
-      
-      cout << "\t\tExpr =";
-      switch (R.ExprTy) {
-      case analysis::ExprType::ScaledLinear:
-        WriteAsOperand(cout << "(", (Value*)R.Scale) << " ) *";
-        // fall through
-      case analysis::ExprType::Linear:
-        WriteAsOperand(cout << "(", R.Var) << " )";
-        if (R.Offset == 0) break;
-        else cout << " +";
-        // fall through
-      case analysis::ExprType::Constant:
-        if (R.Offset) WriteAsOperand(cout, (Value*)R.Offset); else cout << " 0";
-        break;
-      }
-      cout << "\n\n";
-    }
+    // Get and print pass...
+    return false;
   }
-};
 
+  virtual const char *getPassName() const { return "BasicBlockPass Printer"; }
 
-template<class TraitClass>
-class PrinterPass : public TraitClass {
-  const string Message;
-public:
-  PrinterPass(const string &M) : Message(M) {}
-  
-  virtual bool runOnMethod(Method *M) {
-    cout << Message << " on method '" << M->getName() << "'\n";
-
-    TraitClass::doit(M);
-    return false;
+  virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+    AU.addRequiredID(PassToPrint);
+    AU.setPreservesAll();
   }
 };
 
 
-template<class PassClass>
-Pass *Create(const string &Message) {
-  return new PassClass(Message);
-}
 
 
+static cl::opt<std::string>
+InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"),
+              cl::value_desc("filename"));
 
-enum Ans {
-  // global analyses
-  print, intervals, exprs, instforest, loops, indvars,
+static cl::opt<bool> Quiet("q", cl::desc("Don't print analysis pass names"));
+static cl::alias    QuietA("quiet", cl::desc("Alias for -q"),
+                           cl::aliasopt(Quiet));
 
-  // ip analyses
-  printmodule, callgraph, printusedtypes, unsafepointertypes,
+// The AnalysesList is automatically populated with registered Passes by the
+// PassNameParser.
+//
+static cl::list<const PassInfo*, bool,
+                FilteredPassNameParser<PassInfo::Analysis> >
+AnalysesList(cl::desc("Analyses available:"));
 
-  domset, idom, domtree, domfrontier,
-  postdomset, postidom, postdomtree, postdomfrontier,
-};
 
-cl::String InputFilename ("", "Load <arg> file to analyze", cl::NoFlags, "-");
-cl::Flag   Quiet         ("q", "Don't print analysis pass names");
-cl::Alias  QuietA        ("quiet", "Alias for -q", cl::NoFlags, Quiet);
-cl::EnumList<enum Ans> AnalysesList(cl::NoFlags,
-  clEnumVal(print          , "Print each method"),
-  clEnumVal(intervals      , "Print Interval Partitions"),
-  clEnumVal(exprs          , "Classify Expressions"),
-  clEnumVal(instforest     , "Print Instruction Forest"),
-  clEnumVal(loops          , "Print Loops"),
-  clEnumVal(indvars        , "Print Induction Variables"),
-
-  clEnumVal(printmodule    , "Print entire module"),
-  clEnumVal(callgraph      , "Print Call Graph"),
-  clEnumVal(printusedtypes , "Print Types Used by Module"),
-  clEnumVal(unsafepointertypes, "Print Unsafe Pointer Types"),
-
-  clEnumVal(domset         , "Print Dominator Sets"),
-  clEnumVal(idom           , "Print Immediate Dominators"),
-  clEnumVal(domtree        , "Print Dominator Tree"),
-  clEnumVal(domfrontier    , "Print Dominance Frontier"),
-
-  clEnumVal(postdomset     , "Print Postdominator Sets"),
-  clEnumVal(postidom       , "Print Immediate Postdominators"),
-  clEnumVal(postdomtree    , "Print Post Dominator Tree"),
-  clEnumVal(postdomfrontier, "Print Postdominance Frontier"),
-0);
-
-
-struct {
-  enum Ans AnID;
-  Pass *(*PassConstructor)(const string &Message);
-} AnTable[] = {
-  // Global analyses
-  { print             , NewPrintMethod                          },
-  { intervals         , New<MethodPass, cfg::IntervalPartition> },
-  { loops             , New<MethodPass, cfg::LoopInfo>          },
-  { instforest        , Create<PrinterPass<InstForest> >        },
-  { indvars           , Create<PrinterPass<IndVars> >           },
-  { exprs             , Create<PrinterPass<Exprs> >             },
-
-  // IP Analyses...
-  { printmodule       , NewPrintModule                    },
-  { printusedtypes    , New<Pass, FindUsedTypes>          },
-  { callgraph         , New<Pass, cfg::CallGraph>         },
-  { unsafepointertypes, New<Pass, FindUnsafePointerTypes> },
-
-  // Dominator analyses
-  { domset            , New<MethodPass, cfg::DominatorSet>        },
-  { idom              , New<MethodPass, cfg::ImmediateDominators> },
-  { domtree           , New<MethodPass, cfg::DominatorTree>       },
-  { domfrontier       , New<MethodPass, cfg::DominanceFrontier>   },
-
-  { postdomset        , New<MethodPass, cfg::DominatorSet, cfg::DominatorSet::PostDomID> },
-  { postidom          , New<MethodPass, cfg::ImmediateDominators, cfg::ImmediateDominators::PostDomID> },
-  { postdomtree       , New<MethodPass, cfg::DominatorTree, cfg::DominatorTree::PostDomID> },
-  { postdomfrontier   , New<MethodPass, cfg::DominanceFrontier, cfg::DominanceFrontier::PostDomID> },
-};
+static Timer BytecodeLoadTimer("Bytecode Loader");
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, " llvm analysis printer tool\n");
 
+  Module *CurMod = 0;
   try {
-    CurrentModule = ParseBytecodeFile(InputFilename);
-    if (!CurrentModule && !(CurrentModule = ParseAssemblyFile(InputFilename))){
-      std::cerr << "Input file didn't read correctly.\n";
+#if 0
+    TimeRegion RegionTimer(BytecodeLoadTimer);
+#endif
+    CurMod = ParseBytecodeFile(InputFilename);
+    if (!CurMod && !(CurMod = ParseAssemblyFile(InputFilename))){
+      std::cerr << argv[0] << ": input file didn't read correctly.\n";
       return 1;
     }
   } catch (const ParseException &E) {
-    std::cerr << E.getMessage() << "\n";
+    std::cerr << argv[0] << ": " << E.getMessage() << "\n";
     return 1;
   }
 
   // Create a PassManager to hold and optimize the collection of passes we are
   // about to build...
   //
-  PassManager Analyses;
+  PassManager Passes;
 
-  // Loop over all of the analyses looking for analyses to run...
+  // Add an appropriate TargetData instance for this module...
+  Passes.add(new TargetData("analyze", CurMod));
+
+  // Make sure the input LLVM is well formed.
+  Passes.add(createVerifierPass());
+
+  // Create a new optimization pass for each one specified on the command line
   for (unsigned i = 0; i < AnalysesList.size(); ++i) {
-    enum Ans AnalysisPass = AnalysesList[i];
-
-    for (unsigned j = 0; j < sizeof(AnTable)/sizeof(AnTable[0]); ++j) {
-      if (AnTable[j].AnID == AnalysisPass) {
-        string Message;
-        if (!Quiet)
-          Message = "\nRunning: '" + 
-            string(AnalysesList.getArgDescription(AnalysisPass)) + "' analysis";
-        Analyses.add(AnTable[j].PassConstructor(Message));
-        break;                       // get an error later
-      }
-    }
-  }  
+    const PassInfo *Analysis = AnalysesList[i];
+    
+    if (Analysis->getNormalCtor()) {
+      Pass *P = Analysis->getNormalCtor()();
+      Passes.add(P);
+
+      if (BasicBlockPass *BBP = dynamic_cast<BasicBlockPass*>(P))
+        Passes.add(new BasicBlockPassPrinter(Analysis));
+      else if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P))
+        Passes.add(new FunctionPassPrinter(Analysis));
+      else
+        Passes.add(new ModulePassPrinter(Analysis));
+
+    } else
+      std::cerr << argv[0] << ": cannot create pass: "
+                << Analysis->getPassName() << "\n";
+  }
 
-  Analyses.run(CurrentModule);
+  Passes.run(*CurMod);
 
-  delete CurrentModule;
+  delete CurMod;
   return 0;
 }