X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fopt%2Fopt.cpp;h=25474c44a6ef0bbc754056b939c14b86db5fc827;hb=8b9df62d0227beab8c7adb487fb909e67bbc7237;hp=92346f25f4f68502a57cbe5859467aa3e5d6c60d;hpb=2d7551ced2ddfe4b8e7adf9eb7f12e32537abaef;p=oota-llvm.git diff --git a/tools/opt/opt.cpp b/tools/opt/opt.cpp index 92346f25f4f..25474c44a6e 100644 --- a/tools/opt/opt.cpp +++ b/tools/opt/opt.cpp @@ -12,28 +12,34 @@ // //===----------------------------------------------------------------------===// +#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/DebugInfo.h" #include "llvm/Analysis/Verifier.h" #include "llvm/Analysis/LoopPass.h" +#include "llvm/Analysis/RegionPass.h" #include "llvm/Analysis/CallGraph.h" #include "llvm/Target/TargetData.h" +#include "llvm/Target/TargetLibraryInfo.h" #include "llvm/Target/TargetMachine.h" +#include "llvm/ADT/StringSet.h" +#include "llvm/ADT/Triple.h" #include "llvm/Support/PassNameParser.h" -#include "llvm/System/Signals.h" +#include "llvm/Support/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/Streams.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/StandardPasses.h" #include "llvm/Support/SystemUtils.h" +#include "llvm/Support/ToolOutputFile.h" #include "llvm/LinkAllPasses.h" #include "llvm/LinkAllVMCore.h" -#include -#include #include #include using namespace llvm; @@ -47,15 +53,15 @@ 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 OutputFilename("o", cl::desc("Override output filename"), - cl::value_desc("filename"), cl::init("-")); + cl::value_desc("filename")); 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 +70,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,33 +86,42 @@ 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")); static cl::opt OptLevelO2("O2", - cl::desc("Optimization level 1. Similar to llvm-gcc -O2")); + cl::desc("Optimization level 2. Similar to llvm-gcc -O2")); static cl::opt OptLevelO3("O3", - cl::desc("Optimization level 1. Similar to llvm-gcc -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 is 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", - cl::desc("Disable simplify libcalls")); + cl::desc("Disable simplify-libcalls")); static cl::opt Quiet("q", cl::desc("Obsolete option"), cl::Hidden); @@ -114,33 +132,48 @@ 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 +PrintBreakpoints("print-breakpoints-for-testing", + cl::desc("Print select breakpoints location for testing")); + +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) : - CallGraphSCCPass((intptr_t)&ID), PassToPrint(PI) {} - - virtual bool runOnSCC(const std::vector&SCC) { - if (!Quiet) { - cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + raw_ostream &Out; + std::string PassName; - for (unsigned i = 0, e = SCC.size(); i != e; ++i) { - Function *F = SCC[i]->getFunction(); - if (F) - getAnalysisID(PassToPrint).print(cout, F->getParent()); - } + CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out) : + CallGraphSCCPass(ID), PassToPrint(PI), Out(out) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "CallGraphSCCPass Printer: " + PassToPrintName; } + + virtual bool runOnSCC(CallGraphSCC &SCC) { + if (!Quiet) + Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + // Get and print pass... + for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { + Function *F = (*I)->getFunction(); + if (F) + getAnalysisID(PassToPrint->getTypeInfo()).print(Out, + F->getParent()); + } return false; } - - virtual const char *getPassName() const { return "'Pass' Printer"; } + + virtual const char *getPassName() const { return PassName.c_str(); } virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint); + AU.addRequiredID(PassToPrint->getTypeInfo()); AU.setPreservesAll(); } }; @@ -150,23 +183,28 @@ char CallGraphSCCPassPrinter::ID = 0; struct ModulePassPrinter : public ModulePass { static char ID; const PassInfo *PassToPrint; - ModulePassPrinter(const PassInfo *PI) : ModulePass((intptr_t)&ID), - PassToPrint(PI) {} + raw_ostream &Out; + std::string PassName; - virtual bool runOnModule(Module &M) { - if (!Quiet) { - cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; - getAnalysisID(PassToPrint).print(cout, &M); + ModulePassPrinter(const PassInfo *PI, raw_ostream &out) + : ModulePass(ID), PassToPrint(PI), Out(out) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "ModulePass Printer: " + PassToPrintName; } + virtual bool runOnModule(Module &M) { + if (!Quiet) + Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + // Get and print pass... + getAnalysisID(PassToPrint->getTypeInfo()).print(Out, &M); return false; } - virtual const char *getPassName() const { return "'Pass' Printer"; } + virtual const char *getPassName() const { return PassName.c_str(); } virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint); + AU.addRequiredID(PassToPrint->getTypeInfo()); AU.setPreservesAll(); } }; @@ -174,24 +212,31 @@ struct ModulePassPrinter : public ModulePass { char ModulePassPrinter::ID = 0; struct FunctionPassPrinter : public FunctionPass { const PassInfo *PassToPrint; + raw_ostream &Out; static char ID; - FunctionPassPrinter(const PassInfo *PI) : FunctionPass((intptr_t)&ID), - PassToPrint(PI) {} + std::string PassName; - virtual bool runOnFunction(Function &F) { - if (!Quiet) { - cout << "Printing analysis '" << PassToPrint->getPassName() - << "' for function '" << F.getName() << "':\n"; + FunctionPassPrinter(const PassInfo *PI, raw_ostream &out) + : FunctionPass(ID), PassToPrint(PI), Out(out) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "FunctionPass Printer: " + PassToPrintName; } + + virtual bool runOnFunction(Function &F) { + if (!Quiet) + Out << "Printing analysis '" << PassToPrint->getPassName() + << "' for function '" << F.getName() << "':\n"; + // Get and print pass... - getAnalysisID(PassToPrint).print(cout, F.getParent()); + getAnalysisID(PassToPrint->getTypeInfo()).print(Out, + F.getParent()); return false; } - virtual const char *getPassName() const { return "FunctionPass Printer"; } + virtual const char *getPassName() const { return PassName.c_str(); } virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint); + AU.addRequiredID(PassToPrint->getTypeInfo()); AU.setPreservesAll(); } }; @@ -201,56 +246,151 @@ char FunctionPassPrinter::ID = 0; struct LoopPassPrinter : public LoopPass { static char ID; const PassInfo *PassToPrint; - LoopPassPrinter(const PassInfo *PI) : - LoopPass((intptr_t)&ID), PassToPrint(PI) {} + raw_ostream &Out; + std::string PassName; + + LoopPassPrinter(const PassInfo *PI, raw_ostream &out) : + LoopPass(ID), PassToPrint(PI), Out(out) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "LoopPass Printer: " + PassToPrintName; + } + virtual bool runOnLoop(Loop *L, LPPassManager &LPM) { + if (!Quiet) + Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; + + // Get and print pass... + getAnalysisID(PassToPrint->getTypeInfo()).print(Out, + L->getHeader()->getParent()->getParent()); + return false; + } + + virtual const char *getPassName() const { return PassName.c_str(); } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.addRequiredID(PassToPrint->getTypeInfo()); + AU.setPreservesAll(); + } +}; + +char LoopPassPrinter::ID = 0; + +struct RegionPassPrinter : public RegionPass { + static char ID; + const PassInfo *PassToPrint; + raw_ostream &Out; + std::string PassName; + + RegionPassPrinter(const PassInfo *PI, raw_ostream &out) : RegionPass(ID), + PassToPrint(PI), Out(out) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "RegionPass Printer: " + PassToPrintName; + } + + virtual bool runOnRegion(Region *R, RGPassManager &RGM) { if (!Quiet) { - cout << "Printing analysis '" << PassToPrint->getPassName() << "':\n"; - getAnalysisID(PassToPrint).print(cout, - L->getHeader()->getParent()->getParent()); + Out << "Printing analysis '" << PassToPrint->getPassName() << "' for " + << "region: '" << R->getNameStr() << "' in function '" + << R->getEntry()->getParent()->getNameStr() << "':\n"; } // Get and print pass... + getAnalysisID(PassToPrint->getTypeInfo()).print(Out, + R->getEntry()->getParent()->getParent()); return false; } - - virtual const char *getPassName() const { return "'Pass' Printer"; } + + virtual const char *getPassName() const { return PassName.c_str(); } virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint); + AU.addRequiredID(PassToPrint->getTypeInfo()); AU.setPreservesAll(); } }; -char LoopPassPrinter::ID = 0; +char RegionPassPrinter::ID = 0; struct BasicBlockPassPrinter : public BasicBlockPass { const PassInfo *PassToPrint; + raw_ostream &Out; static char ID; - BasicBlockPassPrinter(const PassInfo *PI) - : BasicBlockPass((intptr_t)&ID), PassToPrint(PI) {} + std::string PassName; - virtual bool runOnBasicBlock(BasicBlock &BB) { - if (!Quiet) { - cout << "Printing Analysis info for BasicBlock '" << BB.getName() - << "': Pass " << PassToPrint->getPassName() << ":\n"; + BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out) + : BasicBlockPass(ID), PassToPrint(PI), Out(out) { + std::string PassToPrintName = PassToPrint->getPassName(); + PassName = "BasicBlockPass Printer: " + PassToPrintName; } + virtual bool runOnBasicBlock(BasicBlock &BB) { + if (!Quiet) + Out << "Printing Analysis info for BasicBlock '" << BB.getName() + << "': Pass " << PassToPrint->getPassName() << ":\n"; + // Get and print pass... - getAnalysisID(PassToPrint).print(cout, BB.getParent()->getParent()); + getAnalysisID(PassToPrint->getTypeInfo()).print(Out, + BB.getParent()->getParent()); return false; } - virtual const char *getPassName() const { return "BasicBlockPass Printer"; } + virtual const char *getPassName() const { return PassName.c_str(); } virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.addRequiredID(PassToPrint); + AU.addRequiredID(PassToPrint->getTypeInfo()); AU.setPreservesAll(); } }; char BasicBlockPassPrinter::ID = 0; -inline void addPass(PassManager &PM, Pass *P) { + +struct BreakpointPrinter : public ModulePass { + raw_ostream &Out; + static char ID; + + BreakpointPrinter(raw_ostream &out) + : ModulePass(ID), Out(out) { + } + + void getContextName(DIDescriptor Context, std::string &N) { + if (Context.isNameSpace()) { + DINameSpace NS(Context); + if (!NS.getName().empty()) { + getContextName(NS.getContext(), N); + N = N + NS.getName().str() + "::"; + } + } else if (Context.isType()) { + DIType TY(Context); + if (!TY.getName().empty()) { + getContextName(TY.getContext(), N); + N = N + TY.getName().str() + "::"; + } + } + } + + virtual bool runOnModule(Module &M) { + StringSet<> Processed; + if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp")) + for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { + std::string Name; + DISubprogram SP(NMD->getOperand(i)); + if (SP.Verify()) + getContextName(SP.getContext(), Name); + Name = Name + SP.getDisplayName().str(); + if (!Name.empty() && Processed.insert(Name)) { + Out << Name << "\n"; + } + } + return false; + } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + } +}; + +char BreakpointPrinter::ID = 0; + +inline void addPass(PassManagerBase &PM, Pass *P) { // Add the pass to the pass manager... PM.add(P); @@ -258,89 +398,36 @@ 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 -/// PruneEH - Add PruneEHPass, if set. -/// UnrollLoop - Unroll loops, if set. - void AddOptimizationPasses(PassManager &MPM, FunctionPassManager &FPM, - unsigned OptLevel) { - - if (OptLevel == 0) - return; - - FPM.add(createCFGSimplificationPass()); - if (OptLevel == 1) - FPM.add(createPromoteMemoryToRegisterPass()); - else - FPM.add(createScalarReplAggregatesPass()); - FPM.add(createInstructionCombiningPass()); - - if (UnitAtATime) - MPM.add(createRaiseAllocationsPass()); // call %malloc -> malloc inst - MPM.add(createCFGSimplificationPass()); // Clean up disgusting code - MPM.add(createPromoteMemoryToRegisterPass()); // Kill useless allocas - if (UnitAtATime) { - MPM.add(createGlobalOptimizerPass()); // OptLevel out global vars - MPM.add(createGlobalDCEPass()); // Remove unused fns and globs - MPM.add(createIPConstantPropagationPass()); // IP Constant Propagation - MPM.add(createDeadArgEliminationPass()); // Dead argument elimination - } - MPM.add(createInstructionCombiningPass()); // Clean up after IPCP & DAE - MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE - if (UnitAtATime) - MPM.add(createPruneEHPass()); // Remove dead EH info - if (OptLevel > 1) - MPM.add(createFunctionInliningPass()); // Inline small functions - if (OptLevel > 2) - MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args - if (!DisableSimplifyLibCalls) - MPM.add(createSimplifyLibCallsPass()); // Library Call Optimizations - MPM.add(createInstructionCombiningPass()); // Cleanup for scalarrepl. - MPM.add(createJumpThreadingPass()); // Thread jumps. - MPM.add(createCFGSimplificationPass()); // Merge & remove BBs - MPM.add(createScalarReplAggregatesPass()); // Break up aggregate allocas - MPM.add(createInstructionCombiningPass()); // Combine silly seq's - MPM.add(createCondPropagationPass()); // Propagate conditionals - MPM.add(createTailCallEliminationPass()); // Eliminate tail calls - MPM.add(createCFGSimplificationPass()); // Merge & remove BBs - MPM.add(createReassociatePass()); // Reassociate expressions - MPM.add(createLoopRotatePass()); // Rotate Loop - MPM.add(createLICMPass()); // Hoist loop invariants - MPM.add(createLoopUnswitchPass()); - MPM.add(createLoopIndexSplitPass()); // Split loop index - MPM.add(createInstructionCombiningPass()); - MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars - MPM.add(createLoopDeletionPass()); // Delete dead loops - if (OptLevel > 1) - MPM.add(createLoopUnrollPass()); // Unroll small loops - MPM.add(createInstructionCombiningPass()); // Clean up after the unroller - MPM.add(createGVNPass()); // Remove redundancies - MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset - MPM.add(createSCCPPass()); // Constant prop with SCCP - - // Run instcombine after redundancy elimination to exploit opportunities - // opened up by them. - MPM.add(createInstructionCombiningPass()); - MPM.add(createCondPropagationPass()); // Propagate conditionals - MPM.add(createDeadStoreEliminationPass()); // Delete dead stores - MPM.add(createAggressiveDCEPass()); // Delete dead instructions - MPM.add(createCFGSimplificationPass()); // Merge & remove BBs - - if (UnitAtATime) { - MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes - MPM.add(createDeadTypeEliminationPass()); // Eliminate dead types +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 = 225; + if (OptLevel > 2) + Threshold = 275; + InliningPass = createFunctionInliningPass(Threshold); + } else { + InliningPass = createAlwaysInlinerPass(); } - - if (OptLevel > 1 && UnitAtATime) - MPM.add(createConstantMergePass()); // Merge dup global constants - - return; + createStandardModulePasses(&MPM, OptLevel, + /*OptimizeSize=*/ false, + UnitAtATime, + /*UnrollLoops=*/ OptLevel > 1, + !DisableSimplifyLibCalls, + /*HaveExceptions=*/ true, + InliningPass); } -void AddStandardCompilePasses(PassManager &PM) { +void AddStandardCompilePasses(PassManagerBase &PM) { PM.add(createVerifierPass()); // Verify that input is correct addPass(PM, createLowerSetJmpPass()); // Lower llvm.setjmp/.longjmp @@ -351,58 +438,30 @@ 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, createSimplifyLibCallsPass()); // Library Call Optimizations - addPass(PM, createInstructionCombiningPass()); // Cleanup for scalarrepl. - addPass(PM, createJumpThreadingPass()); // Thread jumps. - 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, createLoopIndexSplitPass()); // Index split loops. - // FIXME : Removing instcombine causes nestedloop regression. - addPass(PM, createInstructionCombiningPass()); - addPass(PM, createIndVarSimplifyPass()); // Canonicalize indvars - addPass(PM, createLoopDeletionPass()); // Delete dead loops - addPass(PM, createLoopUnrollPass()); // Unroll small loops - addPass(PM, createInstructionCombiningPass()); // Clean up after the unroller - addPass(PM, createGVNPass()); // Remove redundancies - addPass(PM, createMemCpyOptPass()); // Remove memcpy / form memset - 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()); // Delete dead instructions - addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs - addPass(PM, createStripDeadPrototypesPass()); // Get rid of dead prototypes - 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, + !DisableSimplifyLibCalls, + /*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 @@ -412,184 +471,245 @@ void AddStandardCompilePasses(PassManager &PM) { // main for opt // int main(int argc, char **argv) { - llvm_shutdown_obj X; // Call llvm_shutdown() on exit. - 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, &ErrorMessage)); - delete Buffer; - } - - if (M.get() == 0) { - cerr << argv[0] << ": "; - if (ErrorMessage.size()) - cerr << ErrorMessage << "\n"; - else - cerr << "bitcode didn't read correctly.\n"; + 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(); + + // Initialize passes + PassRegistry &Registry = *PassRegistry::getPassRegistry(); + initializeCore(Registry); + initializeScalarOpts(Registry); + initializeIPO(Registry); + initializeAnalysis(Registry); + initializeIPA(Registry); + initializeTransformUtils(Registry); + initializeInstCombine(Registry); + initializeInstrumentation(Registry); + initializeTarget(Registry); + + cl::ParseCommandLineOptions(argc, argv, + "llvm .bc -> .bc modular optimizer and analysis printer\n"); + + if (AnalyzeOnly && NoOutput) { + errs() << argv[0] << ": analyze mode conflicts with no-output mode.\n"; + return 1; + } + + // 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... + OwningPtr 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; } + } - // 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... - 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 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 TargetLibraryInfo pass for the module's triple. + TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple())); + + // The -disable-simplify-libcalls flag actually disables all builtin optzns. + if (DisableSimplifyLibCalls) + TLI->disableAllFunctions(); + Passes.add(TLI); + + // 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 FPasses; + if (OptLevelO1 || OptLevelO2 || OptLevelO3) { + FPasses.reset(new PassManager()); + if (TD) + FPasses->add(new TargetData(*TD)); + } - if (!Out->good()) { - cerr << argv[0] << ": error opening " << OutputFilename << "!\n"; + if (PrintBreakpoints) { + // Default to standard output. + if (!Out) { + 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; } - - // Make sure that the Output file gets unlinked from the disk if we get a - // SIGINT - sys::RemoveFileOnSignal(sys::Path(OutputFilename)); } + Passes.add(new BreakpointPrinter(Out->os())); + NoOutput = true; + } - // 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)) { - NoOutput = true; + // 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; } - // 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(M.get())); + if (StandardLinkOpts && + StandardLinkOpts.getPosition() < PassList.getPosition(i)) { + AddStandardLinkPasses(Passes); + StandardLinkOpts = false; + } - FunctionPassManager *FPasses = NULL; - if (OptLevelO1 || OptLevelO2 || OptLevelO3) { - FPasses = new FunctionPassManager(new ExistingModuleProvider(M.get())); - FPasses->add(new TargetData(M.get())); + if (OptLevelO1 && OptLevelO1.getPosition() < PassList.getPosition(i)) { + AddOptimizationPasses(Passes, *FPasses, 1); + OptLevelO1 = 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 (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; - } + 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: " + 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) { - if (dynamic_cast(P)) - Passes.add(new BasicBlockPassPrinter(PassInf)); - else if (dynamic_cast(P)) - Passes.add(new LoopPassPrinter(PassInf)); - else if (dynamic_cast(P)) - Passes.add(new FunctionPassPrinter(PassInf)); - else if (dynamic_cast(P)) - Passes.add(new CallGraphSCCPassPrinter(PassInf)); - else - Passes.add(new ModulePassPrinter(PassInf)); + 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_Region: + Passes.add(new RegionPassPrinter(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(new PrintModulePass(&cerr)); } - - // 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 cout 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->run(*M.get()); - // Delete the ofstream. - if (Out != &std::cout) - 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) { - cerr << argv[0] << ": " << msg << "\n"; - } catch (...) { - cerr << argv[0] << ": Unexpected unknown exception occurred.\n"; + // 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())); } - llvm_shutdown(); - return 1; + + // Before executing passes, print the final values of the LLVM options. + cl::PrintOptionValues(); + + // Now that we have all of the passes ready, run them. + Passes.run(*M.get()); + + // Declare success. + if (!NoOutput || PrintBreakpoints) + Out->keep(); + + return 0; }