X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fopt%2Fopt.cpp;h=abfeace376b2fe3b5263055362edebbe8cc1de4b;hb=358ab1dbb016c50528ada714fa400c821438f2ee;hp=4ef1a6e39c7fdfdbec9b4676dd9c538a90eb2313;hpb=d44ae90fc8974e01ac672af2816516639ff106ef;p=oota-llvm.git diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index 4ef1a6e39c7..abfeace376b 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -2,8 +2,8 @@ // // 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 is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -12,12 +12,16 @@ // //===----------------------------------------------------------------------===// +#include "llvm/LLVMContext.h" #include "llvm/Module.h" +#include "llvm/ModuleProvider.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" @@ -25,12 +29,11 @@ #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/PluginLoader.h" -#include "llvm/Support/Streams.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 -#include #include #include using namespace llvm; @@ -44,7 +47,7 @@ PassList(cl::desc("Optimizations available:")); // Other command line options... // static cl::opt -InputFilename(cl::Positional, cl::desc(""), +InputFilename(cl::Positional, cl::desc(""), cl::init("-"), cl::value_desc("filename")); static cl::opt @@ -59,7 +62,7 @@ PrintEachXForm("p", cl::desc("Print module after each transformation")); static cl::opt NoOutput("disable-output", - cl::desc("Do not write result bytecode file"), cl::Hidden); + cl::desc("Do not write result bitcode file"), cl::Hidden); static cl::opt NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden); @@ -82,6 +85,26 @@ static cl::opt StandardCompileOpts("std-compile-opts", cl::desc("Include the standard compile time optimizations")); +static cl::opt +OptLevelO1("O1", + cl::desc("Optimization level 1. Similar to llvm-gcc -O1")); + +static cl::opt +OptLevelO2("O2", + cl::desc("Optimization level 2. Similar to llvm-gcc -O2")); + +static cl::opt +OptLevelO3("O3", + cl::desc("Optimization level 3. Similar to llvm-gcc -O3")); + +static cl::opt +UnitAtATime("funit-at-a-time", + cl::desc("Enable IPO. This is same as llvm-gcc's -funit-at-a-time")); + +static cl::opt +DisableSimplifyLibCalls("disable-simplify-libcalls", + cl::desc("Disable simplify-libcalls")); + static cl::opt Quiet("q", cl::desc("Obsolete option"), cl::Hidden); @@ -94,16 +117,51 @@ AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization")); // ---------- Define Printers for module and function passes ------------ namespace { +struct CallGraphSCCPassPrinter : public CallGraphSCCPass { + static char ID; + const PassInfo *PassToPrint; + CallGraphSCCPassPrinter(const PassInfo *PI) : + CallGraphSCCPass(&ID), PassToPrint(PI) {} + + virtual bool runOnSCC(const std::vector&SCC) { + if (!Quiet) { + outs() << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + + for (unsigned i = 0, e = SCC.size(); i != e; ++i) { + Function *F = SCC[i]->getFunction(); + if (F) { + outs().flush(); + getAnalysisID(PassToPrint).print(cout, F->getParent()); + cout << std::flush; + } + } + } + // 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(); + } +}; + +char CallGraphSCCPassPrinter::ID = 0; + struct ModulePassPrinter : public ModulePass { static char ID; const PassInfo *PassToPrint; - ModulePassPrinter(const PassInfo *PI) : ModulePass((intptr_t)&ID), + ModulePassPrinter(const PassInfo *PI) : ModulePass(&ID), PassToPrint(PI) {} virtual bool runOnModule(Module &M) { if (!Quiet) { - cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + outs() << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + outs().flush(); getAnalysisID(PassToPrint).print(cout, &M); + cout << std::flush; } // Get and print pass... @@ -122,16 +180,18 @@ char ModulePassPrinter::ID = 0; struct FunctionPassPrinter : public FunctionPass { const PassInfo *PassToPrint; static char ID; - FunctionPassPrinter(const PassInfo *PI) : FunctionPass((intptr_t)&ID), + FunctionPassPrinter(const PassInfo *PI) : FunctionPass(&ID), PassToPrint(PI) {} virtual bool runOnFunction(Function &F) { if (!Quiet) { - cout << "Printing analysis '" << PassToPrint->getPassName() - << "' for function '" << F.getName() << "':\n"; + outs() << "Printing analysis '" << PassToPrint->getPassName() + << "' for function '" << F.getName() << "':\n"; } // Get and print pass... + outs().flush(); getAnalysisID(PassToPrint).print(cout, F.getParent()); + cout << std::flush; return false; } @@ -144,20 +204,51 @@ struct FunctionPassPrinter : public FunctionPass { }; char FunctionPassPrinter::ID = 0; + +struct LoopPassPrinter : public LoopPass { + static char ID; + const PassInfo *PassToPrint; + LoopPassPrinter(const PassInfo *PI) : + LoopPass(&ID), PassToPrint(PI) {} + + virtual bool runOnLoop(Loop *L, LPPassManager &LPM) { + if (!Quiet) { + outs() << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + outs().flush(); + getAnalysisID(PassToPrint).print(cout, + L->getHeader()->getParent()->getParent()); + cout << std::flush; + } + // 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(); + } +}; + +char LoopPassPrinter::ID = 0; + struct BasicBlockPassPrinter : public BasicBlockPass { const PassInfo *PassToPrint; static char ID; BasicBlockPassPrinter(const PassInfo *PI) - : BasicBlockPass((intptr_t)&ID), PassToPrint(PI) {} + : BasicBlockPass(&ID), PassToPrint(PI) {} virtual bool runOnBasicBlock(BasicBlock &BB) { if (!Quiet) { - cout << "Printing Analysis info for BasicBlock '" << BB.getName() - << "': Pass " << PassToPrint->getPassName() << ":\n"; + outs() << "Printing Analysis info for BasicBlock '" << BB.getName() + << "': Pass " << PassToPrint->getPassName() << ":\n"; } // Get and print pass... + outs().flush(); getAnalysisID(PassToPrint).print(cout, BB.getParent()->getParent()); + cout << std::flush; return false; } @@ -178,6 +269,25 @@ inline void addPass(PassManager &PM, Pass *P) { 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(PassManager &MPM, FunctionPassManager &FPM, + unsigned OptLevel) { + createStandardFunctionPasses(&FPM, OptLevel); + + llvm::Pass *InliningPass = OptLevel > 1 ? createFunctionInliningPass() : 0; + createStandardModulePasses(&MPM, OptLevel, + /*OptimizeSize=*/ false, + UnitAtATime, + /*UnrollLoops=*/ OptLevel > 1, + !DisableSimplifyLibCalls, + /*HaveExceptions=*/ true, + InliningPass); +} + void AddStandardCompilePasses(PassManager &PM) { PM.add(createVerifierPass()); // Verify that input is correct @@ -189,54 +299,16 @@ void AddStandardCompilePasses(PassManager &PM) { if (DisableOptimizations) return; - addPass(PM, createRaiseAllocationsPass()); // call %malloc -> malloc inst - addPass(PM, createCFGSimplificationPass()); // Clean up disgusting code - addPass(PM, createPromoteMemoryToRegisterPass());// Kill useless allocas - addPass(PM, createGlobalOptimizerPass()); // Optimize out global vars - addPass(PM, createGlobalDCEPass()); // Remove unused fns and globs - addPass(PM, createIPConstantPropagationPass());// IP Constant Propagation - addPass(PM, createDeadArgEliminationPass()); // Dead argument elimination - addPass(PM, createInstructionCombiningPass()); // Clean up after IPCP & DAE - addPass(PM, createCFGSimplificationPass()); // Clean up after IPCP & DAE - - addPass(PM, createPruneEHPass()); // Remove dead EH info - - if (!DisableInline) - addPass(PM, createFunctionInliningPass()); // Inline small functions - addPass(PM, createArgumentPromotionPass()); // Scalarize uninlined fn args - - addPass(PM, createTailDuplicationPass()); // Simplify cfg by copying code - addPass(PM, createInstructionCombiningPass()); // Cleanup for scalarrepl. - addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs - addPass(PM, createScalarReplAggregatesPass()); // Break up aggregate allocas - addPass(PM, createInstructionCombiningPass()); // Combine silly seq's - addPass(PM, createCondPropagationPass()); // Propagate conditionals - - addPass(PM, createTailCallEliminationPass()); // Eliminate tail calls - addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs - addPass(PM, createReassociatePass()); // Reassociate expressions - addPass(PM, createLoopRotatePass()); - addPass(PM, createLICMPass()); // Hoist loop invariants - addPass(PM, createLoopUnswitchPass()); // Unswitch loops. - addPass(PM, createInstructionCombiningPass()); // Clean up after LICM/reassoc - addPass(PM, createIndVarSimplifyPass()); // Canonicalize indvars - addPass(PM, createLoopUnrollPass()); // Unroll small loops - addPass(PM, createInstructionCombiningPass()); // Clean up after the unroller - addPass(PM, createLoadValueNumberingPass()); // GVN for load instructions - addPass(PM, createGCSEPass()); // Remove common subexprs - addPass(PM, createSCCPPass()); // Constant prop with SCCP - - // Run instcombine after redundancy elimination to exploit opportunities - // opened up by them. - addPass(PM, createInstructionCombiningPass()); - addPass(PM, createCondPropagationPass()); // Propagate conditionals - - addPass(PM, createDeadStoreEliminationPass()); // Delete dead stores - addPass(PM, createAggressiveDCEPass()); // SSA based 'Aggressive DCE' - addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs - addPass(PM, createSimplifyLibCallsPass()); // Library Call Optimizations - addPass(PM, createDeadTypeEliminationPass()); // Eliminate dead types - addPass(PM, createConstantMergePass()); // Merge dup global constants + 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); } } // anonymous namespace @@ -247,9 +319,10 @@ void AddStandardCompilePasses(PassManager &PM) { // int main(int argc, char **argv) { llvm_shutdown_obj X; // Call llvm_shutdown() on exit. + LLVMContext &Context = getGlobalContext(); try { cl::ParseCommandLineOptions(argc, argv, - " llvm .bc -> .bc modular optimizer and analysis printer \n"); + "llvm .bc -> .bc modular optimizer and analysis printer\n"); sys::PrintStackTraceOnErrorSignal(); // Allocate a full target machine description only if necessary. @@ -260,41 +333,33 @@ int main(int argc, char **argv) { // Load the input module... std::auto_ptr M; - MemoryBuffer *Buffer - = MemoryBuffer::getFileOrSTDIN(&InputFilename[0], InputFilename.size()); - - if (Buffer == 0) - ErrorMessage = "Error reading file '" + InputFilename + "'"; - else - M.reset(ParseBitcodeFile(Buffer, &ErrorMessage)); + if (MemoryBuffer *Buffer + = MemoryBuffer::getFileOrSTDIN(InputFilename, &ErrorMessage)) { + M.reset(ParseBitcodeFile(Buffer, Context, &ErrorMessage)); + delete Buffer; + } - delete Buffer; if (M.get() == 0) { - cerr << argv[0] << ": "; + errs() << argv[0] << ": "; if (ErrorMessage.size()) - cerr << ErrorMessage << "\n"; + errs() << ErrorMessage << "\n"; else - cerr << "bytecode didn't read correctly.\n"; + errs() << "bitcode didn't read correctly.\n"; return 1; } // Figure out what stream we are supposed to write to... - // FIXME: cout is not binary! - std::ostream *Out = &std::cout; // Default to printing to stdout... + // FIXME: outs() is not binary! + raw_ostream *Out = &outs(); // Default to printing to stdout... if (OutputFilename != "-") { - if (!Force && std::ifstream(OutputFilename.c_str())) { - // If force is not specified, make sure not to overwrite a file! - cerr << argv[0] << ": error opening '" << OutputFilename - << "': file exists!\n" - << "Use -f command line argument to force output\n"; - return 1; - } - std::ios::openmode io_mode = std::ios::out | std::ios::trunc | - std::ios::binary; - Out = new std::ofstream(OutputFilename.c_str(), io_mode); - - if (!Out->good()) { - cerr << argv[0] << ": error opening " << OutputFilename << "!\n"; + std::string ErrorInfo; + Out = new raw_fd_ostream(OutputFilename.c_str(), /*Binary=*/true, + Force, ErrorInfo); + if (!ErrorInfo.empty()) { + errs() << ErrorInfo << '\n'; + if (!Force) + errs() << "Use -f command line argument to force output\n"; + delete Out; return 1; } @@ -306,7 +371,7 @@ int main(int argc, char **argv) { // 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 && CheckBytecodeOutputToConsole(Out,!Quiet)) { + if (!Force && !NoOutput && CheckBitcodeOutputToConsole(Out,!Quiet)) { NoOutput = true; } @@ -318,62 +383,119 @@ int main(int argc, char **argv) { // Add an appropriate TargetData instance for this module... Passes.add(new TargetData(M.get())); - // If -std-compile-opts is given, add in all the standard compilation - // optimizations first. This will handle -strip-debug, -disable-inline, - // and -disable-opt as well. - if (StandardCompileOpts) - AddStandardCompilePasses(Passes); - - // otherwise if the -strip-debug command line option was specified, add it. - else if (StripDebug) + FunctionPassManager *FPasses = NULL; + if (OptLevelO1 || OptLevelO2 || OptLevelO3) { + FPasses = new FunctionPassManager(new ExistingModuleProvider(M.get())); + FPasses->add(new TargetData(M.get())); + } + + // 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 (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 - cerr << argv[0] << ": cannot create pass: " - << PassInf->getPassName() << "\n"; + errs() << argv[0] << ": cannot create pass: " + << PassInf->getPassName() << "\n"; if (P) { + bool isBBPass = dynamic_cast(P) != 0; + bool isLPass = !isBBPass && dynamic_cast(P) != 0; + bool isFPass = !isLPass && dynamic_cast(P) != 0; + bool isCGSCCPass = !isFPass && dynamic_cast(P) != 0; + addPass(Passes, P); - + if (AnalyzeOnly) { - if (dynamic_cast(P)) + if (isBBPass) Passes.add(new BasicBlockPassPrinter(PassInf)); - else if (dynamic_cast(P)) + else if (isLPass) + Passes.add(new LoopPassPrinter(PassInf)); + else if (isFPass) Passes.add(new FunctionPassPrinter(PassInf)); + else if (isCGSCCPass) + Passes.add(new CallGraphSCCPassPrinter(PassInf)); else Passes.add(new ModulePassPrinter(PassInf)); } } if (PrintEachXForm) - Passes.add(new PrintModulePass(&cerr)); + 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 (OptLevelO1) { + AddOptimizationPasses(Passes, *FPasses, 1); + } + + if (OptLevelO2) { + AddOptimizationPasses(Passes, *FPasses, 2); + } + + if (OptLevelO3) { + AddOptimizationPasses(Passes, *FPasses, 3); + } + + if (OptLevelO1 || OptLevelO2 || OptLevelO3) { + for (Module::iterator I = M.get()->begin(), E = M.get()->end(); + I != E; ++I) + FPasses->run(*I); } // Check that the module is well formed on completion of optimization if (!NoVerify && !VerifyEach) Passes.add(createVerifierPass()); - // Write bytecode out to disk or cout as the last step... + // Write bitcode out to disk or outs() as the last step... if (!NoOutput && !AnalyzeOnly) - Passes.add(CreateBitcodeWriterPass(*Out)); + Passes.add(createBitcodeWriterPass(*Out)); // Now that we have all of the passes ready, run them. Passes.run(*M.get()); - // Delete the ofstream. - if (Out != &std::cout) + // Delete the raw_fd_ostream. + if (Out != &outs()) delete Out; return 0; } catch (const std::string& msg) { - cerr << argv[0] << ": " << msg << "\n"; + errs() << argv[0] << ": " << msg << "\n"; } catch (...) { - cerr << argv[0] << ": Unexpected unknown exception occurred.\n"; + errs() << argv[0] << ": Unexpected unknown exception occurred.\n"; } llvm_shutdown(); return 1;