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 <functional> 19 20 namespace llvm { 21 22 class BasicBlockPass; 23 class Function; 24 class FunctionPass; 25 class ModulePass; 26 class Pass; 27 class GetElementPtrInst; 28 class PassInfo; 29 class TerminatorInst; 30 class TargetLowering; 31 class TargetMachine; 32 33 //===----------------------------------------------------------------------===// 34 // 35 // ConstantPropagation - A worklist driven constant propagation pass 36 // 37 FunctionPass *createConstantPropagationPass(); 38 39 //===----------------------------------------------------------------------===// 40 // 41 // AlignmentFromAssumptions - Use assume intrinsics to set load/store 42 // alignments. 43 // 44 FunctionPass *createAlignmentFromAssumptionsPass(); 45 46 //===----------------------------------------------------------------------===// 47 // 48 // SCCP - Sparse conditional constant propagation. 49 // 50 FunctionPass *createSCCPPass(); 51 52 //===----------------------------------------------------------------------===// 53 // 54 // DeadInstElimination - This pass quickly removes trivially dead instructions 55 // without modifying the CFG of the function. It is a BasicBlockPass, so it 56 // runs efficiently when queued next to other BasicBlockPass's. 57 // 58 Pass *createDeadInstEliminationPass(); 59 60 //===----------------------------------------------------------------------===// 61 // 62 // DeadCodeElimination - This pass is more powerful than DeadInstElimination, 63 // because it is worklist driven that can potentially revisit instructions when 64 // their other instructions become dead, to eliminate chains of dead 65 // computations. 66 // 67 FunctionPass *createDeadCodeEliminationPass(); 68 69 //===----------------------------------------------------------------------===// 70 // 71 // DeadStoreElimination - This pass deletes stores that are post-dominated by 72 // must-aliased stores and are not loaded used between the stores. 73 // 74 FunctionPass *createDeadStoreEliminationPass(); 75 76 //===----------------------------------------------------------------------===// 77 // 78 // AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This 79 // algorithm assumes instructions are dead until proven otherwise, which makes 80 // it more successful are removing non-obviously dead instructions. 81 // 82 FunctionPass *createAggressiveDCEPass(); 83 84 85 //===----------------------------------------------------------------------===// 86 // 87 // GuardWidening - An optimization over the @llvm.experimental.guard intrinsic 88 // that (optimistically) combines multiple guards into one to have fewer checks 89 // at runtime. 90 // 91 FunctionPass *createGuardWideningPass(); 92 93 94 //===----------------------------------------------------------------------===// 95 // 96 // BitTrackingDCE - This pass uses a bit-tracking DCE algorithm in order to 97 // remove computations of dead bits. 98 // 99 FunctionPass *createBitTrackingDCEPass(); 100 101 //===----------------------------------------------------------------------===// 102 // 103 // SROA - Replace aggregates or pieces of aggregates with scalar SSA values. 104 // 105 FunctionPass *createSROAPass(); 106 107 //===----------------------------------------------------------------------===// 108 // 109 // InductiveRangeCheckElimination - Transform loops to elide range checks on 110 // linear functions of the induction variable. 111 // 112 Pass *createInductiveRangeCheckEliminationPass(); 113 114 //===----------------------------------------------------------------------===// 115 // 116 // InductionVariableSimplify - Transform induction variables in a program to all 117 // use a single canonical induction variable per loop. 118 // 119 Pass *createIndVarSimplifyPass(); 120 121 //===----------------------------------------------------------------------===// 122 // 123 // InstructionCombining - Combine instructions to form fewer, simple 124 // instructions. This pass does not modify the CFG, and has a tendency to make 125 // instructions dead, so a subsequent DCE pass is useful. 126 // 127 // This pass combines things like: 128 // %Y = add int 1, %X 129 // %Z = add int 1, %Y 130 // into: 131 // %Z = add int 2, %X 132 // 133 FunctionPass *createInstructionCombiningPass(bool ExpensiveCombines = true); 134 135 //===----------------------------------------------------------------------===// 136 // 137 // LICM - This pass is a loop invariant code motion and memory promotion pass. 138 // 139 Pass *createLICMPass(); 140 141 //===----------------------------------------------------------------------===// 142 // 143 // LoopSink - This pass sinks invariants from preheader to loop body where 144 // frequency is lower than loop preheader. 145 // 146 Pass *createLoopSinkPass(); 147 148 //===----------------------------------------------------------------------===// 149 // 150 // LoopPredication - This pass does loop predication on guards. 151 // 152 Pass *createLoopPredicationPass(); 153 154 //===----------------------------------------------------------------------===// 155 // 156 // LoopInterchange - This pass interchanges loops to provide a more 157 // cache-friendly memory access patterns. 158 // 159 Pass *createLoopInterchangePass(); 160 161 //===----------------------------------------------------------------------===// 162 // 163 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use 164 // a loop's canonical induction variable as one of their indices. 165 // 166 Pass *createLoopStrengthReducePass(); 167 168 //===----------------------------------------------------------------------===// 169 // 170 // LoopUnswitch - This pass is a simple loop unswitching pass. 171 // 172 Pass *createLoopUnswitchPass(bool OptimizeForSize = false, 173 bool hasBranchDivergence = false); 174 175 //===----------------------------------------------------------------------===// 176 // 177 // LoopInstSimplify - This pass simplifies instructions in a loop's body. 178 // 179 Pass *createLoopInstSimplifyPass(); 180 181 //===----------------------------------------------------------------------===// 182 // 183 // LoopUnroll - This pass is a simple loop unrolling pass. 184 // 185 Pass *createLoopUnrollPass(int OptLevel = 2, int Threshold = -1, int Count = -1, 186 int AllowPartial = -1, int Runtime = -1, 187 int UpperBound = -1); 188 // Create an unrolling pass for full unrolling that uses exact trip count only. 189 Pass *createSimpleLoopUnrollPass(int OptLevel = 2); 190 191 //===----------------------------------------------------------------------===// 192 // 193 // LoopReroll - This pass is a simple loop rerolling pass. 194 // 195 Pass *createLoopRerollPass(); 196 197 //===----------------------------------------------------------------------===// 198 // 199 // LoopRotate - This pass is a simple loop rotating pass. 200 // 201 Pass *createLoopRotatePass(int MaxHeaderSize = -1); 202 203 //===----------------------------------------------------------------------===// 204 // 205 // LoopIdiom - This pass recognizes and replaces idioms in loops. 206 // 207 Pass *createLoopIdiomPass(); 208 209 //===----------------------------------------------------------------------===// 210 // 211 // LoopVersioningLICM - This pass is a loop versioning pass for LICM. 212 // 213 Pass *createLoopVersioningLICMPass(); 214 215 //===----------------------------------------------------------------------===// 216 // 217 // PromoteMemoryToRegister - This pass is used to promote memory references to 218 // be register references. A simple example of the transformation performed by 219 // this pass is: 220 // 221 // FROM CODE TO CODE 222 // %X = alloca i32, i32 1 ret i32 42 223 // store i32 42, i32 *%X 224 // %Y = load i32* %X 225 // ret i32 %Y 226 // 227 FunctionPass *createPromoteMemoryToRegisterPass(); 228 229 //===----------------------------------------------------------------------===// 230 // 231 // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory 232 // references. In basically undoes the PromoteMemoryToRegister pass to make cfg 233 // hacking easier. 234 // 235 FunctionPass *createDemoteRegisterToMemoryPass(); 236 extern char &DemoteRegisterToMemoryID; 237 238 //===----------------------------------------------------------------------===// 239 // 240 // Reassociate - This pass reassociates commutative expressions in an order that 241 // is designed to promote better constant propagation, GCSE, LICM, PRE... 242 // 243 // For example: 4 + (x + 5) -> x + (4 + 5) 244 // 245 FunctionPass *createReassociatePass(); 246 247 //===----------------------------------------------------------------------===// 248 // 249 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some 250 // preds always go to some succ. Thresholds other than minus one override the 251 // internal BB duplication default threshold. 252 // 253 FunctionPass *createJumpThreadingPass(int Threshold = -1); 254 255 //===----------------------------------------------------------------------===// 256 // 257 // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, 258 // simplify terminator instructions, etc... 259 // 260 FunctionPass *createCFGSimplificationPass( 261 int Threshold = -1, std::function<bool(const Function &)> Ftor = nullptr); 262 263 //===----------------------------------------------------------------------===// 264 // 265 // LateCFGSimplification - Like CFGSimplification, but may also 266 // convert switches to lookup tables. 267 // 268 FunctionPass *createLateCFGSimplificationPass( 269 int Threshold = -1, std::function<bool(const Function &)> Ftor = nullptr); 270 271 //===----------------------------------------------------------------------===// 272 // 273 // FlattenCFG - flatten CFG, reduce number of conditional branches by using 274 // parallel-and and parallel-or mode, etc... 275 // 276 FunctionPass *createFlattenCFGPass(); 277 278 //===----------------------------------------------------------------------===// 279 // 280 // CFG Structurization - Remove irreducible control flow 281 // 282 /// 283 /// When \p SkipUniformRegions is true the structizer will not structurize 284 /// regions that only contain uniform branches. 285 Pass *createStructurizeCFGPass(bool SkipUniformRegions = false); 286 287 //===----------------------------------------------------------------------===// 288 // 289 // BreakCriticalEdges - Break all of the critical edges in the CFG by inserting 290 // a dummy basic block. This pass may be "required" by passes that cannot deal 291 // with critical edges. For this usage, a pass must call: 292 // 293 // AU.addRequiredID(BreakCriticalEdgesID); 294 // 295 // This pass obviously invalidates the CFG, but can update forward dominator 296 // (set, immediate dominators, tree, and frontier) information. 297 // 298 FunctionPass *createBreakCriticalEdgesPass(); 299 extern char &BreakCriticalEdgesID; 300 301 //===----------------------------------------------------------------------===// 302 // 303 // LoopSimplify - Insert Pre-header blocks into the CFG for every function in 304 // the module. This pass updates dominator information, loop information, and 305 // does not add critical edges to the CFG. 306 // 307 // AU.addRequiredID(LoopSimplifyID); 308 // 309 Pass *createLoopSimplifyPass(); 310 extern char &LoopSimplifyID; 311 312 //===----------------------------------------------------------------------===// 313 // 314 // TailCallElimination - This pass eliminates call instructions to the current 315 // function which occur immediately before return instructions. 316 // 317 FunctionPass *createTailCallEliminationPass(); 318 319 //===----------------------------------------------------------------------===// 320 // 321 // LowerSwitch - This pass converts SwitchInst instructions into a sequence of 322 // chained binary branch instructions. 323 // 324 FunctionPass *createLowerSwitchPass(); 325 extern char &LowerSwitchID; 326 327 //===----------------------------------------------------------------------===// 328 // 329 // LowerInvoke - This pass removes invoke instructions, converting them to call 330 // instructions. 331 // 332 FunctionPass *createLowerInvokePass(); 333 extern char &LowerInvokePassID; 334 335 //===----------------------------------------------------------------------===// 336 // 337 // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop 338 // optimizations. 339 // 340 Pass *createLCSSAPass(); 341 extern char &LCSSAID; 342 343 //===----------------------------------------------------------------------===// 344 // 345 // EarlyCSE - This pass performs a simple and fast CSE pass over the dominator 346 // tree. 347 // 348 FunctionPass *createEarlyCSEPass(bool UseMemorySSA = false); 349 350 //===----------------------------------------------------------------------===// 351 // 352 // GVNHoist - This pass performs a simple and fast GVN pass over the dominator 353 // tree to hoist common expressions from sibling branches. 354 // 355 FunctionPass *createGVNHoistPass(); 356 357 //===----------------------------------------------------------------------===// 358 // 359 // GVNSink - This pass uses an "inverted" value numbering to decide the 360 // similarity of expressions and sinks similar expressions into successors. 361 // 362 FunctionPass *createGVNSinkPass(); 363 364 //===----------------------------------------------------------------------===// 365 // 366 // MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads 367 // are hoisted into the header, while stores sink into the footer. 368 // 369 FunctionPass *createMergedLoadStoreMotionPass(); 370 371 //===----------------------------------------------------------------------===// 372 // 373 // GVN - This pass performs global value numbering and redundant load 374 // elimination cotemporaneously. 375 // 376 FunctionPass *createNewGVNPass(); 377 378 //===----------------------------------------------------------------------===// 379 // 380 // MemCpyOpt - This pass performs optimizations related to eliminating memcpy 381 // calls and/or combining multiple stores into memset's. 382 // 383 FunctionPass *createMemCpyOptPass(); 384 385 //===----------------------------------------------------------------------===// 386 // 387 // LoopDeletion - This pass performs DCE of non-infinite loops that it 388 // can prove are dead. 389 // 390 Pass *createLoopDeletionPass(); 391 392 //===----------------------------------------------------------------------===// 393 // 394 // ConstantHoisting - This pass prepares a function for expensive constants. 395 // 396 FunctionPass *createConstantHoistingPass(); 397 398 //===----------------------------------------------------------------------===// 399 // 400 // InstructionNamer - Give any unnamed non-void instructions "tmp" names. 401 // 402 FunctionPass *createInstructionNamerPass(); 403 extern char &InstructionNamerID; 404 405 //===----------------------------------------------------------------------===// 406 // 407 // Sink - Code Sinking 408 // 409 FunctionPass *createSinkingPass(); 410 411 //===----------------------------------------------------------------------===// 412 // 413 // LowerAtomic - Lower atomic intrinsics to non-atomic form 414 // 415 Pass *createLowerAtomicPass(); 416 417 //===----------------------------------------------------------------------===// 418 // 419 // LowerGuardIntrinsic - Lower guard intrinsics to normal control flow. 420 // 421 Pass *createLowerGuardIntrinsicPass(); 422 423 //===----------------------------------------------------------------------===// 424 // 425 // ValuePropagation - Propagate CFG-derived value information 426 // 427 Pass *createCorrelatedValuePropagationPass(); 428 429 //===----------------------------------------------------------------------===// 430 // 431 // InferAddressSpaces - Modify users of addrspacecast instructions with values 432 // in the source address space if using the destination address space is slower 433 // on the target. 434 // 435 FunctionPass *createInferAddressSpacesPass(); 436 extern char &InferAddressSpacesID; 437 438 //===----------------------------------------------------------------------===// 439 // 440 // InstructionSimplifier - Remove redundant instructions. 441 // 442 FunctionPass *createInstructionSimplifierPass(); 443 extern char &InstructionSimplifierID; 444 445 //===----------------------------------------------------------------------===// 446 // 447 // LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates 448 // "block_weights" metadata. 449 FunctionPass *createLowerExpectIntrinsicPass(); 450 451 //===----------------------------------------------------------------------===// 452 // 453 // PartiallyInlineLibCalls - Tries to inline the fast path of library 454 // calls such as sqrt. 455 // 456 FunctionPass *createPartiallyInlineLibCallsPass(); 457 458 //===----------------------------------------------------------------------===// 459 // 460 // ScalarizerPass - Converts vector operations into scalar operations 461 // 462 FunctionPass *createScalarizerPass(); 463 464 //===----------------------------------------------------------------------===// 465 // 466 // AddDiscriminators - Add DWARF path discriminators to the IR. 467 FunctionPass *createAddDiscriminatorsPass(); 468 469 //===----------------------------------------------------------------------===// 470 // 471 // SeparateConstOffsetFromGEP - Split GEPs for better CSE 472 // 473 FunctionPass * 474 createSeparateConstOffsetFromGEPPass(const TargetMachine *TM = nullptr, 475 bool LowerGEP = false); 476 477 //===----------------------------------------------------------------------===// 478 // 479 // SpeculativeExecution - Aggressively hoist instructions to enable 480 // speculative execution on targets where branches are expensive. 481 // 482 FunctionPass *createSpeculativeExecutionPass(); 483 484 // Same as createSpeculativeExecutionPass, but does nothing unless 485 // TargetTransformInfo::hasBranchDivergence() is true. 486 FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass(); 487 488 //===----------------------------------------------------------------------===// 489 // 490 // LoadCombine - Combine loads into bigger loads. 491 // 492 BasicBlockPass *createLoadCombinePass(); 493 494 //===----------------------------------------------------------------------===// 495 // 496 // StraightLineStrengthReduce - This pass strength-reduces some certain 497 // instruction patterns in straight-line code. 498 // 499 FunctionPass *createStraightLineStrengthReducePass(); 500 501 //===----------------------------------------------------------------------===// 502 // 503 // PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any 504 // safepoint polls (method entry, backedge) that might be required. This pass 505 // does not generate explicit relocation sequences - that's handled by 506 // RewriteStatepointsForGC which can be run at an arbitrary point in the pass 507 // order following this pass. 508 // 509 FunctionPass *createPlaceSafepointsPass(); 510 511 //===----------------------------------------------------------------------===// 512 // 513 // RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have 514 // explicit relocations to include explicit relocations. 515 // 516 ModulePass *createRewriteStatepointsForGCPass(); 517 518 //===----------------------------------------------------------------------===// 519 // 520 // StripGCRelocates - Remove GC relocates that have been inserted by 521 // RewriteStatepointsForGC. The resulting IR is incorrect, but this is useful 522 // for manual inspection. 523 FunctionPass *createStripGCRelocatesPass(); 524 525 //===----------------------------------------------------------------------===// 526 // 527 // Float2Int - Demote floats to ints where possible. 528 // 529 FunctionPass *createFloat2IntPass(); 530 531 //===----------------------------------------------------------------------===// 532 // 533 // NaryReassociate - Simplify n-ary operations by reassociation. 534 // 535 FunctionPass *createNaryReassociatePass(); 536 537 //===----------------------------------------------------------------------===// 538 // 539 // LoopDistribute - Distribute loops. 540 // 541 FunctionPass *createLoopDistributePass(); 542 543 //===----------------------------------------------------------------------===// 544 // 545 // LoopLoadElimination - Perform loop-aware load elimination. 546 // 547 FunctionPass *createLoopLoadEliminationPass(); 548 549 //===----------------------------------------------------------------------===// 550 // 551 // LoopSimplifyCFG - This pass performs basic CFG simplification on loops, 552 // primarily to help other loop passes. 553 // 554 Pass *createLoopSimplifyCFGPass(); 555 556 //===----------------------------------------------------------------------===// 557 // 558 // LoopVersioning - Perform loop multi-versioning. 559 // 560 FunctionPass *createLoopVersioningPass(); 561 562 //===----------------------------------------------------------------------===// 563 // 564 // LoopDataPrefetch - Perform data prefetching in loops. 565 // 566 FunctionPass *createLoopDataPrefetchPass(); 567 568 ///===---------------------------------------------------------------------===// 569 ModulePass *createNameAnonGlobalPass(); 570 571 //===----------------------------------------------------------------------===// 572 // 573 // LibCallsShrinkWrap - Shrink-wraps a call to function if the result is not 574 // used. 575 // 576 FunctionPass *createLibCallsShrinkWrapPass(); 577 } // End llvm namespace 578 579 #endif 580
