X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=tools%2Fopt%2Fopt.cpp;h=520018005f12f535a5f8f7fef21e295be7dcac14;hp=abfeace376b2fe3b5263055362edebbe8cc1de4b;hb=f0356fe140af1a30587b9a86bcfb1b2c51b8ce20;hpb=ac95cc79ac0b899d566cc29c0f646f39c2fa35c0 diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index abfeace376b..520018005f1 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -14,7 +14,6 @@ #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" @@ -26,9 +25,12 @@ #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/MemoryBuffer.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" @@ -47,7 +49,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 @@ -55,7 +57,7 @@ OutputFilename("o", cl::desc("Override output filename"), cl::value_desc("filename"), cl::init("-")); static cl::opt -Force("f", cl::desc("Overwrite output files")); +Force("f", cl::desc("Enable binary output on terminals")); static cl::opt PrintEachXForm("p", cl::desc("Print module after each transformation")); @@ -64,6 +66,9 @@ static cl::opt NoOutput("disable-output", cl::desc("Do not write result bitcode file"), cl::Hidden); +static cl::opt +OutputAssembly("S", cl::desc("Write output as LLVM assembly")); + static cl::opt NoVerify("disable-verify", cl::desc("Do not verify result module"), cl::Hidden); @@ -77,14 +82,22 @@ StripDebug("strip-debug", static cl::opt DisableInline("disable-inlining", cl::desc("Do not run the inliner pass")); -static cl::opt -DisableOptimizations("disable-opt", +static cl::opt +DisableOptimizations("disable-opt", cl::desc("Do not run any optimization passes")); static cl::opt -StandardCompileOpts("std-compile-opts", +DisableInternalize("disable-internalize", + cl::desc("Do not mark all symbols as internal")); + +static cl::opt +StandardCompileOpts("std-compile-opts", cl::desc("Include the standard compile time optimizations")); +static cl::opt +StandardLinkOpts("std-link-opts", + cl::desc("Include the standard link time optimizations")); + static cl::opt OptLevelO1("O1", cl::desc("Optimization level 1. Similar to llvm-gcc -O1")); @@ -99,7 +112,8 @@ OptLevelO3("O3", static cl::opt UnitAtATime("funit-at-a-time", - cl::desc("Enable IPO. This is same as llvm-gcc's -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 DisableSimplifyLibCalls("disable-simplify-libcalls", @@ -114,32 +128,35 @@ QuietA("quiet", cl::desc("Alias for -q"), cl::aliasopt(Quiet)); static cl::opt AnalyzeOnly("analyze", cl::desc("Only perform analysis, no optimization")); +static cl::opt +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; - CallGraphSCCPassPrinter(const PassInfo *PI) : + CallGraphSCCPassPrinter(const PassInfo *PI) : CallGraphSCCPass(&ID), PassToPrint(PI) {} - virtual bool runOnSCC(const std::vector&SCC) { + virtual bool runOnSCC(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; + getAnalysisID(PassToPrint).print(outs(), F->getParent()); } } } // Get and print pass... return false; } - + virtual const char *getPassName() const { return "'Pass' Printer"; } virtual void getAnalysisUsage(AnalysisUsage &AU) const { @@ -159,9 +176,7 @@ struct ModulePassPrinter : public ModulePass { virtual bool runOnModule(Module &M) { if (!Quiet) { outs() << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; - outs().flush(); - getAnalysisID(PassToPrint).print(cout, &M); - cout << std::flush; + getAnalysisID(PassToPrint).print(outs(), &M); } // Get and print pass... @@ -184,14 +199,12 @@ struct FunctionPassPrinter : public FunctionPass { PassToPrint(PI) {} virtual bool runOnFunction(Function &F) { - if (!Quiet) { + if (!Quiet) { 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; + getAnalysisID(PassToPrint).print(outs(), F.getParent()); return false; } @@ -208,21 +221,19 @@ char FunctionPassPrinter::ID = 0; struct LoopPassPrinter : public LoopPass { static char ID; const PassInfo *PassToPrint; - LoopPassPrinter(const PassInfo *PI) : + 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, + getAnalysisID(PassToPrint).print(outs(), 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 { @@ -236,7 +247,7 @@ char LoopPassPrinter::ID = 0; struct BasicBlockPassPrinter : public BasicBlockPass { const PassInfo *PassToPrint; static char ID; - BasicBlockPassPrinter(const PassInfo *PI) + BasicBlockPassPrinter(const PassInfo *PI) : BasicBlockPass(&ID), PassToPrint(PI) {} virtual bool runOnBasicBlock(BasicBlock &BB) { @@ -246,9 +257,7 @@ struct BasicBlockPassPrinter : public BasicBlockPass { } // Get and print pass... - outs().flush(); - getAnalysisID(PassToPrint).print(cout, BB.getParent()->getParent()); - cout << std::flush; + getAnalysisID(PassToPrint).print(outs(), BB.getParent()->getParent()); return false; } @@ -269,8 +278,8 @@ 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 +/// AddOptimizationPasses - This routine adds optimization passes +/// based on selected optimization level, OptLevel. This routine /// duplicates llvm-gcc behaviour. /// /// OptLevel - Optimization Level @@ -278,7 +287,17 @@ void AddOptimizationPasses(PassManager &MPM, FunctionPassManager &FPM, unsigned OptLevel) { createStandardFunctionPasses(&FPM, OptLevel); - llvm::Pass *InliningPass = OptLevel > 1 ? createFunctionInliningPass() : 0; + 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, @@ -302,7 +321,7 @@ void AddStandardCompilePasses(PassManager &PM) { llvm::Pass *InliningPass = !DisableInline ? createFunctionInliningPass() : 0; // -std-compile-opts adds the same module passes as -O3. - createStandardModulePasses(&PM, 3, + createStandardModulePasses(&PM, 3, /*OptimizeSize=*/ false, /*UnitAtATime=*/ true, /*UnrollLoops=*/ true, @@ -311,6 +330,20 @@ void AddStandardCompilePasses(PassManager &PM) { InliningPass); } +void AddStandardLinkPasses(PassManager &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 @@ -318,185 +351,201 @@ void AddStandardCompilePasses(PassManager &PM) { // main for opt // int main(int argc, char **argv) { - llvm_shutdown_obj X; // Call llvm_shutdown() on exit. + sys::PrintStackTraceOnErrorSignal(); + llvm::PrettyStackTraceProgram X(argc, argv); + + // Enable debug stream buffering. + EnableDebugBuffering = true; + + llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. LLVMContext &Context = getGlobalContext(); - try { - cl::ParseCommandLineOptions(argc, argv, - "llvm .bc -> .bc modular optimizer and analysis printer\n"); - sys::PrintStackTraceOnErrorSignal(); - - // Allocate a full target machine description only if necessary. - // FIXME: The choice of target should be controllable on the command line. - std::auto_ptr target; - - std::string ErrorMessage; - - // Load the input module... - std::auto_ptr M; - if (MemoryBuffer *Buffer - = MemoryBuffer::getFileOrSTDIN(InputFilename, &ErrorMessage)) { - M.reset(ParseBitcodeFile(Buffer, Context, &ErrorMessage)); - delete Buffer; - } - - if (M.get() == 0) { - errs() << argv[0] << ": "; - if (ErrorMessage.size()) - errs() << ErrorMessage << "\n"; - else - errs() << "bitcode didn't read correctly.\n"; - return 1; - } + + 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 target; + + SMDiagnostic Err; + + // Load the input module... + std::auto_ptr 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... + // FIXME: outs() is not binary! + raw_ostream *Out = &outs(); // Default to printing to stdout... + if (OutputFilename != "-") { + if (NoOutput || AnalyzeOnly) { + errs() << "WARNING: The -o (output filename) option is ignored when\n" + "the --disable-output or --analyze options are used.\n"; + } else { + // Make sure that the Output file gets unlinked from the disk if we get a + // SIGINT + sys::RemoveFileOnSignal(sys::Path(OutputFilename)); - // Figure out what stream we are supposed to write to... - // FIXME: outs() is not binary! - raw_ostream *Out = &outs(); // Default to printing to stdout... - if (OutputFilename != "-") { std::string ErrorInfo; - Out = new raw_fd_ostream(OutputFilename.c_str(), /*Binary=*/true, - Force, ErrorInfo); + Out = new raw_fd_ostream(OutputFilename.c_str(), ErrorInfo, + raw_fd_ostream::F_Binary); if (!ErrorInfo.empty()) { errs() << ErrorInfo << '\n'; - if (!Force) - errs() << "Use -f command line argument to force output\n"; delete Out; return 1; } - - // Make sure that the Output file gets unlinked from the disk if we get a - // SIGINT - sys::RemoveFileOnSignal(sys::Path(OutputFilename)); } + } - // 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 && CheckBitcodeOutputToConsole(Out,!Quiet)) { + // 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, !Quiet)) NoOutput = true; - } - // Create a PassManager to hold and optimize the collection of passes we are - // about to build... - // - PassManager Passes; + // 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); + + FunctionPassManager *FPasses = NULL; + if (OptLevelO1 || OptLevelO2 || OptLevelO3) { + FPasses = new FunctionPassManager(M.get()); + if (TD) + FPasses->add(new TargetData(*TD)); + } - // Add an appropriate TargetData instance for this module... - Passes.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; + } - FunctionPassManager *FPasses = NULL; - if (OptLevelO1 || OptLevelO2 || OptLevelO3) { - FPasses = new FunctionPassManager(new ExistingModuleProvider(M.get())); - FPasses->add(new TargetData(M.get())); + if (StandardLinkOpts && + StandardLinkOpts.getPosition() < PassList.getPosition(i)) { + AddStandardLinkPasses(Passes); + StandardLinkOpts = false; } - - // 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 (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) { + AddOptimizationPasses(Passes, *FPasses, 1); + OptLevelO1 = false; + } - if (OptLevelO3 && OptLevelO3.getPosition() < PassList.getPosition(i)) { - AddOptimizationPasses(Passes, *FPasses, 3); - OptLevelO3 = 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) { - 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 (isBBPass) - Passes.add(new BasicBlockPassPrinter(PassInf)); - 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)); + 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) { + addPass(Passes, P); + + if (AnalyzeOnly) { + switch (P->getPassKind()) { + case PT_BasicBlock: + Passes.add(new BasicBlockPassPrinter(PassInf)); + break; + case PT_Loop: + Passes.add(new LoopPassPrinter(PassInf)); + break; + case PT_Function: + Passes.add(new FunctionPassPrinter(PassInf)); + break; + case PT_CallGraphSCC: + Passes.add(new CallGraphSCCPassPrinter(PassInf)); + break; + default: + Passes.add(new ModulePassPrinter(PassInf)); + 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 (OptLevelO1) { - AddOptimizationPasses(Passes, *FPasses, 1); - } + if (PrintEachXForm) + Passes.add(createPrintModulePass(&errs())); + } - if (OptLevelO2) { - AddOptimizationPasses(Passes, *FPasses, 2); - } + // If -std-compile-opts was specified at the end of the pass list, add them. + if (StandardCompileOpts) { + AddStandardCompilePasses(Passes); + StandardCompileOpts = false; + } - if (OptLevelO3) { - AddOptimizationPasses(Passes, *FPasses, 3); - } + if (StandardLinkOpts) { + AddStandardLinkPasses(Passes); + StandardLinkOpts = false; + } - if (OptLevelO1 || OptLevelO2 || OptLevelO3) { - for (Module::iterator I = M.get()->begin(), E = M.get()->end(); - I != E; ++I) - FPasses->run(*I); - } + if (OptLevelO1) + AddOptimizationPasses(Passes, *FPasses, 1); - // Check that the module is well formed on completion of optimization - if (!NoVerify && !VerifyEach) - Passes.add(createVerifierPass()); + if (OptLevelO2) + AddOptimizationPasses(Passes, *FPasses, 2); - // Write bitcode out to disk or outs() as the last step... - if (!NoOutput && !AnalyzeOnly) - Passes.add(createBitcodeWriterPass(*Out)); + if (OptLevelO3) + AddOptimizationPasses(Passes, *FPasses, 3); - // Now that we have all of the passes ready, run them. - Passes.run(*M.get()); + if (OptLevelO1 || OptLevelO2 || OptLevelO3) { + FPasses->doInitialization(); + for (Module::iterator I = M.get()->begin(), E = M.get()->end(); + I != E; ++I) + FPasses->run(*I); + } - // Delete the raw_fd_ostream. - if (Out != &outs()) - delete Out; - return 0; + // Check that the module is well formed on completion of optimization + if (!NoVerify && !VerifyEach) + Passes.add(createVerifierPass()); - } catch (const std::string& msg) { - errs() << argv[0] << ": " << msg << "\n"; - } catch (...) { - errs() << argv[0] << ": Unexpected unknown exception occurred.\n"; + // Write bitcode or assembly out to disk or outs() as the last step... + if (!NoOutput && !AnalyzeOnly) { + if (OutputAssembly) + Passes.add(createPrintModulePass(Out)); + else + Passes.add(createBitcodeWriterPass(*Out)); } - llvm_shutdown(); - return 1; + + // Now that we have all of the passes ready, run them. + Passes.run(*M.get()); + + // Delete the raw_fd_ostream. + if (Out != &outs()) + delete Out; + return 0; }