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 #include "llvm/ADT/StringRef.h" 19 20 namespace llvm { 21 22 class BasicBlockPass; 23 class FunctionPass; 24 class Pass; 25 class GetElementPtrInst; 26 class PassInfo; 27 class TerminatorInst; 28 class TargetLowering; 29 class TargetMachine; 30 31 //===----------------------------------------------------------------------===// 32 // 33 // ConstantPropagation - A worklist driven constant propagation pass 34 // 35 FunctionPass *createConstantPropagationPass(); 36 37 //===----------------------------------------------------------------------===// 38 // 39 // AlignmentFromAssumptions - Use assume intrinsics to set load/store 40 // alignments. 41 // 42 FunctionPass *createAlignmentFromAssumptionsPass(); 43 44 //===----------------------------------------------------------------------===// 45 // 46 // SCCP - Sparse conditional constant propagation. 47 // 48 FunctionPass *createSCCPPass(); 49 50 //===----------------------------------------------------------------------===// 51 // 52 // DeadInstElimination - This pass quickly removes trivially dead instructions 53 // without modifying the CFG of the function. It is a BasicBlockPass, so it 54 // runs efficiently when queued next to other BasicBlockPass's. 55 // 56 Pass *createDeadInstEliminationPass(); 57 58 //===----------------------------------------------------------------------===// 59 // 60 // DeadCodeElimination - This pass is more powerful than DeadInstElimination, 61 // because it is worklist driven that can potentially revisit instructions when 62 // their other instructions become dead, to eliminate chains of dead 63 // computations. 64 // 65 FunctionPass *createDeadCodeEliminationPass(); 66 67 //===----------------------------------------------------------------------===// 68 // 69 // DeadStoreElimination - This pass deletes stores that are post-dominated by 70 // must-aliased stores and are not loaded used between the stores. 71 // 72 FunctionPass *createDeadStoreEliminationPass(); 73 74 //===----------------------------------------------------------------------===// 75 // 76 // AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This 77 // algorithm assumes instructions are dead until proven otherwise, which makes 78 // it more successful are removing non-obviously dead instructions. 79 // 80 FunctionPass *createAggressiveDCEPass(); 81 82 //===----------------------------------------------------------------------===// 83 // 84 // SROA - Replace aggregates or pieces of aggregates with scalar SSA values. 85 // 86 FunctionPass *createSROAPass(bool RequiresDomTree = true); 87 88 //===----------------------------------------------------------------------===// 89 // 90 // ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas 91 // if possible. 92 // 93 FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1, 94 bool UseDomTree = true, 95 signed StructMemberThreshold = -1, 96 signed ArrayElementThreshold = -1, 97 signed ScalarLoadThreshold = -1); 98 99 //===----------------------------------------------------------------------===// 100 // 101 // InductionVariableSimplify - Transform induction variables in a program to all 102 // use a single canonical induction variable per loop. 103 // 104 Pass *createIndVarSimplifyPass(); 105 106 //===----------------------------------------------------------------------===// 107 // 108 // InstructionCombining - Combine instructions to form fewer, simple 109 // instructions. This pass does not modify the CFG, and has a tendency to make 110 // instructions dead, so a subsequent DCE pass is useful. 111 // 112 // This pass combines things like: 113 // %Y = add int 1, %X 114 // %Z = add int 1, %Y 115 // into: 116 // %Z = add int 2, %X 117 // 118 FunctionPass *createInstructionCombiningPass(); 119 120 //===----------------------------------------------------------------------===// 121 // 122 // LICM - This pass is a loop invariant code motion and memory promotion pass. 123 // 124 Pass *createLICMPass(); 125 126 //===----------------------------------------------------------------------===// 127 // 128 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use 129 // a loop's canonical induction variable as one of their indices. 130 // 131 Pass *createLoopStrengthReducePass(); 132 133 Pass *createGlobalMergePass(const TargetMachine *TM = nullptr); 134 135 //===----------------------------------------------------------------------===// 136 // 137 // LoopUnswitch - This pass is a simple loop unswitching pass. 138 // 139 Pass *createLoopUnswitchPass(bool OptimizeForSize = false); 140 141 //===----------------------------------------------------------------------===// 142 // 143 // LoopInstSimplify - This pass simplifies instructions in a loop's body. 144 // 145 Pass *createLoopInstSimplifyPass(); 146 147 //===----------------------------------------------------------------------===// 148 // 149 // LoopUnroll - This pass is a simple loop unrolling pass. 150 // 151 Pass *createLoopUnrollPass(int Threshold = -1, int Count = -1, 152 int AllowPartial = -1, int Runtime = -1); 153 // Create an unrolling pass for full unrolling only. 154 Pass *createSimpleLoopUnrollPass(); 155 156 //===----------------------------------------------------------------------===// 157 // 158 // LoopReroll - This pass is a simple loop rerolling pass. 159 // 160 Pass *createLoopRerollPass(); 161 162 //===----------------------------------------------------------------------===// 163 // 164 // LoopRotate - This pass is a simple loop rotating pass. 165 // 166 Pass *createLoopRotatePass(int MaxHeaderSize = -1); 167 168 //===----------------------------------------------------------------------===// 169 // 170 // LoopIdiom - This pass recognizes and replaces idioms in loops. 171 // 172 Pass *createLoopIdiomPass(); 173 174 //===----------------------------------------------------------------------===// 175 // 176 // PromoteMemoryToRegister - This pass is used to promote memory references to 177 // be register references. A simple example of the transformation performed by 178 // this pass is: 179 // 180 // FROM CODE TO CODE 181 // %X = alloca i32, i32 1 ret i32 42 182 // store i32 42, i32 *%X 183 // %Y = load i32* %X 184 // ret i32 %Y 185 // 186 FunctionPass *createPromoteMemoryToRegisterPass(); 187 188 //===----------------------------------------------------------------------===// 189 // 190 // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory 191 // references. In basically undoes the PromoteMemoryToRegister pass to make cfg 192 // hacking easier. 193 // 194 FunctionPass *createDemoteRegisterToMemoryPass(); 195 extern char &DemoteRegisterToMemoryID; 196 197 //===----------------------------------------------------------------------===// 198 // 199 // Reassociate - This pass reassociates commutative expressions in an order that 200 // is designed to promote better constant propagation, GCSE, LICM, PRE... 201 // 202 // For example: 4 + (x + 5) -> x + (4 + 5) 203 // 204 FunctionPass *createReassociatePass(); 205 206 //===----------------------------------------------------------------------===// 207 // 208 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some 209 // preds always go to some succ. Thresholds other than minus one override the 210 // internal BB duplication default threshold. 211 // 212 FunctionPass *createJumpThreadingPass(int Threshold = -1); 213 214 //===----------------------------------------------------------------------===// 215 // 216 // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, 217 // simplify terminator instructions, etc... 218 // 219 FunctionPass *createCFGSimplificationPass(int Threshold = -1); 220 221 //===----------------------------------------------------------------------===// 222 // 223 // FlattenCFG - flatten CFG, reduce number of conditional branches by using 224 // parallel-and and parallel-or mode, etc... 225 // 226 FunctionPass *createFlattenCFGPass(); 227 228 //===----------------------------------------------------------------------===// 229 // 230 // CFG Structurization - Remove irreducible control flow 231 // 232 Pass *createStructurizeCFGPass(); 233 234 //===----------------------------------------------------------------------===// 235 // 236 // BreakCriticalEdges - Break all of the critical edges in the CFG by inserting 237 // a dummy basic block. This pass may be "required" by passes that cannot deal 238 // with critical edges. For this usage, a pass must call: 239 // 240 // AU.addRequiredID(BreakCriticalEdgesID); 241 // 242 // This pass obviously invalidates the CFG, but can update forward dominator 243 // (set, immediate dominators, tree, and frontier) information. 244 // 245 FunctionPass *createBreakCriticalEdgesPass(); 246 extern char &BreakCriticalEdgesID; 247 248 //===----------------------------------------------------------------------===// 249 // 250 // LoopSimplify - Insert Pre-header blocks into the CFG for every function in 251 // the module. This pass updates dominator information, loop information, and 252 // does not add critical edges to the CFG. 253 // 254 // AU.addRequiredID(LoopSimplifyID); 255 // 256 Pass *createLoopSimplifyPass(); 257 extern char &LoopSimplifyID; 258 259 //===----------------------------------------------------------------------===// 260 // 261 // TailCallElimination - This pass eliminates call instructions to the current 262 // function which occur immediately before return instructions. 263 // 264 FunctionPass *createTailCallEliminationPass(); 265 266 //===----------------------------------------------------------------------===// 267 // 268 // LowerSwitch - This pass converts SwitchInst instructions into a sequence of 269 // chained binary branch instructions. 270 // 271 FunctionPass *createLowerSwitchPass(); 272 extern char &LowerSwitchID; 273 274 //===----------------------------------------------------------------------===// 275 // 276 // LowerInvoke - This pass removes invoke instructions, converting them to call 277 // instructions. 278 // 279 FunctionPass *createLowerInvokePass(); 280 extern char &LowerInvokePassID; 281 282 //===----------------------------------------------------------------------===// 283 // 284 // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop 285 // optimizations. 286 // 287 Pass *createLCSSAPass(); 288 extern char &LCSSAID; 289 290 //===----------------------------------------------------------------------===// 291 // 292 // EarlyCSE - This pass performs a simple and fast CSE pass over the dominator 293 // tree. 294 // 295 FunctionPass *createEarlyCSEPass(); 296 297 //===----------------------------------------------------------------------===// 298 // 299 // MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads 300 // are hoisted into the header, while stores sink into the footer. 301 // 302 FunctionPass *createMergedLoadStoreMotionPass(); 303 304 //===----------------------------------------------------------------------===// 305 // 306 // GVN - This pass performs global value numbering and redundant load 307 // elimination cotemporaneously. 308 // 309 FunctionPass *createGVNPass(bool NoLoads = false); 310 311 //===----------------------------------------------------------------------===// 312 // 313 // MemCpyOpt - This pass performs optimizations related to eliminating memcpy 314 // calls and/or combining multiple stores into memset's. 315 // 316 FunctionPass *createMemCpyOptPass(); 317 318 //===----------------------------------------------------------------------===// 319 // 320 // LoopDeletion - This pass performs DCE of non-infinite loops that it 321 // can prove are dead. 322 // 323 Pass *createLoopDeletionPass(); 324 325 //===----------------------------------------------------------------------===// 326 // 327 // ConstantHoisting - This pass prepares a function for expensive constants. 328 // 329 FunctionPass *createConstantHoistingPass(); 330 331 //===----------------------------------------------------------------------===// 332 // 333 // InstructionNamer - Give any unnamed non-void instructions "tmp" names. 334 // 335 FunctionPass *createInstructionNamerPass(); 336 extern char &InstructionNamerID; 337 338 //===----------------------------------------------------------------------===// 339 // 340 // Sink - Code Sinking 341 // 342 FunctionPass *createSinkingPass(); 343 344 //===----------------------------------------------------------------------===// 345 // 346 // LowerAtomic - Lower atomic intrinsics to non-atomic form 347 // 348 Pass *createLowerAtomicPass(); 349 350 //===----------------------------------------------------------------------===// 351 // 352 // ValuePropagation - Propagate CFG-derived value information 353 // 354 Pass *createCorrelatedValuePropagationPass(); 355 356 //===----------------------------------------------------------------------===// 357 // 358 // InstructionSimplifier - Remove redundant instructions. 359 // 360 FunctionPass *createInstructionSimplifierPass(); 361 extern char &InstructionSimplifierID; 362 363 //===----------------------------------------------------------------------===// 364 // 365 // LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates 366 // "block_weights" metadata. 367 FunctionPass *createLowerExpectIntrinsicPass(); 368 369 //===----------------------------------------------------------------------===// 370 // 371 // PartiallyInlineLibCalls - Tries to inline the fast path of library 372 // calls such as sqrt. 373 // 374 FunctionPass *createPartiallyInlineLibCallsPass(); 375 376 //===----------------------------------------------------------------------===// 377 // 378 // SampleProfilePass - Loads sample profile data from disk and generates 379 // IR metadata to reflect the profile. 380 FunctionPass *createSampleProfileLoaderPass(); 381 FunctionPass *createSampleProfileLoaderPass(StringRef Name); 382 383 //===----------------------------------------------------------------------===// 384 // 385 // ScalarizerPass - Converts vector operations into scalar operations 386 // 387 FunctionPass *createScalarizerPass(); 388 389 //===----------------------------------------------------------------------===// 390 // 391 // AddDiscriminators - Add DWARF path discriminators to the IR. 392 FunctionPass *createAddDiscriminatorsPass(); 393 394 //===----------------------------------------------------------------------===// 395 // 396 // SeparateConstOffsetFromGEP - Split GEPs for better CSE 397 // 398 FunctionPass * 399 createSeparateConstOffsetFromGEPPass(const TargetMachine *TM = nullptr, 400 bool LowerGEP = false); 401 402 //===----------------------------------------------------------------------===// 403 // 404 // LoadCombine - Combine loads into bigger loads. 405 // 406 BasicBlockPass *createLoadCombinePass(); 407 408 } // End llvm namespace 409 410 #endif 411