1 //===-- Scalar.h - Scalar Transformations -----------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This header file defines prototypes for accessor functions that expose passes 10 // in the Scalar transformations library. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_TRANSFORMS_SCALAR_H 15 #define LLVM_TRANSFORMS_SCALAR_H 16 17 #include "llvm/Transforms/Utils/SimplifyCFGOptions.h" 18 #include <functional> 19 20 namespace llvm { 21 22 class Function; 23 class FunctionPass; 24 class ModulePass; 25 class Pass; 26 27 //===----------------------------------------------------------------------===// 28 // 29 // AlignmentFromAssumptions - Use assume intrinsics to set load/store 30 // alignments. 31 // 32 FunctionPass *createAlignmentFromAssumptionsPass(); 33 34 //===----------------------------------------------------------------------===// 35 // 36 // AnnotationRemarks - Emit remarks for !annotation metadata. 37 // 38 FunctionPass *createAnnotationRemarksLegacyPass(); 39 40 //===----------------------------------------------------------------------===// 41 // 42 // SCCP - Sparse conditional constant propagation. 43 // 44 FunctionPass *createSCCPPass(); 45 46 //===----------------------------------------------------------------------===// 47 // 48 // RedundantDbgInstElimination - This pass removes redundant dbg intrinsics 49 // without modifying the CFG of the function. It is a FunctionPass. 50 // 51 Pass *createRedundantDbgInstEliminationPass(); 52 53 //===----------------------------------------------------------------------===// 54 // 55 // DeadCodeElimination - This pass is more powerful than DeadInstElimination, 56 // because it is worklist driven that can potentially revisit instructions when 57 // their other instructions become dead, to eliminate chains of dead 58 // computations. 59 // 60 FunctionPass *createDeadCodeEliminationPass(); 61 62 //===----------------------------------------------------------------------===// 63 // 64 // DeadStoreElimination - This pass deletes stores that are post-dominated by 65 // must-aliased stores and are not loaded used between the stores. 66 // 67 FunctionPass *createDeadStoreEliminationPass(); 68 69 70 //===----------------------------------------------------------------------===// 71 // 72 // CallSiteSplitting - This pass split call-site based on its known argument 73 // values. 74 FunctionPass *createCallSiteSplittingPass(); 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 // GuardWidening - An optimization over the @llvm.experimental.guard intrinsic 87 // that (optimistically) combines multiple guards into one to have fewer checks 88 // at runtime. 89 // 90 FunctionPass *createGuardWideningPass(); 91 92 93 //===----------------------------------------------------------------------===// 94 // 95 // LoopGuardWidening - Analogous to the GuardWidening pass, but restricted to a 96 // single loop at a time for use within a LoopPassManager. Desired effect is 97 // to widen guards into preheader or a single guard within loop if that's not 98 // possible. 99 // 100 Pass *createLoopGuardWideningPass(); 101 102 103 //===----------------------------------------------------------------------===// 104 // 105 // BitTrackingDCE - This pass uses a bit-tracking DCE algorithm in order to 106 // remove computations of dead bits. 107 // 108 FunctionPass *createBitTrackingDCEPass(); 109 110 //===----------------------------------------------------------------------===// 111 // 112 // SROA - Replace aggregates or pieces of aggregates with scalar SSA values. 113 // 114 FunctionPass *createSROAPass(); 115 116 //===----------------------------------------------------------------------===// 117 // 118 // InductiveRangeCheckElimination - Transform loops to elide range checks on 119 // linear functions of the induction variable. 120 // 121 Pass *createInductiveRangeCheckEliminationPass(); 122 123 //===----------------------------------------------------------------------===// 124 // 125 // InductionVariableSimplify - Transform induction variables in a program to all 126 // use a single canonical induction variable per loop. 127 // 128 Pass *createIndVarSimplifyPass(); 129 130 //===----------------------------------------------------------------------===// 131 // 132 // LICM - This pass is a loop invariant code motion and memory promotion pass. 133 // 134 Pass *createLICMPass(); 135 Pass *createLICMPass(unsigned LicmMssaOptCap, 136 unsigned LicmMssaNoAccForPromotionCap); 137 138 //===----------------------------------------------------------------------===// 139 // 140 // LoopSink - This pass sinks invariants from preheader to loop body where 141 // frequency is lower than loop preheader. 142 // 143 Pass *createLoopSinkPass(); 144 145 //===----------------------------------------------------------------------===// 146 // 147 // LoopPredication - This pass does loop predication on guards. 148 // 149 Pass *createLoopPredicationPass(); 150 151 //===----------------------------------------------------------------------===// 152 // 153 // LoopInterchange - This pass interchanges loops to provide a more 154 // cache-friendly memory access patterns. 155 // 156 Pass *createLoopInterchangePass(); 157 158 //===----------------------------------------------------------------------===// 159 // 160 // LoopFlatten - This pass flattens nested loops into a single loop. 161 // 162 FunctionPass *createLoopFlattenPass(); 163 164 //===----------------------------------------------------------------------===// 165 // 166 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use 167 // a loop's canonical induction variable as one of their indices. 168 // 169 Pass *createLoopStrengthReducePass(); 170 171 //===----------------------------------------------------------------------===// 172 // 173 // LoopUnswitch - This pass is a simple loop unswitching pass. 174 // 175 Pass *createLoopUnswitchPass(bool OptimizeForSize = false, 176 bool hasBranchDivergence = false); 177 178 //===----------------------------------------------------------------------===// 179 // 180 // LoopInstSimplify - This pass simplifies instructions in a loop's body. 181 // 182 Pass *createLoopInstSimplifyPass(); 183 184 //===----------------------------------------------------------------------===// 185 // 186 // LoopUnroll - This pass is a simple loop unrolling pass. 187 // 188 Pass *createLoopUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false, 189 bool ForgetAllSCEV = false, int Threshold = -1, 190 int Count = -1, int AllowPartial = -1, 191 int Runtime = -1, int UpperBound = -1, 192 int AllowPeeling = -1); 193 // Create an unrolling pass for full unrolling that uses exact trip count only 194 // and also does peeling. 195 Pass *createSimpleLoopUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false, 196 bool ForgetAllSCEV = false); 197 198 //===----------------------------------------------------------------------===// 199 // 200 // LoopUnrollAndJam - This pass is a simple loop unroll and jam pass. 201 // 202 Pass *createLoopUnrollAndJamPass(int OptLevel = 2); 203 204 //===----------------------------------------------------------------------===// 205 // 206 // LoopReroll - This pass is a simple loop rerolling pass. 207 // 208 Pass *createLoopRerollPass(); 209 210 //===----------------------------------------------------------------------===// 211 // 212 // LoopRotate - This pass is a simple loop rotating pass. 213 // 214 Pass *createLoopRotatePass(int MaxHeaderSize = -1, bool PrepareForLTO = false); 215 216 //===----------------------------------------------------------------------===// 217 // 218 // LoopIdiom - This pass recognizes and replaces idioms in loops. 219 // 220 Pass *createLoopIdiomPass(); 221 222 //===----------------------------------------------------------------------===// 223 // 224 // LoopVersioningLICM - This pass is a loop versioning pass for LICM. 225 // 226 Pass *createLoopVersioningLICMPass(); 227 228 //===----------------------------------------------------------------------===// 229 // 230 // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory 231 // references. In basically undoes the PromoteMemoryToRegister pass to make cfg 232 // hacking easier. 233 // 234 FunctionPass *createDemoteRegisterToMemoryPass(); 235 extern char &DemoteRegisterToMemoryID; 236 237 //===----------------------------------------------------------------------===// 238 // 239 // Reassociate - This pass reassociates commutative expressions in an order that 240 // is designed to promote better constant propagation, GCSE, LICM, PRE... 241 // 242 // For example: 4 + (x + 5) -> x + (4 + 5) 243 // 244 FunctionPass *createReassociatePass(); 245 246 //===----------------------------------------------------------------------===// 247 // 248 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some 249 // preds always go to some succ. If FreezeSelectCond is true, unfold the 250 // condition of a select that unfolds to branch. Thresholds other than minus one 251 // override the internal BB duplication default threshold. 252 // 253 FunctionPass *createJumpThreadingPass(bool FreezeSelectCond = false, 254 int Threshold = -1); 255 256 //===----------------------------------------------------------------------===// 257 // 258 // DFAJumpThreading - When a switch statement inside a loop is used to 259 // implement a deterministic finite automata we can jump thread the switch 260 // statement reducing number of conditional jumps. 261 // 262 FunctionPass *createDFAJumpThreadingPass(); 263 264 //===----------------------------------------------------------------------===// 265 // 266 // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, 267 // simplify terminator instructions, convert switches to lookup tables, etc. 268 // 269 FunctionPass *createCFGSimplificationPass( 270 SimplifyCFGOptions Options = SimplifyCFGOptions(), 271 std::function<bool(const Function &)> Ftor = nullptr); 272 273 //===----------------------------------------------------------------------===// 274 // 275 // FlattenCFG - flatten CFG, reduce number of conditional branches by using 276 // parallel-and and parallel-or mode, etc... 277 // 278 FunctionPass *createFlattenCFGPass(); 279 280 //===----------------------------------------------------------------------===// 281 // 282 // CFG Structurization - Remove irreducible control flow 283 // 284 /// 285 /// When \p SkipUniformRegions is true the structizer will not structurize 286 /// regions that only contain uniform branches. 287 Pass *createStructurizeCFGPass(bool SkipUniformRegions = false); 288 289 //===----------------------------------------------------------------------===// 290 // 291 // TailCallElimination - This pass eliminates call instructions to the current 292 // function which occur immediately before return instructions. 293 // 294 FunctionPass *createTailCallEliminationPass(); 295 296 //===----------------------------------------------------------------------===// 297 // 298 // EarlyCSE - This pass performs a simple and fast CSE pass over the dominator 299 // tree. 300 // 301 FunctionPass *createEarlyCSEPass(bool UseMemorySSA = false); 302 303 //===----------------------------------------------------------------------===// 304 // 305 // GVNHoist - This pass performs a simple and fast GVN pass over the dominator 306 // tree to hoist common expressions from sibling branches. 307 // 308 FunctionPass *createGVNHoistPass(); 309 310 //===----------------------------------------------------------------------===// 311 // 312 // GVNSink - This pass uses an "inverted" value numbering to decide the 313 // similarity of expressions and sinks similar expressions into successors. 314 // 315 FunctionPass *createGVNSinkPass(); 316 317 //===----------------------------------------------------------------------===// 318 // 319 // MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads 320 // are hoisted into the header, while stores sink into the footer. 321 // 322 FunctionPass *createMergedLoadStoreMotionPass(bool SplitFooterBB = false); 323 324 //===----------------------------------------------------------------------===// 325 // 326 // GVN - This pass performs global value numbering and redundant load 327 // elimination cotemporaneously. 328 // 329 FunctionPass *createNewGVNPass(); 330 331 //===----------------------------------------------------------------------===// 332 // 333 // DivRemPairs - Hoist/decompose integer division and remainder instructions. 334 // 335 FunctionPass *createDivRemPairsPass(); 336 337 //===----------------------------------------------------------------------===// 338 // 339 // MemCpyOpt - This pass performs optimizations related to eliminating memcpy 340 // calls and/or combining multiple stores into memset's. 341 // 342 FunctionPass *createMemCpyOptPass(); 343 344 //===----------------------------------------------------------------------===// 345 // 346 // LoopDeletion - This pass performs DCE of non-infinite loops that it 347 // can prove are dead. 348 // 349 Pass *createLoopDeletionPass(); 350 351 //===----------------------------------------------------------------------===// 352 // 353 // ConstantHoisting - This pass prepares a function for expensive constants. 354 // 355 FunctionPass *createConstantHoistingPass(); 356 357 //===----------------------------------------------------------------------===// 358 // 359 // ConstraintElimination - This pass eliminates conditions based on found 360 // constraints. 361 // 362 FunctionPass *createConstraintEliminationPass(); 363 364 //===----------------------------------------------------------------------===// 365 // 366 // Sink - Code Sinking 367 // 368 FunctionPass *createSinkingPass(); 369 370 //===----------------------------------------------------------------------===// 371 // 372 // LowerAtomic - Lower atomic intrinsics to non-atomic form 373 // 374 Pass *createLowerAtomicPass(); 375 376 //===----------------------------------------------------------------------===// 377 // 378 // LowerGuardIntrinsic - Lower guard intrinsics to normal control flow. 379 // 380 Pass *createLowerGuardIntrinsicPass(); 381 382 //===----------------------------------------------------------------------===// 383 // 384 // LowerMatrixIntrinsics - Lower matrix intrinsics to vector operations. 385 // 386 Pass *createLowerMatrixIntrinsicsPass(); 387 388 //===----------------------------------------------------------------------===// 389 // 390 // LowerMatrixIntrinsicsMinimal - Lower matrix intrinsics to vector operations 391 // (lightweight, does not require extra analysis) 392 // 393 Pass *createLowerMatrixIntrinsicsMinimalPass(); 394 395 //===----------------------------------------------------------------------===// 396 // 397 // LowerWidenableCondition - Lower widenable condition to i1 true. 398 // 399 Pass *createLowerWidenableConditionPass(); 400 401 //===----------------------------------------------------------------------===// 402 // 403 // MergeICmps - Merge integer comparison chains into a memcmp 404 // 405 Pass *createMergeICmpsLegacyPass(); 406 407 //===----------------------------------------------------------------------===// 408 // 409 // ValuePropagation - Propagate CFG-derived value information 410 // 411 Pass *createCorrelatedValuePropagationPass(); 412 413 //===----------------------------------------------------------------------===// 414 // 415 // InferAddressSpaces - Modify users of addrspacecast instructions with values 416 // in the source address space if using the destination address space is slower 417 // on the target. If AddressSpace is left to its default value, it will be 418 // obtained from the TargetTransformInfo. 419 // 420 FunctionPass *createInferAddressSpacesPass(unsigned AddressSpace = ~0u); 421 extern char &InferAddressSpacesID; 422 423 //===----------------------------------------------------------------------===// 424 // 425 // LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates 426 // "block_weights" metadata. 427 FunctionPass *createLowerExpectIntrinsicPass(); 428 429 //===----------------------------------------------------------------------===// 430 // 431 // LowerConstantIntrinsicss - Expand any remaining llvm.objectsize and 432 // llvm.is.constant intrinsic calls, even for the unknown cases. 433 // 434 FunctionPass *createLowerConstantIntrinsicsPass(); 435 436 //===----------------------------------------------------------------------===// 437 // 438 // PartiallyInlineLibCalls - Tries to inline the fast path of library 439 // calls such as sqrt. 440 // 441 FunctionPass *createPartiallyInlineLibCallsPass(); 442 443 //===----------------------------------------------------------------------===// 444 // 445 // SeparateConstOffsetFromGEP - Split GEPs for better CSE 446 // 447 FunctionPass *createSeparateConstOffsetFromGEPPass(bool LowerGEP = false); 448 449 //===----------------------------------------------------------------------===// 450 // 451 // SpeculativeExecution - Aggressively hoist instructions to enable 452 // speculative execution on targets where branches are expensive. 453 // 454 FunctionPass *createSpeculativeExecutionPass(); 455 456 // Same as createSpeculativeExecutionPass, but does nothing unless 457 // TargetTransformInfo::hasBranchDivergence() is true. 458 FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass(); 459 460 //===----------------------------------------------------------------------===// 461 // 462 // StraightLineStrengthReduce - This pass strength-reduces some certain 463 // instruction patterns in straight-line code. 464 // 465 FunctionPass *createStraightLineStrengthReducePass(); 466 467 //===----------------------------------------------------------------------===// 468 // 469 // PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any 470 // safepoint polls (method entry, backedge) that might be required. This pass 471 // does not generate explicit relocation sequences - that's handled by 472 // RewriteStatepointsForGC which can be run at an arbitrary point in the pass 473 // order following this pass. 474 // 475 FunctionPass *createPlaceSafepointsPass(); 476 477 //===----------------------------------------------------------------------===// 478 // 479 // RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have 480 // explicit relocations to include explicit relocations. 481 // 482 ModulePass *createRewriteStatepointsForGCLegacyPass(); 483 484 //===----------------------------------------------------------------------===// 485 // 486 // Float2Int - Demote floats to ints where possible. 487 // 488 FunctionPass *createFloat2IntPass(); 489 490 //===----------------------------------------------------------------------===// 491 // 492 // NaryReassociate - Simplify n-ary operations by reassociation. 493 // 494 FunctionPass *createNaryReassociatePass(); 495 496 //===----------------------------------------------------------------------===// 497 // 498 // LoopDistribute - Distribute loops. 499 // 500 FunctionPass *createLoopDistributePass(); 501 502 //===----------------------------------------------------------------------===// 503 // 504 // LoopFuse - Fuse loops. 505 // 506 FunctionPass *createLoopFusePass(); 507 508 //===----------------------------------------------------------------------===// 509 // 510 // LoopLoadElimination - Perform loop-aware load elimination. 511 // 512 FunctionPass *createLoopLoadEliminationPass(); 513 514 //===----------------------------------------------------------------------===// 515 // 516 // LoopVersioning - Perform loop multi-versioning. 517 // 518 FunctionPass *createLoopVersioningPass(); 519 520 //===----------------------------------------------------------------------===// 521 // 522 // LoopDataPrefetch - Perform data prefetching in loops. 523 // 524 FunctionPass *createLoopDataPrefetchPass(); 525 526 ///===---------------------------------------------------------------------===// 527 ModulePass *createNameAnonGlobalPass(); 528 ModulePass *createCanonicalizeAliasesPass(); 529 530 //===----------------------------------------------------------------------===// 531 // 532 // LibCallsShrinkWrap - Shrink-wraps a call to function if the result is not 533 // used. 534 // 535 FunctionPass *createLibCallsShrinkWrapPass(); 536 537 //===----------------------------------------------------------------------===// 538 // 539 // LoopSimplifyCFG - This pass performs basic CFG simplification on loops, 540 // primarily to help other loop passes. 541 // 542 Pass *createLoopSimplifyCFGPass(); 543 544 //===----------------------------------------------------------------------===// 545 // 546 // WarnMissedTransformations - This pass emits warnings for leftover forced 547 // transformations. 548 // 549 Pass *createWarnMissedTransformationsPass(); 550 551 //===----------------------------------------------------------------------===// 552 // 553 // This pass does instruction simplification on each 554 // instruction in a function. 555 // 556 FunctionPass *createInstSimplifyLegacyPass(); 557 558 559 //===----------------------------------------------------------------------===// 560 // 561 // createScalarizeMaskedMemIntrinPass - Replace masked load, store, gather 562 // and scatter intrinsics with scalar code when target doesn't support them. 563 // 564 FunctionPass *createScalarizeMaskedMemIntrinLegacyPass(); 565 } // End llvm namespace 566 567 #endif 568