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 // 79 // CallSiteSplitting - This pass split call-site based on its known argument 80 // values. 81 FunctionPass *createCallSiteSplittingPass(); 82 83 //===----------------------------------------------------------------------===// 84 // 85 // AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This 86 // algorithm assumes instructions are dead until proven otherwise, which makes 87 // it more successful are removing non-obviously dead instructions. 88 // 89 FunctionPass *createAggressiveDCEPass(); 90 91 //===----------------------------------------------------------------------===// 92 // 93 // GuardWidening - An optimization over the @llvm.experimental.guard intrinsic 94 // that (optimistically) combines multiple guards into one to have fewer checks 95 // at runtime. 96 // 97 FunctionPass *createGuardWideningPass(); 98 99 100 //===----------------------------------------------------------------------===// 101 // 102 // LoopGuardWidening - Analogous to the GuardWidening pass, but restricted to a 103 // single loop at a time for use within a LoopPassManager. Desired effect is 104 // to widen guards into preheader or a single guard within loop if that's not 105 // possible. 106 // 107 Pass *createLoopGuardWideningPass(); 108 109 110 //===----------------------------------------------------------------------===// 111 // 112 // BitTrackingDCE - This pass uses a bit-tracking DCE algorithm in order to 113 // remove computations of dead bits. 114 // 115 FunctionPass *createBitTrackingDCEPass(); 116 117 //===----------------------------------------------------------------------===// 118 // 119 // SROA - Replace aggregates or pieces of aggregates with scalar SSA values. 120 // 121 FunctionPass *createSROAPass(); 122 123 //===----------------------------------------------------------------------===// 124 // 125 // InductiveRangeCheckElimination - Transform loops to elide range checks on 126 // linear functions of the induction variable. 127 // 128 Pass *createInductiveRangeCheckEliminationPass(); 129 130 //===----------------------------------------------------------------------===// 131 // 132 // InductionVariableSimplify - Transform induction variables in a program to all 133 // use a single canonical induction variable per loop. 134 // 135 Pass *createIndVarSimplifyPass(); 136 137 //===----------------------------------------------------------------------===// 138 // 139 // LICM - This pass is a loop invariant code motion and memory promotion pass. 140 // 141 Pass *createLICMPass(); 142 143 //===----------------------------------------------------------------------===// 144 // 145 // LoopSink - This pass sinks invariants from preheader to loop body where 146 // frequency is lower than loop preheader. 147 // 148 Pass *createLoopSinkPass(); 149 150 //===----------------------------------------------------------------------===// 151 // 152 // LoopPredication - This pass does loop predication on guards. 153 // 154 Pass *createLoopPredicationPass(); 155 156 //===----------------------------------------------------------------------===// 157 // 158 // LoopInterchange - This pass interchanges loops to provide a more 159 // cache-friendly memory access patterns. 160 // 161 Pass *createLoopInterchangePass(); 162 163 //===----------------------------------------------------------------------===// 164 // 165 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use 166 // a loop's canonical induction variable as one of their indices. 167 // 168 Pass *createLoopStrengthReducePass(); 169 170 //===----------------------------------------------------------------------===// 171 // 172 // LoopUnswitch - This pass is a simple loop unswitching pass. 173 // 174 Pass *createLoopUnswitchPass(bool OptimizeForSize = false, 175 bool hasBranchDivergence = false); 176 177 //===----------------------------------------------------------------------===// 178 // 179 // LoopInstSimplify - This pass simplifies instructions in a loop's body. 180 // 181 Pass *createLoopInstSimplifyPass(); 182 183 //===----------------------------------------------------------------------===// 184 // 185 // LoopUnroll - This pass is a simple loop unrolling pass. 186 // 187 Pass *createLoopUnrollPass(int OptLevel = 2, int Threshold = -1, int Count = -1, 188 int AllowPartial = -1, int Runtime = -1, 189 int UpperBound = -1, int AllowPeeling = -1); 190 // Create an unrolling pass for full unrolling that uses exact trip count only. 191 Pass *createSimpleLoopUnrollPass(int OptLevel = 2); 192 193 //===----------------------------------------------------------------------===// 194 // 195 // LoopUnrollAndJam - This pass is a simple loop unroll and jam pass. 196 // 197 Pass *createLoopUnrollAndJamPass(int OptLevel = 2); 198 199 //===----------------------------------------------------------------------===// 200 // 201 // LoopReroll - This pass is a simple loop rerolling pass. 202 // 203 Pass *createLoopRerollPass(); 204 205 //===----------------------------------------------------------------------===// 206 // 207 // LoopRotate - This pass is a simple loop rotating pass. 208 // 209 Pass *createLoopRotatePass(int MaxHeaderSize = -1); 210 211 //===----------------------------------------------------------------------===// 212 // 213 // LoopIdiom - This pass recognizes and replaces idioms in loops. 214 // 215 Pass *createLoopIdiomPass(); 216 217 //===----------------------------------------------------------------------===// 218 // 219 // LoopVersioningLICM - This pass is a loop versioning pass for LICM. 220 // 221 Pass *createLoopVersioningLICMPass(); 222 223 //===----------------------------------------------------------------------===// 224 // 225 // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory 226 // references. In basically undoes the PromoteMemoryToRegister pass to make cfg 227 // hacking easier. 228 // 229 FunctionPass *createDemoteRegisterToMemoryPass(); 230 extern char &DemoteRegisterToMemoryID; 231 232 //===----------------------------------------------------------------------===// 233 // 234 // Reassociate - This pass reassociates commutative expressions in an order that 235 // is designed to promote better constant propagation, GCSE, LICM, PRE... 236 // 237 // For example: 4 + (x + 5) -> x + (4 + 5) 238 // 239 FunctionPass *createReassociatePass(); 240 241 //===----------------------------------------------------------------------===// 242 // 243 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some 244 // preds always go to some succ. Thresholds other than minus one override the 245 // internal BB duplication default threshold. 246 // 247 FunctionPass *createJumpThreadingPass(int Threshold = -1); 248 249 //===----------------------------------------------------------------------===// 250 // 251 // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, 252 // simplify terminator instructions, convert switches to lookup tables, etc. 253 // 254 FunctionPass *createCFGSimplificationPass( 255 unsigned Threshold = 1, bool ForwardSwitchCond = false, 256 bool ConvertSwitch = false, bool KeepLoops = true, bool SinkCommon = false, 257 std::function<bool(const Function &)> Ftor = nullptr); 258 259 //===----------------------------------------------------------------------===// 260 // 261 // FlattenCFG - flatten CFG, reduce number of conditional branches by using 262 // parallel-and and parallel-or mode, etc... 263 // 264 FunctionPass *createFlattenCFGPass(); 265 266 //===----------------------------------------------------------------------===// 267 // 268 // CFG Structurization - Remove irreducible control flow 269 // 270 /// 271 /// When \p SkipUniformRegions is true the structizer will not structurize 272 /// regions that only contain uniform branches. 273 Pass *createStructurizeCFGPass(bool SkipUniformRegions = false); 274 275 //===----------------------------------------------------------------------===// 276 // 277 // TailCallElimination - This pass eliminates call instructions to the current 278 // function which occur immediately before return instructions. 279 // 280 FunctionPass *createTailCallEliminationPass(); 281 282 //===----------------------------------------------------------------------===// 283 // 284 // EarlyCSE - This pass performs a simple and fast CSE pass over the dominator 285 // tree. 286 // 287 FunctionPass *createEarlyCSEPass(bool UseMemorySSA = false); 288 289 //===----------------------------------------------------------------------===// 290 // 291 // GVNHoist - This pass performs a simple and fast GVN pass over the dominator 292 // tree to hoist common expressions from sibling branches. 293 // 294 FunctionPass *createGVNHoistPass(); 295 296 //===----------------------------------------------------------------------===// 297 // 298 // GVNSink - This pass uses an "inverted" value numbering to decide the 299 // similarity of expressions and sinks similar expressions into successors. 300 // 301 FunctionPass *createGVNSinkPass(); 302 303 //===----------------------------------------------------------------------===// 304 // 305 // MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads 306 // are hoisted into the header, while stores sink into the footer. 307 // 308 FunctionPass *createMergedLoadStoreMotionPass(); 309 310 //===----------------------------------------------------------------------===// 311 // 312 // GVN - This pass performs global value numbering and redundant load 313 // elimination cotemporaneously. 314 // 315 FunctionPass *createNewGVNPass(); 316 317 //===----------------------------------------------------------------------===// 318 // 319 // DivRemPairs - Hoist/decompose integer division and remainder instructions. 320 // 321 FunctionPass *createDivRemPairsPass(); 322 323 //===----------------------------------------------------------------------===// 324 // 325 // MemCpyOpt - This pass performs optimizations related to eliminating memcpy 326 // calls and/or combining multiple stores into memset's. 327 // 328 FunctionPass *createMemCpyOptPass(); 329 330 //===----------------------------------------------------------------------===// 331 // 332 // LoopDeletion - This pass performs DCE of non-infinite loops that it 333 // can prove are dead. 334 // 335 Pass *createLoopDeletionPass(); 336 337 //===----------------------------------------------------------------------===// 338 // 339 // ConstantHoisting - This pass prepares a function for expensive constants. 340 // 341 FunctionPass *createConstantHoistingPass(); 342 343 //===----------------------------------------------------------------------===// 344 // 345 // Sink - Code Sinking 346 // 347 FunctionPass *createSinkingPass(); 348 349 //===----------------------------------------------------------------------===// 350 // 351 // LowerAtomic - Lower atomic intrinsics to non-atomic form 352 // 353 Pass *createLowerAtomicPass(); 354 355 //===----------------------------------------------------------------------===// 356 // 357 // LowerGuardIntrinsic - Lower guard intrinsics to normal control flow. 358 // 359 Pass *createLowerGuardIntrinsicPass(); 360 361 //===----------------------------------------------------------------------===// 362 // 363 // MergeICmps - Merge integer comparison chains into a memcmp 364 // 365 Pass *createMergeICmpsPass(); 366 367 //===----------------------------------------------------------------------===// 368 // 369 // ValuePropagation - Propagate CFG-derived value information 370 // 371 Pass *createCorrelatedValuePropagationPass(); 372 373 //===----------------------------------------------------------------------===// 374 // 375 // InferAddressSpaces - Modify users of addrspacecast instructions with values 376 // in the source address space if using the destination address space is slower 377 // on the target. 378 // 379 FunctionPass *createInferAddressSpacesPass(); 380 extern char &InferAddressSpacesID; 381 382 //===----------------------------------------------------------------------===// 383 // 384 // LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates 385 // "block_weights" metadata. 386 FunctionPass *createLowerExpectIntrinsicPass(); 387 388 //===----------------------------------------------------------------------===// 389 // 390 // PartiallyInlineLibCalls - Tries to inline the fast path of library 391 // calls such as sqrt. 392 // 393 FunctionPass *createPartiallyInlineLibCallsPass(); 394 395 //===----------------------------------------------------------------------===// 396 // 397 // ScalarizerPass - Converts vector operations into scalar operations 398 // 399 FunctionPass *createScalarizerPass(); 400 401 //===----------------------------------------------------------------------===// 402 // 403 // SeparateConstOffsetFromGEP - Split GEPs for better CSE 404 // 405 FunctionPass *createSeparateConstOffsetFromGEPPass(bool LowerGEP = false); 406 407 //===----------------------------------------------------------------------===// 408 // 409 // SpeculativeExecution - Aggressively hoist instructions to enable 410 // speculative execution on targets where branches are expensive. 411 // 412 FunctionPass *createSpeculativeExecutionPass(); 413 414 // Same as createSpeculativeExecutionPass, but does nothing unless 415 // TargetTransformInfo::hasBranchDivergence() is true. 416 FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass(); 417 418 //===----------------------------------------------------------------------===// 419 // 420 // StraightLineStrengthReduce - This pass strength-reduces some certain 421 // instruction patterns in straight-line code. 422 // 423 FunctionPass *createStraightLineStrengthReducePass(); 424 425 //===----------------------------------------------------------------------===// 426 // 427 // PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any 428 // safepoint polls (method entry, backedge) that might be required. This pass 429 // does not generate explicit relocation sequences - that's handled by 430 // RewriteStatepointsForGC which can be run at an arbitrary point in the pass 431 // order following this pass. 432 // 433 FunctionPass *createPlaceSafepointsPass(); 434 435 //===----------------------------------------------------------------------===// 436 // 437 // RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have 438 // explicit relocations to include explicit relocations. 439 // 440 ModulePass *createRewriteStatepointsForGCLegacyPass(); 441 442 //===----------------------------------------------------------------------===// 443 // 444 // Float2Int - Demote floats to ints where possible. 445 // 446 FunctionPass *createFloat2IntPass(); 447 448 //===----------------------------------------------------------------------===// 449 // 450 // NaryReassociate - Simplify n-ary operations by reassociation. 451 // 452 FunctionPass *createNaryReassociatePass(); 453 454 //===----------------------------------------------------------------------===// 455 // 456 // LoopDistribute - Distribute loops. 457 // 458 FunctionPass *createLoopDistributePass(); 459 460 //===----------------------------------------------------------------------===// 461 // 462 // LoopLoadElimination - Perform loop-aware load elimination. 463 // 464 FunctionPass *createLoopLoadEliminationPass(); 465 466 //===----------------------------------------------------------------------===// 467 // 468 // LoopVersioning - Perform loop multi-versioning. 469 // 470 FunctionPass *createLoopVersioningPass(); 471 472 //===----------------------------------------------------------------------===// 473 // 474 // LoopDataPrefetch - Perform data prefetching in loops. 475 // 476 FunctionPass *createLoopDataPrefetchPass(); 477 478 ///===---------------------------------------------------------------------===// 479 ModulePass *createNameAnonGlobalPass(); 480 481 //===----------------------------------------------------------------------===// 482 // 483 // LibCallsShrinkWrap - Shrink-wraps a call to function if the result is not 484 // used. 485 // 486 FunctionPass *createLibCallsShrinkWrapPass(); 487 488 //===----------------------------------------------------------------------===// 489 // 490 // LoopSimplifyCFG - This pass performs basic CFG simplification on loops, 491 // primarily to help other loop passes. 492 // 493 Pass *createLoopSimplifyCFGPass(); 494 } // End llvm namespace 495 496 #endif 497