-//===------------------------------------------------------------------------===
-// LLVM 'Analyze' UTILITY
+//===- analyze.cpp - The LLVM analyze utility -----------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// 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
// analyze --help - Output information about command line switches
// analyze --quiet - Do not print analysis name before output
//
-//===------------------------------------------------------------------------===
+//===----------------------------------------------------------------------===//
-#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/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 "Support/CommandLine.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/Target/TargetData.h"
+#include "llvm/Support/PassNameParser.h"
+#include "llvm/System/Signals.h"
+#include "llvm/Support/PluginLoader.h"
+#include "llvm/Support/Timer.h"
#include <algorithm>
-static void PrintMethod(Method *M) {
- cout << M;
-}
+using namespace llvm;
-static void PrintIntervalPartition(Method *M) {
- cout << cfg::IntervalPartition(M);
-}
+struct ModulePassPrinter : public Pass {
+ const PassInfo *PassToPrint;
+ ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
-static void PrintClassifiedExprs(Method *M) {
- cout << "Classified expressions for: " << M->getName() << endl;
- Method::inst_iterator I = M->inst_begin(), E = M->inst_end();
- for (; 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 << endl << endl;
+ 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 const char *getPassName() const { return "'Pass' Printer"; }
-static void PrintInductionVariables(Method *M) {
- cfg::LoopInfo LI(M);
- for (Method::inst_iterator I = M->inst_begin(), E = M->inst_end();
- I != E; ++I)
- if (PHINode *PN = dyn_cast<PHINode>(*I)) {
- InductionVariable IV(PN, &LI);
- if (IV.InductionType != InductionVariable::Unknown)
- cout << IV;
- }
-}
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequiredID(PassToPrint);
+ AU.setPreservesAll();
+ }
+};
+struct FunctionPassPrinter : public FunctionPass {
+ const PassInfo *PassToPrint;
+ FunctionPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
-static void PrintInstForest(Method *M) {
- cout << analysis::InstForest<char>(M);
-}
-static void PrintLoops(Method *M) {
- cout << cfg::LoopInfo(M);
-}
-static void PrintCallGraph(Module *M) {
- cout << cfg::CallGraph(M);
-}
+ virtual bool runOnFunction(Function &F) {
+ std::cout << "Printing analysis '" << PassToPrint->getPassName()
+ << "' for function '" << F.getName() << "':\n";
+ getAnalysisID<Pass>(PassToPrint).print(std::cout, F.getParent());
-static void PrintUnsafePtrTypes(Module *M) {
- FindUnsafePointerTypes FUPT;
- FUPT.run(M);
- FUPT.printResults(M, cout);
-}
+ // Get and print pass...
+ return false;
+ }
-static void PrintUsedTypes(Module *M) {
- FindUsedTypes FUT;
- FUT.run(M);
- FUT.printTypes(cout, M);
-}
+ virtual const char *getPassName() const { return "FunctionPass Printer"; }
-static void PrintDominatorSets(Method *M) {
- cout << cfg::DominatorSet(M);
-}
-static void PrintImmediateDominators(Method *M) {
- cout << cfg::ImmediateDominators(M);
-}
-static void PrintDominatorTree(Method *M) {
- cout << cfg::DominatorTree(M);
-}
-static void PrintDominanceFrontier(Method *M) {
- cout << cfg::DominanceFrontier(M);
-}
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequiredID(PassToPrint);
+ AU.setPreservesAll();
+ }
+};
-static void PrintPostDominatorSets(Method *M) {
- cout << cfg::DominatorSet(M, true);
-}
-static void PrintImmediatePostDoms(Method *M) {
- cout << cfg::ImmediateDominators(cfg::DominatorSet(M, true));
-}
-static void PrintPostDomTree(Method *M) {
- cout << cfg::DominatorTree(cfg::DominatorSet(M, true));
-}
-static void PrintPostDomFrontier(Method *M) {
- cout << cfg::DominanceFrontier(cfg::DominatorSet(M, true));
-}
+struct BasicBlockPassPrinter : public BasicBlockPass {
+ const PassInfo *PassToPrint;
+ BasicBlockPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
+ 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());
-enum Ans {
- PassDone, // Unique Marker
- print, intervals, exprclassify, instforest, loops, indvars, callgraph,
- printusedtypes, unsafepointertypes,
+ // Get and print pass...
+ return false;
+ }
- domset, idom, domtree, domfrontier,
- postdomset, postidom, postdomtree, postdomfrontier,
-};
+ virtual const char *getPassName() const { return "BasicBlockPass Printer"; }
-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(exprclassify , "Classify Expressions"),
- clEnumVal(instforest , "Print Instruction Forest"),
- clEnumVal(loops , "Print Loops"),
- clEnumVal(indvars , "Print Induction Variables"),
- 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;
- void (*AnPtr)(Method *M);
-} MethAnTable[] = {
- { print , PrintMethod },
- { intervals , PrintIntervalPartition },
- { exprclassify , PrintClassifiedExprs },
- { instforest , PrintInstForest },
- { loops , PrintLoops },
- { indvars , PrintInductionVariables },
-
- { domset , PrintDominatorSets },
- { idom , PrintImmediateDominators },
- { domtree , PrintDominatorTree },
- { domfrontier , PrintDominanceFrontier },
-
- { postdomset , PrintPostDominatorSets },
- { postidom , PrintImmediatePostDoms },
- { postdomtree , PrintPostDomTree },
- { postdomfrontier, PrintPostDomFrontier },
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequiredID(PassToPrint);
+ AU.setPreservesAll();
+ }
};
-pair<enum Ans, void (*)(Module *)> ModAnTable[] = {
- pair<enum Ans, void (*)(Module *)>(callgraph , PrintCallGraph),
- pair<enum Ans, void (*)(Module *)>(printusedtypes , PrintUsedTypes),
- pair<enum Ans, void (*)(Module *)>(unsafepointertypes, PrintUnsafePtrTypes),
-};
+namespace {
+ cl::opt<std::string>
+ InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"),
+ cl::value_desc("filename"));
+
+ cl::opt<bool> Quiet("q", cl::desc("Don't print analysis pass names"));
+ cl::alias QuietA("quiet", cl::desc("Alias for -q"),
+ cl::aliasopt(Quiet));
+
+ cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
+ cl::desc("Do not verify input module"));
+
+ // The AnalysesList is automatically populated with registered Passes by the
+ // PassNameParser.
+ //
+ cl::list<const PassInfo*, bool, FilteredPassNameParser<PassInfo::Analysis> >
+ AnalysesList(cl::desc("Analyses available:"));
+
+ Timer BytecodeLoadTimer("Bytecode Loader");
+}
int main(int argc, char **argv) {
cl::ParseCommandLineOptions(argc, argv, " llvm analysis printer tool\n");
-
- Module *C = ParseBytecodeFile(InputFilename);
- if (!C && !(C = ParseAssemblyFile(InputFilename))) {
- cerr << "Input file didn't read correctly.\n";
+ sys::PrintStackTraceOnErrorSignal();
+
+ Module *CurMod = 0;
+ try {
+#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 << argv[0] << ": " << E.getMessage() << "\n";
return 1;
}
- // Loop over all of the analyses looking for module level analyses to run...
+ // Create a PassManager to hold and optimize the collection of passes we are
+ // about to build...
+ //
+ PassManager Passes;
+
+ // Add an appropriate TargetData instance for this module...
+ Passes.add(new TargetData("analyze", CurMod));
+
+ // Make sure the input LLVM is well formed.
+ if (!NoVerify)
+ 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(ModAnTable)/sizeof(ModAnTable[0]); ++j) {
- if (ModAnTable[j].first == AnalysisPass) {
- if (!Quiet)
- cerr << "Running: " << AnalysesList.getArgDescription(AnalysisPass)
- << " analysis on module!\n";
- ModAnTable[j].second(C);
- AnalysesList[i] = PassDone; // Mark pass as complete so that we don't
- break; // get an error later
- }
- }
- }
-
- // Loop over all of the methods in the module...
- for (Module::iterator I = C->begin(), E = C->end(); I != E; ++I) {
- Method *M = *I;
- if (M->isExternal()) continue;
-
- for (unsigned i = 0; i < AnalysesList.size(); ++i) {
- enum Ans AnalysisPass = AnalysesList[i];
- if (AnalysisPass == PassDone) continue; // Don't rerun module analyses
-
- // Loop over all of the analyses to be run...
- unsigned j;
- for (j = 0; j < sizeof(MethAnTable)/sizeof(MethAnTable[0]); ++j) {
- if (AnalysisPass == MethAnTable[j].AnID) {
- if (!Quiet)
- cerr << "Running: " << AnalysesList.getArgDescription(AnalysisPass)
- << " analysis on '" << ((Value*)M)->getName() << "'!\n";
- MethAnTable[j].AnPtr(M);
- break;
- }
- }
- if (j == sizeof(MethAnTable)/sizeof(MethAnTable[0]))
- cerr << "Analysis tables inconsistent!\n";
- }
+ 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";
}
- delete C;
+ Passes.run(*CurMod);
+
+ delete CurMod;
return 0;
}
projects / oota-llvm.git / blobdiff