Optimize.cpp revision c8c5752b2fcc9131358905e7af75d51dd84861b9
1//===- Optimize.cpp - Optimize a complete program -------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by Reid Spencer and is distributed under the 6// University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements all optimization of the linked module for llvm-ld. 11// 12//===----------------------------------------------------------------------===// 13 14#include "llvm/Module.h" 15#include "llvm/PassManager.h" 16#include "llvm/Analysis/LoadValueNumbering.h" 17#include "llvm/Analysis/Passes.h" 18#include "llvm/Analysis/LoopPass.h" 19#include "llvm/Analysis/Verifier.h" 20#include "llvm/Support/CommandLine.h" 21#include "llvm/System/DynamicLibrary.h" 22#include "llvm/Target/TargetData.h" 23#include "llvm/Target/TargetMachine.h" 24#include "llvm/Transforms/IPO.h" 25#include "llvm/Transforms/Scalar.h" 26#include "llvm/Support/PassNameParser.h" 27#include "llvm/Support/PluginLoader.h" 28#include <iostream> 29using namespace llvm; 30 31// Pass Name Options as generated by the PassNameParser 32static cl::list<const PassInfo*, bool, PassNameParser> 33 OptimizationList(cl::desc("Optimizations available:")); 34 35// Optimization Enumeration 36enum OptimizationLevels { 37 OPT_FAST_COMPILE = 1, 38 OPT_SIMPLE = 2, 39 OPT_AGGRESSIVE = 3, 40 OPT_LINK_TIME = 4, 41 OPT_AGGRESSIVE_LINK_TIME = 5 42}; 43 44// Optimization Options 45static cl::opt<OptimizationLevels> OptLevel( 46 cl::desc("Choose level of optimization to apply:"), 47 cl::init(OPT_FAST_COMPILE), cl::values( 48 clEnumValN(OPT_FAST_COMPILE,"O0", 49 "An alias for the -O1 option."), 50 clEnumValN(OPT_FAST_COMPILE,"O1", 51 "Optimize for linking speed, not execution speed."), 52 clEnumValN(OPT_SIMPLE,"O2", 53 "Perform only required/minimal optimizations"), 54 clEnumValN(OPT_AGGRESSIVE,"O3", 55 "An alias for the -O2 option."), 56 clEnumValN(OPT_LINK_TIME,"O4", 57 "Perform standard link time optimizations"), 58 clEnumValN(OPT_AGGRESSIVE_LINK_TIME,"O5", 59 "Perform aggressive link time optimizations"), 60 clEnumValEnd 61 ) 62); 63 64static cl::opt<bool> DisableInline("disable-inlining", 65 cl::desc("Do not run the inliner pass")); 66 67static cl::opt<bool> 68DisableOptimizations("disable-opt", 69 cl::desc("Do not run any optimization passes")); 70 71static cl::opt<bool> DisableInternalize("disable-internalize", 72 cl::desc("Do not mark all symbols as internal")); 73 74static cl::opt<bool> VerifyEach("verify-each", 75 cl::desc("Verify intermediate results of all passes")); 76 77static cl::alias ExportDynamic("export-dynamic", 78 cl::aliasopt(DisableInternalize), 79 cl::desc("Alias for -disable-internalize")); 80 81static cl::opt<bool> Strip("strip-all", 82 cl::desc("Strip all symbol info from executable")); 83 84static cl::alias A0("s", cl::desc("Alias for --strip-all"), 85 cl::aliasopt(Strip)); 86 87static cl::opt<bool> StripDebug("strip-debug", 88 cl::desc("Strip debugger symbol info from executable")); 89 90static cl::alias A1("S", cl::desc("Alias for --strip-debug"), 91 cl::aliasopt(StripDebug)); 92 93// A utility function that adds a pass to the pass manager but will also add 94// a verifier pass after if we're supposed to verify. 95static inline void addPass(PassManager &PM, Pass *P) { 96 // Add the pass to the pass manager... 97 PM.add(P); 98 99 // If we are verifying all of the intermediate steps, add the verifier... 100 if (VerifyEach) 101 PM.add(createVerifierPass()); 102} 103 104namespace llvm { 105 106/// Optimize - Perform link time optimizations. This will run the scalar 107/// optimizations, any loaded plugin-optimization modules, and then the 108/// inter-procedural optimizations if applicable. 109void Optimize(Module* M) { 110 111 // Instantiate the pass manager to organize the passes. 112 PassManager Passes; 113 114 // If we're verifying, start off with a verification pass. 115 if (VerifyEach) 116 Passes.add(createVerifierPass()); 117 118 // Add an appropriate TargetData instance for this module... 119 addPass(Passes, new TargetData(M)); 120 121 if (!DisableOptimizations) { 122 // Now that composite has been compiled, scan through the module, looking 123 // for a main function. If main is defined, mark all other functions 124 // internal. 125 addPass(Passes, createInternalizePass(!DisableInternalize)); 126 127 // Propagate constants at call sites into the functions they call. This 128 // opens opportunities for globalopt (and inlining) by substituting function 129 // pointers passed as arguments to direct uses of functions. 130 addPass(Passes, createIPSCCPPass()); 131 132 // Now that we internalized some globals, see if we can hack on them! 133 addPass(Passes, createGlobalOptimizerPass()); 134 135 // Linking modules together can lead to duplicated global constants, only 136 // keep one copy of each constant... 137 addPass(Passes, createConstantMergePass()); 138 139 // Remove unused arguments from functions... 140 addPass(Passes, createDeadArgEliminationPass()); 141 142 // Reduce the code after globalopt and ipsccp. Both can open up significant 143 // simplification opportunities, and both can propagate functions through 144 // function pointers. When this happens, we often have to resolve varargs 145 // calls, etc, so let instcombine do this. 146 addPass(Passes, createInstructionCombiningPass()); 147 148 if (!DisableInline) 149 addPass(Passes, createFunctionInliningPass()); // Inline small functions 150 151 addPass(Passes, createPruneEHPass()); // Remove dead EH info 152 addPass(Passes, createGlobalOptimizerPass()); // Optimize globals again. 153 addPass(Passes, createGlobalDCEPass()); // Remove dead functions 154 155 // If we didn't decide to inline a function, check to see if we can 156 // transform it to pass arguments by value instead of by reference. 157 addPass(Passes, createArgumentPromotionPass()); 158 159 // The IPO passes may leave cruft around. Clean up after them. 160 addPass(Passes, createInstructionCombiningPass()); 161 162 addPass(Passes, createScalarReplAggregatesPass()); // Break up allocas 163 164 // Run a few AA driven optimizations here and now, to cleanup the code. 165 addPass(Passes, createGlobalsModRefPass()); // IP alias analysis 166 167 addPass(Passes, createLICMPass()); // Hoist loop invariants 168 addPass(Passes, createLoadValueNumberingPass()); // GVN for load instrs 169 addPass(Passes, createGCSEPass()); // Remove common subexprs 170 addPass(Passes, createDeadStoreEliminationPass()); // Nuke dead stores 171 172 // Cleanup and simplify the code after the scalar optimizations. 173 addPass(Passes, createInstructionCombiningPass()); 174 175 // Delete basic blocks, which optimization passes may have killed... 176 addPass(Passes, createCFGSimplificationPass()); 177 178 // Now that we have optimized the program, discard unreachable functions... 179 addPass(Passes, createGlobalDCEPass()); 180 } 181 182 // If the -s or -S command line options were specified, strip the symbols out 183 // of the resulting program to make it smaller. -s and -S are GNU ld options 184 // that we are supporting; they alias -strip-all and -strip-debug. 185 if (Strip || StripDebug) 186 addPass(Passes, createStripSymbolsPass(StripDebug && !Strip)); 187 188 // Create a new optimization pass for each one specified on the command line 189 std::auto_ptr<TargetMachine> target; 190 for (unsigned i = 0; i < OptimizationList.size(); ++i) { 191 const PassInfo *Opt = OptimizationList[i]; 192 if (Opt->getNormalCtor()) 193 addPass(Passes, Opt->getNormalCtor()()); 194 else 195 std::cerr << "llvm-ld: cannot create pass: " << Opt->getPassName() 196 << "\n"; 197 } 198 199 // The user's passes may leave cruft around. Clean up after them them but 200 // only if we haven't got DisableOptimizations set 201 if (!DisableOptimizations) { 202 addPass(Passes, createInstructionCombiningPass()); 203 addPass(Passes, createCFGSimplificationPass()); 204 addPass(Passes, createDeadCodeEliminationPass()); 205 addPass(Passes, createGlobalDCEPass()); 206 } 207 208 // Make sure everything is still good. 209 Passes.add(createVerifierPass()); 210 211 // Run our queue of passes all at once now, efficiently. 212 Passes.run(*M); 213} 214 215} 216