1 //===-- Scalar.h - Scalar Transformations -----------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This header file defines prototypes for accessor functions that expose passes 11 // in the Scalar transformations library. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_TRANSFORMS_SCALAR_H 16 #define LLVM_TRANSFORMS_SCALAR_H 17 18 namespace llvm { 19 20 class FunctionPass; 21 class Pass; 22 class GetElementPtrInst; 23 class PassInfo; 24 class TerminatorInst; 25 class TargetLowering; 26 27 //===----------------------------------------------------------------------===// 28 // 29 // ConstantPropagation - A worklist driven constant propagation pass 30 // 31 FunctionPass *createConstantPropagationPass(); 32 33 //===----------------------------------------------------------------------===// 34 // 35 // SCCP - Sparse conditional constant propagation. 36 // 37 FunctionPass *createSCCPPass(); 38 39 //===----------------------------------------------------------------------===// 40 // 41 // DeadInstElimination - This pass quickly removes trivially dead instructions 42 // without modifying the CFG of the function. It is a BasicBlockPass, so it 43 // runs efficiently when queued next to other BasicBlockPass's. 44 // 45 Pass *createDeadInstEliminationPass(); 46 47 //===----------------------------------------------------------------------===// 48 // 49 // DeadCodeElimination - This pass is more powerful than DeadInstElimination, 50 // because it is worklist driven that can potentially revisit instructions when 51 // their other instructions become dead, to eliminate chains of dead 52 // computations. 53 // 54 FunctionPass *createDeadCodeEliminationPass(); 55 56 //===----------------------------------------------------------------------===// 57 // 58 // DeadStoreElimination - This pass deletes stores that are post-dominated by 59 // must-aliased stores and are not loaded used between the stores. 60 // 61 FunctionPass *createDeadStoreEliminationPass(); 62 63 //===----------------------------------------------------------------------===// 64 // 65 // AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This 66 // algorithm assumes instructions are dead until proven otherwise, which makes 67 // it more successful are removing non-obviously dead instructions. 68 // 69 FunctionPass *createAggressiveDCEPass(); 70 71 //===----------------------------------------------------------------------===// 72 // 73 // ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas 74 // if possible. 75 // 76 FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1, 77 bool UseDomTree = true); 78 79 //===----------------------------------------------------------------------===// 80 // 81 // InductionVariableSimplify - Transform induction variables in a program to all 82 // use a single canonical induction variable per loop. 83 // 84 Pass *createIndVarSimplifyPass(); 85 86 //===----------------------------------------------------------------------===// 87 // 88 // InstructionCombining - Combine instructions to form fewer, simple 89 // instructions. This pass does not modify the CFG, and has a tendency to make 90 // instructions dead, so a subsequent DCE pass is useful. 91 // 92 // This pass combines things like: 93 // %Y = add int 1, %X 94 // %Z = add int 1, %Y 95 // into: 96 // %Z = add int 2, %X 97 // 98 FunctionPass *createInstructionCombiningPass(); 99 100 //===----------------------------------------------------------------------===// 101 // 102 // LICM - This pass is a loop invariant code motion and memory promotion pass. 103 // 104 Pass *createLICMPass(); 105 106 //===----------------------------------------------------------------------===// 107 // 108 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use 109 // a loop's canonical induction variable as one of their indices. It takes an 110 // optional parameter used to consult the target machine whether certain 111 // transformations are profitable. 112 // 113 Pass *createLoopStrengthReducePass(const TargetLowering *TLI = 0); 114 115 //===----------------------------------------------------------------------===// 116 // 117 // LoopUnswitch - This pass is a simple loop unswitching pass. 118 // 119 Pass *createLoopUnswitchPass(bool OptimizeForSize = false); 120 121 //===----------------------------------------------------------------------===// 122 // 123 // LoopInstSimplify - This pass simplifies instructions in a loop's body. 124 // 125 Pass *createLoopInstSimplifyPass(); 126 127 //===----------------------------------------------------------------------===// 128 // 129 // LoopUnroll - This pass is a simple loop unrolling pass. 130 // 131 Pass *createLoopUnrollPass(int Threshold = -1, int Count = -1, int AllowPartial = -1); 132 133 //===----------------------------------------------------------------------===// 134 // 135 // LoopRotate - This pass is a simple loop rotating pass. 136 // 137 Pass *createLoopRotatePass(); 138 139 //===----------------------------------------------------------------------===// 140 // 141 // LoopIdiom - This pass recognizes and replaces idioms in loops. 142 // 143 Pass *createLoopIdiomPass(); 144 145 //===----------------------------------------------------------------------===// 146 // 147 // PromoteMemoryToRegister - This pass is used to promote memory references to 148 // be register references. A simple example of the transformation performed by 149 // this pass is: 150 // 151 // FROM CODE TO CODE 152 // %X = alloca i32, i32 1 ret i32 42 153 // store i32 42, i32 *%X 154 // %Y = load i32* %X 155 // ret i32 %Y 156 // 157 FunctionPass *createPromoteMemoryToRegisterPass(); 158 159 //===----------------------------------------------------------------------===// 160 // 161 // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory 162 // references. In basically undoes the PromoteMemoryToRegister pass to make cfg 163 // hacking easier. 164 // 165 FunctionPass *createDemoteRegisterToMemoryPass(); 166 extern char &DemoteRegisterToMemoryID; 167 168 //===----------------------------------------------------------------------===// 169 // 170 // Reassociate - This pass reassociates commutative expressions in an order that 171 // is designed to promote better constant propagation, GCSE, LICM, PRE... 172 // 173 // For example: 4 + (x + 5) -> x + (4 + 5) 174 // 175 FunctionPass *createReassociatePass(); 176 177 //===----------------------------------------------------------------------===// 178 // 179 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some 180 // preds always go to some succ. 181 // 182 FunctionPass *createJumpThreadingPass(); 183 184 //===----------------------------------------------------------------------===// 185 // 186 // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, 187 // simplify terminator instructions, etc... 188 // 189 FunctionPass *createCFGSimplificationPass(); 190 191 //===----------------------------------------------------------------------===// 192 // 193 // BreakCriticalEdges - Break all of the critical edges in the CFG by inserting 194 // a dummy basic block. This pass may be "required" by passes that cannot deal 195 // with critical edges. For this usage, a pass must call: 196 // 197 // AU.addRequiredID(BreakCriticalEdgesID); 198 // 199 // This pass obviously invalidates the CFG, but can update forward dominator 200 // (set, immediate dominators, tree, and frontier) information. 201 // 202 FunctionPass *createBreakCriticalEdgesPass(); 203 extern char &BreakCriticalEdgesID; 204 205 //===----------------------------------------------------------------------===// 206 // 207 // LoopSimplify - Insert Pre-header blocks into the CFG for every function in 208 // the module. This pass updates dominator information, loop information, and 209 // does not add critical edges to the CFG. 210 // 211 // AU.addRequiredID(LoopSimplifyID); 212 // 213 Pass *createLoopSimplifyPass(); 214 extern char &LoopSimplifyID; 215 216 //===----------------------------------------------------------------------===// 217 // 218 // TailCallElimination - This pass eliminates call instructions to the current 219 // function which occur immediately before return instructions. 220 // 221 FunctionPass *createTailCallEliminationPass(); 222 223 //===----------------------------------------------------------------------===// 224 // 225 // LowerSwitch - This pass converts SwitchInst instructions into a sequence of 226 // chained binary branch instructions. 227 // 228 FunctionPass *createLowerSwitchPass(); 229 extern char &LowerSwitchID; 230 231 //===----------------------------------------------------------------------===// 232 // 233 // LowerInvoke - This pass converts invoke and unwind instructions to use sjlj 234 // exception handling mechanisms. Note that after this pass runs the CFG is not 235 // entirely accurate (exceptional control flow edges are not correct anymore) so 236 // only very simple things should be done after the lowerinvoke pass has run 237 // (like generation of native code). This should *NOT* be used as a general 238 // purpose "my LLVM-to-LLVM pass doesn't support the invoke instruction yet" 239 // lowering pass. 240 // 241 FunctionPass *createLowerInvokePass(const TargetLowering *TLI = 0); 242 FunctionPass *createLowerInvokePass(const TargetLowering *TLI, 243 bool useExpensiveEHSupport); 244 extern char &LowerInvokePassID; 245 246 //===----------------------------------------------------------------------===// 247 // 248 // BlockPlacement - This pass reorders basic blocks in order to increase the 249 // number of fall-through conditional branches. 250 // 251 FunctionPass *createBlockPlacementPass(); 252 253 //===----------------------------------------------------------------------===// 254 // 255 // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop 256 // optimizations. 257 // 258 Pass *createLCSSAPass(); 259 extern char &LCSSAID; 260 261 //===----------------------------------------------------------------------===// 262 // 263 // EarlyCSE - This pass performs a simple and fast CSE pass over the dominator 264 // tree. 265 // 266 FunctionPass *createEarlyCSEPass(); 267 268 //===----------------------------------------------------------------------===// 269 // 270 // GVN - This pass performs global value numbering and redundant load 271 // elimination cotemporaneously. 272 // 273 FunctionPass *createGVNPass(bool NoLoads = false); 274 275 //===----------------------------------------------------------------------===// 276 // 277 // MemCpyOpt - This pass performs optimizations related to eliminating memcpy 278 // calls and/or combining multiple stores into memset's. 279 // 280 FunctionPass *createMemCpyOptPass(); 281 282 //===----------------------------------------------------------------------===// 283 // 284 // LoopDeletion - This pass performs DCE of non-infinite loops that it 285 // can prove are dead. 286 // 287 Pass *createLoopDeletionPass(); 288 289 //===----------------------------------------------------------------------===// 290 // 291 /// createSimplifyLibCallsPass - This pass optimizes specific calls to 292 /// specific well-known (library) functions. 293 FunctionPass *createSimplifyLibCallsPass(); 294 295 //===----------------------------------------------------------------------===// 296 // 297 // CodeGenPrepare - This pass prepares a function for instruction selection. 298 // 299 FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0); 300 301 //===----------------------------------------------------------------------===// 302 // 303 // InstructionNamer - Give any unnamed non-void instructions "tmp" names. 304 // 305 FunctionPass *createInstructionNamerPass(); 306 extern char &InstructionNamerID; 307 308 //===----------------------------------------------------------------------===// 309 // 310 // GEPSplitter - Split complex GEPs into simple ones 311 // 312 FunctionPass *createGEPSplitterPass(); 313 314 //===----------------------------------------------------------------------===// 315 // 316 // Sink - Code Sinking 317 // 318 FunctionPass *createSinkingPass(); 319 320 //===----------------------------------------------------------------------===// 321 // 322 // LowerAtomic - Lower atomic intrinsics to non-atomic form 323 // 324 Pass *createLowerAtomicPass(); 325 326 //===----------------------------------------------------------------------===// 327 // 328 // ValuePropagation - Propagate CFG-derived value information 329 // 330 Pass *createCorrelatedValuePropagationPass(); 331 332 //===----------------------------------------------------------------------===// 333 // 334 // ObjCARCExpand - ObjC ARC preliminary simplifications. 335 // 336 Pass *createObjCARCExpandPass(); 337 338 //===----------------------------------------------------------------------===// 339 // 340 // ObjCARCContract - Late ObjC ARC cleanups. 341 // 342 Pass *createObjCARCContractPass(); 343 344 //===----------------------------------------------------------------------===// 345 // 346 // ObjCARCOpt - ObjC ARC optimization. 347 // 348 Pass *createObjCARCOptPass(); 349 350 //===----------------------------------------------------------------------===// 351 // 352 // InstructionSimplifier - Remove redundant instructions. 353 // 354 FunctionPass *createInstructionSimplifierPass(); 355 extern char &InstructionSimplifierID; 356 357 358 //===----------------------------------------------------------------------===// 359 // 360 // LowerExpectIntriniscs - Removes llvm.expect intrinsics and creates 361 // "block_weights" metadata. 362 FunctionPass *createLowerExpectIntrinsicPass(); 363 364 365 } // End llvm namespace 366 367 #endif 368
