-; RUN: analyze %s -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=Ptr:HR
+; RUN: opt -analyze %s -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=Ptr:HR
; This is the same testcase as 2003-06-29-NodeCollapsing2.ll, but it uses the
; graph checker.
;
-; RUN: analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: opt -analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
;
%T = type { int}
-; RUN: analyze %s -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=X:GM
+; RUN: opt -analyze %s -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=X:GM
%G = internal global int 5
-; RUN: analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: opt -analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
%X = internal global { int, short, short } { int 1, short 2, short 3 }
; This should cause the global node to collapse!!
; XFAIL: *
-; RUN: analyze %s -datastructure-gc --dsgc-check-flags=test:GAU
+; RUN: opt -analyze %s -datastructure-gc --dsgc-check-flags=test:GAU
%Tree = type { int, %Tree*, %Tree* }
%T5 = external global %Tree
; This is the same testcase as 2003-06-29-NodeCollapsing2.ll, but it uses the
; graph checker.
;
-; RUN: analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: opt -analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
;
%S = type { double, int }
-; RUN: analyze %s -datastructure-gc -dsgc-check-flags=Xn:SMR
-; RUN: analyze %s -datastructure-gc -dsgc-check-flags=X:SMR
+; RUN: opt -analyze %s -datastructure-gc -dsgc-check-flags=Xn:SMR
+; RUN: opt -analyze %s -datastructure-gc -dsgc-check-flags=X:SMR
declare void %llvm.memcpy.i32(sbyte*, sbyte*, uint, uint)
declare void %llvm.memmove.i32(sbyte*, sbyte*, uint, uint)
-; RUN: analyze %s -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=bu &&\
-; RUN: analyze %s -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=td
+; RUN: opt -analyze %s -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=bu &&\
+; RUN: opt -analyze %s -datastructure-gc -dsgc-check-flags=G:GIM -dsgc-dspass=td
%S = type { double, int }
-; RUN: llvm-as < %s | analyze -datastructure
+; RUN: llvm-as < %s | opt -analyze -datastructure
target endian = little
target pointersize = 32
-; RUN: llvm-as < %s | analyze -datastructure
+; RUN: llvm-as < %s | opt -analyze -datastructure
; ModuleID = 'bug3.bc'
target endian = little
-; RUN: analyze %s -datastructure-gc -dsgc-check-flags=x:IA
+; RUN: opt -analyze %s -datastructure-gc -dsgc-check-flags=x:IA
; ModuleID = 'bug3.bc'
target endian = little
; FIXME: this should be SHM for bu, but change it for now since besides incompleteness
; this is working
-; RUN: analyze %s -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=Y:SHIM && \
-; RUN: analyze %s -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=P1:SHM,P2:SHM
+; RUN: opt -analyze %s -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=Y:SHIM && \
+; RUN: opt -analyze %s -datastructure-gc -dsgc-dspass=td -dsgc-check-flags=P1:SHM,P2:SHM
%G = internal constant [2 x int*(int*)*] [
int*(int*)* %callee1, int*(int*)* %callee2
; -- globals in GG pointed to by latter should be marked I, but not other nodes
;
; FIXME: KnownPtr should be just S.
-; RUN: analyze %s -datastructure-gc -dsgc-check-flags=KnownPtr:SI,UnknownPtr:SI -dsgc-dspass=bu
+; RUN: opt -analyze %s -datastructure-gc -dsgc-check-flags=KnownPtr:SI,UnknownPtr:SI -dsgc-dspass=bu
%Z = internal global int 0
%X = internal global int 0
-; RUN: analyze %s -budatastructure -dont-print-ds
+; RUN: opt -analyze %s -budatastructure -dont-print-ds
%MidFnTy = type void (\2*)
; Test to check for support for "physical subtyping"
;
-; RUN: analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
+; RUN: opt -analyze %s -datastructure-gc -dsgc-abort-if-any-collapsed
;
%S = type { int }
%T = type { int, float, double }
-; RUN: analyze %s -datastructure-gc --dsgc-abort-if-merged=Y,BVal
+; RUN: opt -analyze %s -datastructure-gc --dsgc-abort-if-merged=Y,BVal
implementation
; FIXME: A should just be SM
-; RUN: analyze %s -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=A:SIM
+; RUN: opt -analyze %s -datastructure-gc -dsgc-dspass=bu -dsgc-check-flags=A:SIM
; Constant globals should not mark stuff incomplete. This should allow the
; bu pass to resolve the indirect call immediately in "test", allowing %A to
; be marked complete and the store to happen.
; has no defined way to check for this, so DSA can know that strcpy doesn't
; require merging the input arguments.
-; RUN: analyze %s -datastructure-gc --dsgc-abort-if-merged=A,B --dsgc-check-flags=A:ASM,B:ASR --dsgc-dspass=bu
+; RUN: opt -analyze %s -datastructure-gc --dsgc-abort-if-merged=A,B --dsgc-check-flags=A:ASM,B:ASR --dsgc-dspass=bu
implementation
-; RUN: analyze %s -domset -disable-verify
+; RUN: opt -analyze %s -domset -disable-verify
;
int %re_match_2() {
ENTRY:
; This testcase was incorrectly computing that the loopentry.7 loop was
; not a child of the loopentry.6 loop.
;
-; RUN: analyze %s -loops | grep "^ Loop Containing: %loopentry.7"
+; RUN: opt -analyze %s -loops | grep "^ Loop Containing: %loopentry.7"
void %getAndMoveToFrontDecode() { ; No predecessors!
br label %endif.2
; folded completely away if possible. This is a very common case, so it should
; be efficient.
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
;
implementation
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
%crazy = type [2 x { [2 x sbyte], short } ]
implementation
; This file contains a list of situations where node folding should happen...
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
implementation
; very simple test
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
implementation
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
%str = type { int*, int* }
; This file contains a list of cases where node folding should NOT happen
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
;
implementation
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
%G = global int 2 ; <int*> [#uses=1]
%H = global int* null
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
int* %test1(int *%A) {
%R = getelementptr int* %A, long 1
; A test for "physical subtyping" used in some C programs...
;
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
;
%ST = type { int, int* } ; "Subtype"
%DT = type { int, int*, int } ; "derived type"
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
implementation ; Functions:
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
void %foo(int* %X) {
store int 4, int* %X
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
implementation
-; RUN: analyze %s -tddatastructure
+; RUN: opt -analyze %s -tddatastructure
%str = type { int, int* }
LEVEL := ..
PARALLEL_DIRS := llvm-config llvm-as llvm-dis opt gccas llc llvm-link lli gccld\
- llvm-stub analyze llvm-extract llvm-nm llvm-prof llvm-ar \
- llvm-ranlib llvm-bcanalyzer llvmc llvm-ld llvm-db bugpoint \
- llvm2cpp
+ llvm-stub llvm-extract llvm-nm llvm-prof llvm-ar llvm-ranlib \
+ llvm-bcanalyzer llvmc llvm-ld llvm-db bugpoint llvm2cpp
include $(LEVEL)/Makefile.common
+++ /dev/null
-//===- AnalysisWrappers.cpp - Wrappers around non-pass analyses -----------===//
-//
-// 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 file defines pass wrappers around LLVM analyses that don't make sense to
-// be passes. It provides a nice standard pass interface to these classes so
-// that they can be printed out by analyze.
-//
-// These classes are separated out of analyze.cpp so that it is more clear which
-// code is the integral part of the analyze tool, and which part of the code is
-// just making it so more passes are available.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Module.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/CallSite.h"
-#include "llvm/Analysis/CallGraph.h"
-#include <iostream>
-using namespace llvm;
-
-namespace {
- /// ExternalFunctionsPassedConstants - This pass prints out call sites to
- /// external functions that are called with constant arguments. This can be
- /// useful when looking for standard library functions we should constant fold
- /// or handle in alias analyses.
- struct ExternalFunctionsPassedConstants : public ModulePass {
- virtual bool runOnModule(Module &M) {
- for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
- if (I->isExternal()) {
- bool PrintedFn = false;
- for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
- UI != E; ++UI)
- if (Instruction *User = dyn_cast<Instruction>(*UI)) {
- CallSite CS = CallSite::get(User);
- if (CS.getInstruction()) {
- for (CallSite::arg_iterator AI = CS.arg_begin(),
- E = CS.arg_end(); AI != E; ++AI)
- if (isa<Constant>(*AI)) {
- if (!PrintedFn) {
- std::cerr << "Function '" << I->getName() << "':\n";
- PrintedFn = true;
- }
- std::cerr << *User;
- break;
- }
- }
- }
- }
-
- return false;
- }
-
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.setPreservesAll();
- }
- };
-
- RegisterAnalysis<ExternalFunctionsPassedConstants>
- P1("externalfnconstants", "Print external fn callsites passed constants");
-
- struct CallGraphPrinter : public ModulePass {
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.setPreservesAll();
- AU.addRequired<CallGraph>();
- }
- virtual bool runOnModule(Module &M) { return false; }
-
- virtual void print(std::ostream &OS, const Module *M) const {
- getAnalysis<CallGraph>().print(OS, M);
- }
- };
-
- RegisterAnalysis<CallGraphPrinter>
- P2("callgraph", "Print a call graph");
-}
+++ /dev/null
-//===- GraphPrinters.cpp - DOT printers for various graph types -----------===//
-//
-// 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 file defines several printers for various different types of graphs used
-// by the LLVM infrastructure. It uses the generic graph interface to convert
-// the graph into a .dot graph. These graphs can then be processed with the
-// "dot" tool to convert them to postscript or some other suitable format.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Support/GraphWriter.h"
-#include "llvm/Pass.h"
-#include "llvm/Value.h"
-#include "llvm/Analysis/CallGraph.h"
-#include <fstream>
-using namespace llvm;
-
-template<typename GraphType>
-static void WriteGraphToFile(std::ostream &O, const std::string &GraphName,
- const GraphType >) {
- std::string Filename = GraphName + ".dot";
- O << "Writing '" << Filename << "'...";
- std::ofstream F(Filename.c_str());
-
- if (F.good())
- WriteGraph(F, GT);
- else
- O << " error opening file for writing!";
- O << "\n";
-}
-
-
-//===----------------------------------------------------------------------===//
-// Call Graph Printer
-//===----------------------------------------------------------------------===//
-
-namespace llvm {
- template<>
- struct DOTGraphTraits<CallGraph*> : public DefaultDOTGraphTraits {
- static std::string getGraphName(CallGraph *F) {
- return "Call Graph";
- }
-
- static std::string getNodeLabel(CallGraphNode *Node, CallGraph *Graph) {
- if (Node->getFunction())
- return ((Value*)Node->getFunction())->getName();
- else
- return "Indirect call node";
- }
- };
-}
-
-
-namespace {
- struct CallGraphPrinter : public ModulePass {
- virtual bool runOnModule(Module &M) {
- WriteGraphToFile(std::cerr, "callgraph", &getAnalysis<CallGraph>());
- return false;
- }
-
- void print(std::ostream &OS) const {}
-
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.addRequired<CallGraph>();
- AU.setPreservesAll();
- }
- };
-
- RegisterAnalysis<CallGraphPrinter> P2("print-callgraph",
- "Print Call Graph to 'dot' file");
-}
+++ /dev/null
-##===- tools/analyze/Makefile ------------------------------*- Makefile -*-===##
-#
-# 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.
-#
-##===----------------------------------------------------------------------===##
-LEVEL = ../..
-TOOLNAME = analyze
-USEDLIBS = LLVMAsmParser.a LLVMBCReader.a LLVMAnalysis.a LLVMipa.a \
- LLVMDataStructure \
- LLVMScalarOpts.a LLVMTransforms.a LLVMTarget.a LLVMScalarOpts.a \
- LLVMTransformUtils.a LLVMCore.a LLVMSupport.a LLVMbzip2.a LLVMSystem.a
-REQUIRES_EH := 1
-
-include $(LEVEL)/Makefile.common
+++ /dev/null
-//===- PrintSCC.cpp - Enumerate SCCs in some key graphs -------------------===//
-//
-// 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 file provides passes to print out SCCs in a CFG or a CallGraph.
-// Normally, you would not use these passes; instead, you would use the
-// scc_iterator directly to enumerate SCCs and process them in some way. These
-// passes serve three purposes:
-//
-// (1) As a reference for how to use the scc_iterator.
-// (2) To print out the SCCs for a CFG or a CallGraph:
-// analyze -cfgscc to print the SCCs in each CFG of a module.
-// analyze -cfgscc -stats to print the #SCCs and the maximum SCC size.
-// analyze -cfgscc -debug > /dev/null to watch the algorithm in action.
-//
-// and similarly:
-// analyze -callscc [-stats] [-debug] to print SCCs in the CallGraph
-//
-// (3) To test the scc_iterator.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Pass.h"
-#include "llvm/Module.h"
-#include "llvm/Analysis/CallGraph.h"
-#include "llvm/Support/CFG.h"
-#include "llvm/ADT/SCCIterator.h"
-#include <iostream>
-using namespace llvm;
-
-namespace {
- struct CFGSCC : public FunctionPass {
- bool runOnFunction(Function& func);
-
- void print(std::ostream &O, const Module* = 0) const { }
-
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.setPreservesAll();
- }
- };
-
- struct CallGraphSCC : public ModulePass {
- // run - Print out SCCs in the call graph for the specified module.
- bool runOnModule(Module &M);
-
- void print(std::ostream &O, const Module* = 0) const { }
-
- // getAnalysisUsage - This pass requires the CallGraph.
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.setPreservesAll();
- AU.addRequired<CallGraph>();
- }
- };
-
- RegisterAnalysis<CFGSCC>
- Y("cfgscc", "Print SCCs of each function CFG");
-
- RegisterAnalysis<CallGraphSCC>
- Z("callscc", "Print SCCs of the Call Graph");
-}
-
-bool CFGSCC::runOnFunction(Function &F) {
- unsigned sccNum = 0;
- std::cout << "SCCs for Function " << F.getName() << " in PostOrder:";
- for (scc_iterator<Function*> SCCI = scc_begin(&F),
- E = scc_end(&F); SCCI != E; ++SCCI) {
- std::vector<BasicBlock*> &nextSCC = *SCCI;
- std::cout << "\nSCC #" << ++sccNum << " : ";
- for (std::vector<BasicBlock*>::const_iterator I = nextSCC.begin(),
- E = nextSCC.end(); I != E; ++I)
- std::cout << (*I)->getName() << ", ";
- if (nextSCC.size() == 1 && SCCI.hasLoop())
- std::cout << " (Has self-loop).";
- }
- std::cout << "\n";
-
- return true;
-}
-
-
-// run - Print out SCCs in the call graph for the specified module.
-bool CallGraphSCC::runOnModule(Module &M) {
- CallGraphNode* rootNode = getAnalysis<CallGraph>().getRoot();
- unsigned sccNum = 0;
- std::cout << "SCCs for the program in PostOrder:";
- for (scc_iterator<CallGraphNode*> SCCI = scc_begin(rootNode),
- E = scc_end(rootNode); SCCI != E; ++SCCI) {
- const std::vector<CallGraphNode*> &nextSCC = *SCCI;
- std::cout << "\nSCC #" << ++sccNum << " : ";
- for (std::vector<CallGraphNode*>::const_iterator I = nextSCC.begin(),
- E = nextSCC.end(); I != E; ++I)
- std::cout << ((*I)->getFunction() ? (*I)->getFunction()->getName()
- : std::string("Indirect CallGraph node")) << ", ";
- if (nextSCC.size() == 1 && SCCI.hasLoop())
- std::cout << " (Has self-loop).";
- }
- std::cout << "\n";
-
- return true;
-}
+++ /dev/null
-//===- 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
-// debugging an analysis pass.
-//
-// analyze --help - Output information about command line switches
-// analyze --quiet - Do not print analysis name before output
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Module.h"
-#include "llvm/PassManager.h"
-#include "llvm/Bytecode/Reader.h"
-#include "llvm/Assembly/Parser.h"
-#include "llvm/Analysis/Verifier.h"
-#include "llvm/Analysis/LinkAllAnalyses.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 "llvm/LinkAllVMCore.h"
-#include <algorithm>
-
-using namespace llvm;
-
-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");
-}
-
-struct ModulePassPrinter : public ModulePass {
- const PassInfo *PassToPrint;
- ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
-
- virtual bool runOnModule(Module &M) {
- if (!Quiet) {
- 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"; }
-
- 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) {
- if (!Quiet) {
- std::cout << "Printing analysis '" << PassToPrint->getPassName()
- << "' for function '" << F.getName() << "':\n";
- }
- // Get and print pass...
- getAnalysisID<Pass>(PassToPrint).print(std::cout, F.getParent());
- return false;
- }
-
- virtual const char *getPassName() const { return "FunctionPass Printer"; }
-
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.addRequiredID(PassToPrint);
- AU.setPreservesAll();
- }
-};
-
-struct BasicBlockPassPrinter : public BasicBlockPass {
- const PassInfo *PassToPrint;
- BasicBlockPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
-
- virtual bool runOnBasicBlock(BasicBlock &BB) {
- if (!Quiet) {
- std::cout << "Printing Analysis info for BasicBlock '" << BB.getName()
- << "': Pass " << PassToPrint->getPassName() << ":\n";
- }
-
- // Get and print pass...
- getAnalysisID<Pass>(PassToPrint).print(std::cout, BB.getParent()->getParent());
- return false;
- }
-
- virtual const char *getPassName() const { return "BasicBlockPass Printer"; }
-
- virtual void getAnalysisUsage(AnalysisUsage &AU) const {
- AU.addRequiredID(PassToPrint);
- AU.setPreservesAll();
- }
-};
-
-
-
-int main(int argc, char **argv) {
- try {
- 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;
- }
- } catch (const ParseException &E) {
- 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 Passes;
-
- // Add an appropriate TargetData instance for this module...
- Passes.add(new TargetData(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";
- }
-
- Passes.run(*CurMod);
-
- delete CurMod;
- return 0;
-
- } catch (const std::string& msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
- } catch (...) {
- std::cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
- }
- return 1;
-}
TOOLNAME = opt
REQUIRES_EH := 1
-USEDLIBS = LLVMBCReader.a LLVMBCWriter.a LLVMInstrumentation.a \
- LLVMScalarOpts.a LLVMipo.a LLVMipa.a LLVMDataStructure LLVMTransforms.a \
- LLVMTarget.a LLVMTransformUtils.a LLVMAnalysis.a LLVMCore.a LLVMSupport.a \
- LLVMbzip2.a LLVMSystem.a
+USEDLIBS = LLVMAsmParser.a LLVMBCReader.a LLVMBCWriter.a LLVMInstrumentation.a \
+ LLVMScalarOpts.a LLVMipo.a LLVMipa.a LLVMDataStructure \
+ LLVMTransforms.a LLVMTarget.a LLVMTransformUtils.a LLVMAnalysis.a \
+ LLVMCore.a LLVMSupport.a LLVMbzip2.a LLVMSystem.a
include $(LEVEL)/Makefile.common
//===----------------------------------------------------------------------===//
//
// Optimizations may be specified an arbitrary number of times on the command
-// line, they are run in the order specified.
+// line, They are run in the order specified.
//
//===----------------------------------------------------------------------===//
#include "llvm/Module.h"
+#include "llvm/Assembly/Parser.h"
#include "llvm/PassManager.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Bytecode/WriteBytecodePass.h"
#include "llvm/System/Signals.h"
#include "llvm/Support/PluginLoader.h"
#include "llvm/Support/SystemUtils.h"
+#include "llvm/Support/Timer.h"
+#include "llvm/Analysis/LinkAllAnalyses.h"
#include "llvm/Transforms/LinkAllPasses.h"
#include "llvm/LinkAllVMCore.h"
#include <fstream>
// Other command line options...
//
static cl::opt<std::string>
-InputFilename(cl::Positional, cl::desc("<input bytecode>"), cl::init("-"));
+InputFilename(cl::Positional, cl::desc("<input bytecode file>"),
+ cl::init("-"), cl::value_desc("filename"));
static cl::opt<std::string>
OutputFilename("o", cl::desc("Override output filename"),
static cl::alias
QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet));
+static cl::opt<bool>
+AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization"));
+
+// 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:"));
+
+static Timer BytecodeLoadTimer("Bytecode Loader");
+
+// ---------- Define Printers for module and function passes ------------
+namespace {
+
+struct ModulePassPrinter : public ModulePass {
+ const PassInfo *PassToPrint;
+ ModulePassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
+
+ virtual bool runOnModule(Module &M) {
+ if (!Quiet) {
+ 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"; }
+
+ 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) {
+ if (!Quiet) {
+ std::cout << "Printing analysis '" << PassToPrint->getPassName()
+ << "' for function '" << F.getName() << "':\n";
+ }
+ // Get and print pass...
+ getAnalysisID<Pass>(PassToPrint).print(std::cout, F.getParent());
+ return false;
+ }
+
+ virtual const char *getPassName() const { return "FunctionPass Printer"; }
+
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequiredID(PassToPrint);
+ AU.setPreservesAll();
+ }
+};
+
+struct BasicBlockPassPrinter : public BasicBlockPass {
+ const PassInfo *PassToPrint;
+ BasicBlockPassPrinter(const PassInfo *PI) : PassToPrint(PI) {}
+
+ virtual bool runOnBasicBlock(BasicBlock &BB) {
+ if (!Quiet) {
+ std::cout << "Printing Analysis info for BasicBlock '" << BB.getName()
+ << "': Pass " << PassToPrint->getPassName() << ":\n";
+ }
+
+ // Get and print pass...
+ getAnalysisID<Pass>(PassToPrint).print(
+ std::cout, BB.getParent()->getParent());
+ return false;
+ }
+
+ virtual const char *getPassName() const { return "BasicBlockPass Printer"; }
+
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.addRequiredID(PassToPrint);
+ AU.setPreservesAll();
+ }
+};
+
+} // anonymous namespace
+
//===----------------------------------------------------------------------===//
// main for opt
int main(int argc, char **argv) {
try {
cl::ParseCommandLineOptions(argc, argv,
- " llvm .bc -> .bc modular optimizer\n");
+ " llvm .bc -> .bc modular optimizer and analysis printer \n");
sys::PrintStackTraceOnErrorSignal();
+ if (AnalyzeOnly) {
+ 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;
+ }
+
+ // 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(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";
+ }
+
+ Passes.run(*CurMod);
+
+ delete CurMod;
+ return 0;
+ }
+
// Allocate a full target machine description only if necessary...
// FIXME: The choice of target should be controllable on the command line.
std::auto_ptr<TargetMachine> target;
Passes.run(*M.get());
return 0;
+
} catch (const std::string& msg) {
std::cerr << argv[0] << ": " << msg << "\n";
} catch (...) {
projects / oota-llvm.git / commitdiff