-//===------------------------------------------------------------------------===
-// 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 <iostream>
-#include "llvm/Instruction.h"
#include "llvm/Module.h"
-#include "llvm/Method.h"
+#include "llvm/PassManager.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Assembly/Parser.h"
-#include "llvm/Tools/CommandLine.h"
-#include "llvm/Analysis/Writer.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>
+
+using namespace llvm;
+
+struct ModulePassPrinter : public Pass {
+ const PassInfo *PassToPrint;
+ ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
+
+ 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"; }
-#include "llvm/Analysis/Dominators.h"
-#include "llvm/Analysis/IntervalPartition.h"
-#include "llvm/Analysis/Expressions.h"
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequiredID(PassToPrint);
+ AU.setPreservesAll();
+ }
+};
-static void PrintMethod(Method *M) {
- cout << M;
-}
+struct FunctionPassPrinter : public FunctionPass {
+ const PassInfo *PassToPrint;
+ FunctionPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
-static void PrintIntervalPartition(Method *M) {
- cout << cfg::IntervalPartition(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 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;
+ // Get and print pass...
+ return false;
}
-}
+ 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());
+
+ // Get and print pass...
+ return false;
+ }
+
+ virtual const char *getPassName() const { return "BasicBlockPass Printer"; }
-struct {
- const string ArgName, Name;
- void (*AnPtr)(Method *M);
-} AnTable[] = {
- { "-print" , "Print each Method" , PrintMethod },
- { "-intervals" , "Interval Partition" , PrintIntervalPartition },
- { "-exprclassify" , "Classify Expressions" , PrintClassifiedExprs },
-
- { "-domset" , "Dominator Sets" , PrintDominatorSets },
- { "-idom" , "Immediate Dominators" , PrintImmediateDominators },
- { "-domtree" , "Dominator Tree" , PrintDominatorTree },
- { "-domfrontier" , "Dominance Frontier" , PrintDominanceFrontier },
-
- { "-postdomset" , "Postdominator Sets" , PrintPostDominatorSets },
- { "-postidom" , "Immediate Postdominators", PrintImmediatePostDoms },
- { "-postdomtree" , "Post Dominator Tree" , PrintPostDomTree },
- { "-postdomfrontier", "Postdominance Frontier" , PrintPostDomFrontier },
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequiredID(PassToPrint);
+ AU.setPreservesAll();
+ }
};
+
+
+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) {
- ToolCommandLine Options(argc, argv, false);
- bool Quiet = false;
-
- for (int i = 1; i < argc; i++) {
- if (string(argv[i]) == string("--help")) {
- cerr << argv[0] << " usage:\n"
- << " " << argv[0] << " --help\t - Print this usage information\n"
- << "\t --quiet\t - Do not print analysis name before output\n";
- for (unsigned j = 0; j < sizeof(AnTable)/sizeof(AnTable[0]); ++j) {
- cerr << "\t " << AnTable[j].ArgName << "\t - Print "
- << AnTable[j].Name << endl;
- }
+ cl::ParseCommandLineOptions(argc, argv, " llvm analysis printer tool\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;
- } else if (string(argv[i]) == string("-q") ||
- string(argv[i]) == string("--quiet")) {
- Quiet = true; argv[i] = 0;
}
- }
-
- Module *C = ParseBytecodeFile(Options.getInputFilename());
- if (!C && !(C = ParseAssemblyFile(Options))) {
- cerr << "Input file didn't read correctly.\n";
+ } catch (const ParseException &E) {
+ std::cerr << argv[0] << ": " << E.getMessage() << "\n";
return 1;
}
- // 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;
-
- // Loop over all of the analyses to be run...
- for (int i = 1; i < argc; i++) {
- if (argv[i] == 0) continue;
- unsigned j;
- for (j = 0; j < sizeof(AnTable)/sizeof(AnTable[0]); j++) {
- if (string(argv[i]) == AnTable[j].ArgName) {
- if (!Quiet)
- cerr << "Running: " << AnTable[j].Name << " analysis on '"
- << ((Value*)M)->getName() << "'!\n";
- AnTable[j].AnPtr(M);
- break;
- }
- }
-
- if (j == sizeof(AnTable)/sizeof(AnTable[0]))
- cerr << "'" << argv[i] << "' argument unrecognized: ignored\n";
- }
+ // 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) {
+ 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