diff options
Diffstat (limited to 'contrib/llvm/tools/opt')
| -rw-r--r-- | contrib/llvm/tools/opt/AnalysisWrappers.cpp | 94 | ||||
| -rw-r--r-- | contrib/llvm/tools/opt/CMakeLists.txt | 8 | ||||
| -rw-r--r-- | contrib/llvm/tools/opt/GraphPrinters.cpp | 123 | ||||
| -rw-r--r-- | contrib/llvm/tools/opt/Makefile | 14 | ||||
| -rw-r--r-- | contrib/llvm/tools/opt/PrintSCC.cpp | 112 | ||||
| -rw-r--r-- | contrib/llvm/tools/opt/opt.cpp | 557 |
6 files changed, 0 insertions, 908 deletions
diff --git a/contrib/llvm/tools/opt/AnalysisWrappers.cpp b/contrib/llvm/tools/opt/AnalysisWrappers.cpp deleted file mode 100644 index a2b57bb..0000000 --- a/contrib/llvm/tools/opt/AnalysisWrappers.cpp +++ /dev/null @@ -1,94 +0,0 @@ -//===- AnalysisWrappers.cpp - Wrappers around non-pass analyses -----------===// -// -// The LLVM Compiler Infrastructure -// -// This file 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 "llvm/Support/raw_ostream.h" -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 { - static char ID; // Pass ID, replacement for typeid - ExternalFunctionsPassedConstants() : ModulePass(ID) {} - virtual bool runOnModule(Module &M) { - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { - if (!I->isDeclaration()) continue; - - bool PrintedFn = false; - for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); - UI != E; ++UI) { - Instruction *User = dyn_cast<Instruction>(*UI); - if (!User) continue; - - CallSite CS(cast<Value>(User)); - if (!CS) continue; - - for (CallSite::arg_iterator AI = CS.arg_begin(), - E = CS.arg_end(); AI != E; ++AI) { - if (!isa<Constant>(*AI)) continue; - - if (!PrintedFn) { - errs() << "Function '" << I->getName() << "':\n"; - PrintedFn = true; - } - errs() << *User; - break; - } - } - } - - return false; - } - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesAll(); - } - }; -} - -char ExternalFunctionsPassedConstants::ID = 0; -static RegisterPass<ExternalFunctionsPassedConstants> - P1("print-externalfnconstants", - "Print external fn callsites passed constants"); - -namespace { - struct CallGraphPrinter : public ModulePass { - static char ID; // Pass ID, replacement for typeid - CallGraphPrinter() : ModulePass(ID) {} - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesAll(); - AU.addRequiredTransitive<CallGraph>(); - } - virtual bool runOnModule(Module &M) { - getAnalysis<CallGraph>().print(errs(), &M); - return false; - } - }; -} - -char CallGraphPrinter::ID = 0; -static RegisterPass<CallGraphPrinter> - P2("print-callgraph", "Print a call graph"); diff --git a/contrib/llvm/tools/opt/CMakeLists.txt b/contrib/llvm/tools/opt/CMakeLists.txt deleted file mode 100644 index 0570d0e..0000000 --- a/contrib/llvm/tools/opt/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -set(LLVM_LINK_COMPONENTS bitreader asmparser bitwriter instrumentation scalaropts ipo) - -add_llvm_tool(opt - AnalysisWrappers.cpp - GraphPrinters.cpp - PrintSCC.cpp - opt.cpp - ) diff --git a/contrib/llvm/tools/opt/GraphPrinters.cpp b/contrib/llvm/tools/opt/GraphPrinters.cpp deleted file mode 100644 index 9de7d6a..0000000 --- a/contrib/llvm/tools/opt/GraphPrinters.cpp +++ /dev/null @@ -1,123 +0,0 @@ -//===- GraphPrinters.cpp - DOT printers for various graph types -----------===// -// -// The LLVM Compiler Infrastructure -// -// This file 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 "llvm/Analysis/Dominators.h" -#include "llvm/Support/raw_ostream.h" -using namespace llvm; - -template<typename GraphType> -static void WriteGraphToFile(raw_ostream &O, const std::string &GraphName, - const GraphType >) { - std::string Filename = GraphName + ".dot"; - O << "Writing '" << Filename << "'..."; - std::string ErrInfo; - tool_output_file F(Filename.c_str(), ErrInfo); - - if (ErrInfo.empty()) { - WriteGraph(F.os(), GT); - F.os().close(); - if (!F.os().has_error()) { - O << "\n"; - F.keep(); - return; - } - } - O << " error opening file for writing!\n"; - F.os().clear_error(); -} - - -//===----------------------------------------------------------------------===// -// Call Graph Printer -//===----------------------------------------------------------------------===// - -namespace llvm { - template<> - struct DOTGraphTraits<CallGraph*> : public DefaultDOTGraphTraits { - - DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {} - - 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 "external node"; - } - }; -} - - -namespace { - struct CallGraphPrinter : public ModulePass { - static char ID; // Pass ID, replacement for typeid - CallGraphPrinter() : ModulePass(ID) {} - - virtual bool runOnModule(Module &M) { - WriteGraphToFile(llvm::errs(), "callgraph", &getAnalysis<CallGraph>()); - return false; - } - - void print(raw_ostream &OS, const llvm::Module*) const {} - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequired<CallGraph>(); - AU.setPreservesAll(); - } - }; -} - -char CallGraphPrinter::ID = 0; -static RegisterPass<CallGraphPrinter> P2("dot-callgraph", - "Print Call Graph to 'dot' file"); - -//===----------------------------------------------------------------------===// -// DomInfoPrinter Pass -//===----------------------------------------------------------------------===// - -namespace { - class DomInfoPrinter : public FunctionPass { - public: - static char ID; // Pass identification, replacement for typeid - DomInfoPrinter() : FunctionPass(ID) {} - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesAll(); - AU.addRequired<DominatorTree>(); - AU.addRequired<DominanceFrontier>(); - - } - - virtual bool runOnFunction(Function &F) { - DominatorTree &DT = getAnalysis<DominatorTree>(); - DT.dump(); - DominanceFrontier &DF = getAnalysis<DominanceFrontier>(); - DF.dump(); - return false; - } - }; -} - -char DomInfoPrinter::ID = 0; -static RegisterPass<DomInfoPrinter> -DIP("print-dom-info", "Dominator Info Printer", true, true); diff --git a/contrib/llvm/tools/opt/Makefile b/contrib/llvm/tools/opt/Makefile deleted file mode 100644 index 726cad8..0000000 --- a/contrib/llvm/tools/opt/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -##===- tools/opt/Makefile ----------------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## -LEVEL = ../.. -TOOLNAME = opt - -LINK_COMPONENTS := bitreader bitwriter asmparser instrumentation scalaropts ipo - -include $(LEVEL)/Makefile.common diff --git a/contrib/llvm/tools/opt/PrintSCC.cpp b/contrib/llvm/tools/opt/PrintSCC.cpp deleted file mode 100644 index 533f49e..0000000 --- a/contrib/llvm/tools/opt/PrintSCC.cpp +++ /dev/null @@ -1,112 +0,0 @@ -//===- PrintSCC.cpp - Enumerate SCCs in some key graphs -------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file 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 -print-cfg-sccs to print the SCCs in each CFG of a module. -// analyze -print-cfg-sccs -stats to print the #SCCs and the maximum SCC size. -// analyze -print-cfg-sccs -debug > /dev/null to watch the algorithm in action. -// -// and similarly: -// analyze -print-callgraph-sccs [-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/Support/raw_ostream.h" -#include "llvm/ADT/SCCIterator.h" -using namespace llvm; - -namespace { - struct CFGSCC : public FunctionPass { - static char ID; // Pass identification, replacement for typeid - CFGSCC() : FunctionPass(ID) {} - bool runOnFunction(Function& func); - - void print(raw_ostream &O, const Module* = 0) const { } - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesAll(); - } - }; - - struct CallGraphSCC : public ModulePass { - static char ID; // Pass identification, replacement for typeid - CallGraphSCC() : ModulePass(ID) {} - - // run - Print out SCCs in the call graph for the specified module. - bool runOnModule(Module &M); - - void print(raw_ostream &O, const Module* = 0) const { } - - // getAnalysisUsage - This pass requires the CallGraph. - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesAll(); - AU.addRequired<CallGraph>(); - } - }; -} - -char CFGSCC::ID = 0; -static RegisterPass<CFGSCC> -Y("print-cfg-sccs", "Print SCCs of each function CFG"); - -char CallGraphSCC::ID = 0; -static RegisterPass<CallGraphSCC> -Z("print-callgraph-sccs", "Print SCCs of the Call Graph"); - -bool CFGSCC::runOnFunction(Function &F) { - unsigned sccNum = 0; - errs() << "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; - errs() << "\nSCC #" << ++sccNum << " : "; - for (std::vector<BasicBlock*>::const_iterator I = nextSCC.begin(), - E = nextSCC.end(); I != E; ++I) - errs() << (*I)->getName() << ", "; - if (nextSCC.size() == 1 && SCCI.hasLoop()) - errs() << " (Has self-loop)."; - } - errs() << "\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; - errs() << "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; - errs() << "\nSCC #" << ++sccNum << " : "; - for (std::vector<CallGraphNode*>::const_iterator I = nextSCC.begin(), - E = nextSCC.end(); I != E; ++I) - errs() << ((*I)->getFunction() ? (*I)->getFunction()->getNameStr() - : std::string("external node")) << ", "; - if (nextSCC.size() == 1 && SCCI.hasLoop()) - errs() << " (Has self-loop)."; - } - errs() << "\n"; - - return true; -} diff --git a/contrib/llvm/tools/opt/opt.cpp b/contrib/llvm/tools/opt/opt.cpp deleted file mode 100644 index d837185..0000000 --- a/contrib/llvm/tools/opt/opt.cpp +++ /dev/null @@ -1,557 +0,0 @@ -//===- opt.cpp - The LLVM Modular Optimizer -------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// Optimizations may be specified an arbitrary number of times on the command -// line, They are run in the order specified. -// -//===----------------------------------------------------------------------===// - -#include "llvm/LLVMContext.h" -#include "llvm/Module.h" -#include "llvm/PassManager.h" -#include "llvm/CallGraphSCCPass.h" -#include "llvm/Bitcode/ReaderWriter.h" -#include "llvm/Assembly/PrintModulePass.h" -#include "llvm/Analysis/Verifier.h" -#include "llvm/Analysis/LoopPass.h" -#include "llvm/Analysis/CallGraph.h" -#include "llvm/Target/TargetData.h" -#include "llvm/Target/TargetMachine.h" -#include "llvm/Support/PassNameParser.h" -#include "llvm/System/Signals.h" -#include "llvm/Support/Debug.h" -#include "llvm/Support/IRReader.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/PluginLoader.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/Support/StandardPasses.h" -#include "llvm/Support/SystemUtils.h" -#include "llvm/Support/raw_ostream.h" -#include "llvm/LinkAllPasses.h" -#include "llvm/LinkAllVMCore.h" -#include <memory> -#include <algorithm> -using namespace llvm; - -// The OptimizationList is automatically populated with registered Passes by the -// PassNameParser. -// -static cl::list<const PassInfo*, bool, PassNameParser> -PassList(cl::desc("Optimizations available:")); - -// Other command line options... -// -static cl::opt<std::string> -InputFilename(cl::Positional, cl::desc("<input bitcode file>"), - cl::init("-"), cl::value_desc("filename")); - -static cl::opt<std::string> -OutputFilename("o", cl::desc("Override output filename"), - cl::value_desc("filename")); - -static cl::opt<bool> -Force("f", cl::desc("Enable binary output on terminals")); - -static cl::opt<bool> -PrintEachXForm("p", cl::desc("Print module after each transformation")); - -static cl::opt<bool> -NoOutput("disable-output", - cl::desc("Do not write result bitcode file"), cl::Hidden); - -static cl::opt<bool> -OutputAssembly("S", cl::desc("Write output as LLVM assembly")); - -static cl::opt<bool> -NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden); - -static cl::opt<bool> -VerifyEach("verify-each", cl::desc("Verify after each transform")); - -static cl::opt<bool> -StripDebug("strip-debug", - cl::desc("Strip debugger symbol info from translation unit")); - -static cl::opt<bool> -DisableInline("disable-inlining", cl::desc("Do not run the inliner pass")); - -static cl::opt<bool> -DisableOptimizations("disable-opt", - cl::desc("Do not run any optimization passes")); - -static cl::opt<bool> -DisableInternalize("disable-internalize", - cl::desc("Do not mark all symbols as internal")); - -static cl::opt<bool> -StandardCompileOpts("std-compile-opts", - cl::desc("Include the standard compile time optimizations")); - -static cl::opt<bool> -StandardLinkOpts("std-link-opts", - cl::desc("Include the standard link time optimizations")); - -static cl::opt<bool> -OptLevelO1("O1", - cl::desc("Optimization level 1. Similar to llvm-gcc -O1")); - -static cl::opt<bool> -OptLevelO2("O2", - cl::desc("Optimization level 2. Similar to llvm-gcc -O2")); - -static cl::opt<bool> -OptLevelO3("O3", - cl::desc("Optimization level 3. Similar to llvm-gcc -O3")); - -static cl::opt<bool> -UnitAtATime("funit-at-a-time", - cl::desc("Enable IPO. This is same as llvm-gcc's -funit-at-a-time"), - cl::init(true)); - -static cl::opt<bool> -DisableSimplifyLibCalls("disable-simplify-libcalls", - cl::desc("Disable simplify-libcalls")); - -static cl::opt<bool> -Quiet("q", cl::desc("Obsolete option"), cl::Hidden); - -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")); - -static cl::opt<std::string> -DefaultDataLayout("default-data-layout", - cl::desc("data layout string to use if not specified by module"), - cl::value_desc("layout-string"), cl::init("")); - -// ---------- Define Printers for module and function passes ------------ -namespace { - -struct CallGraphSCCPassPrinter : public CallGraphSCCPass { - static char ID; - const PassInfo *PassToPrint; - raw_ostream &Out; - CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out) : - CallGraphSCCPass(ID), PassToPrint(PI), Out(out) {} - - virtual bool runOnSCC(CallGraphSCC &SCC) { - if (!Quiet) { - Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; - - for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { - Function *F = (*I)->getFunction(); - if (F) - getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, - F->getParent()); - } - } - // Get and print pass... - return false; - } - - virtual const char *getPassName() const { return "'Pass' Printer"; } - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint->getTypeInfo()); - AU.setPreservesAll(); - } -}; - -char CallGraphSCCPassPrinter::ID = 0; - -struct ModulePassPrinter : public ModulePass { - static char ID; - const PassInfo *PassToPrint; - raw_ostream &Out; - ModulePassPrinter(const PassInfo *PI, raw_ostream &out) - : ModulePass(ID), PassToPrint(PI), Out(out) {} - - virtual bool runOnModule(Module &M) { - if (!Quiet) { - Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; - getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M); - } - - // Get and print pass... - return false; - } - - virtual const char *getPassName() const { return "'Pass' Printer"; } - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint->getTypeInfo()); - AU.setPreservesAll(); - } -}; - -char ModulePassPrinter::ID = 0; -struct FunctionPassPrinter : public FunctionPass { - const PassInfo *PassToPrint; - raw_ostream &Out; - static char ID; - FunctionPassPrinter(const PassInfo *PI, raw_ostream &out) - : FunctionPass(ID), PassToPrint(PI), Out(out) {} - - virtual bool runOnFunction(Function &F) { - if (!Quiet) { - Out << "Printing analysis '" << PassToPrint->getPassName() - << "' for function '" << F.getName() << "':\n"; - } - // Get and print pass... - getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, - F.getParent()); - return false; - } - - virtual const char *getPassName() const { return "FunctionPass Printer"; } - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint->getTypeInfo()); - AU.setPreservesAll(); - } -}; - -char FunctionPassPrinter::ID = 0; - -struct LoopPassPrinter : public LoopPass { - static char ID; - const PassInfo *PassToPrint; - raw_ostream &Out; - LoopPassPrinter(const PassInfo *PI, raw_ostream &out) : - LoopPass(ID), PassToPrint(PI), Out(out) {} - - virtual bool runOnLoop(Loop *L, LPPassManager &LPM) { - if (!Quiet) { - Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; - getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, - L->getHeader()->getParent()->getParent()); - } - // Get and print pass... - return false; - } - - virtual const char *getPassName() const { return "'Pass' Printer"; } - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint->getTypeInfo()); - AU.setPreservesAll(); - } -}; - -char LoopPassPrinter::ID = 0; - -struct BasicBlockPassPrinter : public BasicBlockPass { - const PassInfo *PassToPrint; - raw_ostream &Out; - static char ID; - BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out) - : BasicBlockPass(ID), PassToPrint(PI), Out(out) {} - - virtual bool runOnBasicBlock(BasicBlock &BB) { - if (!Quiet) { - Out << "Printing Analysis info for BasicBlock '" << BB.getName() - << "': Pass " << PassToPrint->getPassName() << ":\n"; - } - - // Get and print pass... - getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, - BB.getParent()->getParent()); - return false; - } - - virtual const char *getPassName() const { return "BasicBlockPass Printer"; } - - virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint->getTypeInfo()); - AU.setPreservesAll(); - } -}; - -char BasicBlockPassPrinter::ID = 0; -inline void addPass(PassManagerBase &PM, Pass *P) { - // Add the pass to the pass manager... - PM.add(P); - - // If we are verifying all of the intermediate steps, add the verifier... - if (VerifyEach) PM.add(createVerifierPass()); -} - -/// AddOptimizationPasses - This routine adds optimization passes -/// based on selected optimization level, OptLevel. This routine -/// duplicates llvm-gcc behaviour. -/// -/// OptLevel - Optimization Level -void AddOptimizationPasses(PassManagerBase &MPM, PassManagerBase &FPM, - unsigned OptLevel) { - createStandardFunctionPasses(&FPM, OptLevel); - - llvm::Pass *InliningPass = 0; - if (DisableInline) { - // No inlining pass - } else if (OptLevel) { - unsigned Threshold = 200; - if (OptLevel > 2) - Threshold = 250; - InliningPass = createFunctionInliningPass(Threshold); - } else { - InliningPass = createAlwaysInlinerPass(); - } - createStandardModulePasses(&MPM, OptLevel, - /*OptimizeSize=*/ false, - UnitAtATime, - /*UnrollLoops=*/ OptLevel > 1, - !DisableSimplifyLibCalls, - /*HaveExceptions=*/ true, - InliningPass); -} - -void AddStandardCompilePasses(PassManagerBase &PM) { - PM.add(createVerifierPass()); // Verify that input is correct - - addPass(PM, createLowerSetJmpPass()); // Lower llvm.setjmp/.longjmp - - // If the -strip-debug command line option was specified, do it. - if (StripDebug) - addPass(PM, createStripSymbolsPass(true)); - - if (DisableOptimizations) return; - - llvm::Pass *InliningPass = !DisableInline ? createFunctionInliningPass() : 0; - - // -std-compile-opts adds the same module passes as -O3. - createStandardModulePasses(&PM, 3, - /*OptimizeSize=*/ false, - /*UnitAtATime=*/ true, - /*UnrollLoops=*/ true, - /*SimplifyLibCalls=*/ true, - /*HaveExceptions=*/ true, - InliningPass); -} - -void AddStandardLinkPasses(PassManagerBase &PM) { - PM.add(createVerifierPass()); // Verify that input is correct - - // If the -strip-debug command line option was specified, do it. - if (StripDebug) - addPass(PM, createStripSymbolsPass(true)); - - if (DisableOptimizations) return; - - createStandardLTOPasses(&PM, /*Internalize=*/ !DisableInternalize, - /*RunInliner=*/ !DisableInline, - /*VerifyEach=*/ VerifyEach); -} - -} // anonymous namespace - - -//===----------------------------------------------------------------------===// -// main for opt -// -int main(int argc, char **argv) { - sys::PrintStackTraceOnErrorSignal(); - llvm::PrettyStackTraceProgram X(argc, argv); - - if (AnalyzeOnly && NoOutput) { - errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n"; - return 1; - } - - // Enable debug stream buffering. - EnableDebugBuffering = true; - - llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - LLVMContext &Context = getGlobalContext(); - - cl::ParseCommandLineOptions(argc, argv, - "llvm .bc -> .bc modular optimizer and analysis printer\n"); - - // 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; - - SMDiagnostic Err; - - // Load the input module... - std::auto_ptr<Module> M; - M.reset(ParseIRFile(InputFilename, Err, Context)); - - if (M.get() == 0) { - Err.Print(argv[0], errs()); - return 1; - } - - // Figure out what stream we are supposed to write to... - OwningPtr<tool_output_file> Out; - if (NoOutput) { - if (!OutputFilename.empty()) - errs() << "WARNING: The -o (output filename) option is ignored when\n" - "the --disable-output option is used.\n"; - } else { - // Default to standard output. - if (OutputFilename.empty()) - OutputFilename = "-"; - - std::string ErrorInfo; - Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo, - raw_fd_ostream::F_Binary)); - if (!ErrorInfo.empty()) { - errs() << ErrorInfo << '\n'; - return 1; - } - } - - // If the output is set to be emitted to standard out, and standard out is a - // console, print out a warning message and refuse to do it. We don't - // impress anyone by spewing tons of binary goo to a terminal. - if (!Force && !NoOutput && !AnalyzeOnly && !OutputAssembly) - if (CheckBitcodeOutputToConsole(Out->os(), !Quiet)) - NoOutput = true; - - // 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... - TargetData *TD = 0; - const std::string &ModuleDataLayout = M.get()->getDataLayout(); - if (!ModuleDataLayout.empty()) - TD = new TargetData(ModuleDataLayout); - else if (!DefaultDataLayout.empty()) - TD = new TargetData(DefaultDataLayout); - - if (TD) - Passes.add(TD); - - OwningPtr<PassManager> FPasses; - if (OptLevelO1 || OptLevelO2 || OptLevelO3) { - FPasses.reset(new PassManager()); - if (TD) - FPasses->add(new TargetData(*TD)); - } - - // If the -strip-debug command line option was specified, add it. If - // -std-compile-opts was also specified, it will handle StripDebug. - if (StripDebug && !StandardCompileOpts) - addPass(Passes, createStripSymbolsPass(true)); - - // Create a new optimization pass for each one specified on the command line - for (unsigned i = 0; i < PassList.size(); ++i) { - // Check to see if -std-compile-opts was specified before this option. If - // so, handle it. - if (StandardCompileOpts && - StandardCompileOpts.getPosition() < PassList.getPosition(i)) { - AddStandardCompilePasses(Passes); - StandardCompileOpts = false; - } - - if (StandardLinkOpts && - StandardLinkOpts.getPosition() < PassList.getPosition(i)) { - AddStandardLinkPasses(Passes); - StandardLinkOpts = false; - } - - if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) { - AddOptimizationPasses(Passes, *FPasses, 1); - OptLevelO1 = false; - } - - if (OptLevelO2 && OptLevelO2.getPosition() < PassList.getPosition(i)) { - AddOptimizationPasses(Passes, *FPasses, 2); - OptLevelO2 = false; - } - - if (OptLevelO3 && OptLevelO3.getPosition() < PassList.getPosition(i)) { - AddOptimizationPasses(Passes, *FPasses, 3); - OptLevelO3 = false; - } - - const PassInfo *PassInf = PassList[i]; - Pass *P = 0; - if (PassInf->getNormalCtor()) - P = PassInf->getNormalCtor()(); - else - errs() << argv[0] << ": cannot create pass: " - << PassInf->getPassName() << "\n"; - if (P) { - PassKind Kind = P->getPassKind(); - addPass(Passes, P); - - if (AnalyzeOnly) { - switch (Kind) { - case PT_BasicBlock: - Passes.add(new BasicBlockPassPrinter(PassInf, Out->os())); - break; - case PT_Loop: - Passes.add(new LoopPassPrinter(PassInf, Out->os())); - break; - case PT_Function: - Passes.add(new FunctionPassPrinter(PassInf, Out->os())); - break; - case PT_CallGraphSCC: - Passes.add(new CallGraphSCCPassPrinter(PassInf, Out->os())); - break; - default: - Passes.add(new ModulePassPrinter(PassInf, Out->os())); - break; - } - } - } - - if (PrintEachXForm) - Passes.add(createPrintModulePass(&errs())); - } - - // If -std-compile-opts was specified at the end of the pass list, add them. - if (StandardCompileOpts) { - AddStandardCompilePasses(Passes); - StandardCompileOpts = false; - } - - if (StandardLinkOpts) { - AddStandardLinkPasses(Passes); - StandardLinkOpts = false; - } - - if (OptLevelO1) - AddOptimizationPasses(Passes, *FPasses, 1); - - if (OptLevelO2) - AddOptimizationPasses(Passes, *FPasses, 2); - - if (OptLevelO3) - AddOptimizationPasses(Passes, *FPasses, 3); - - if (OptLevelO1 || OptLevelO2 || OptLevelO3) - FPasses->run(*M.get()); - - // Check that the module is well formed on completion of optimization - if (!NoVerify && !VerifyEach) - Passes.add(createVerifierPass()); - - // Write bitcode or assembly to the output as the last step... - if (!NoOutput && !AnalyzeOnly) { - if (OutputAssembly) - Passes.add(createPrintModulePass(&Out->os())); - else - Passes.add(createBitcodeWriterPass(Out->os())); - } - - // Now that we have all of the passes ready, run them. - Passes.run(*M.get()); - - // Declare success. - if (!NoOutput) - Out->keep(); - - return 0; -} |
