LLVM  14.0.0git
Scalar.h
Go to the documentation of this file.
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 
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 //
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 //
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 //
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 //
122 
123 //===----------------------------------------------------------------------===//
124 //
125 // InductionVariableSimplify - Transform induction variables in a program to all
126 // use a single canonical induction variable per loop.
127 //
129 
130 //===----------------------------------------------------------------------===//
131 //
132 // LICM - This pass is a loop invariant code motion and memory promotion pass.
133 //
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 //
144 
145 //===----------------------------------------------------------------------===//
146 //
147 // LoopPredication - This pass does loop predication on guards.
148 //
150 
151 //===----------------------------------------------------------------------===//
152 //
153 // LoopInterchange - This pass interchanges loops to provide a more
154 // cache-friendly memory access patterns.
155 //
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 //
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 //
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 //
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 //
221 
222 //===----------------------------------------------------------------------===//
223 //
224 // LoopVersioningLICM - This pass is a loop versioning pass for LICM.
225 //
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 //
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 //
375 
376 //===----------------------------------------------------------------------===//
377 //
378 // LowerGuardIntrinsic - Lower guard intrinsics to normal control flow.
379 //
381 
382 //===----------------------------------------------------------------------===//
383 //
384 // LowerMatrixIntrinsics - Lower matrix intrinsics to vector operations.
385 //
387 
388 //===----------------------------------------------------------------------===//
389 //
390 // LowerMatrixIntrinsicsMinimal - Lower matrix intrinsics to vector operations
391 // (lightweight, does not require extra analysis)
392 //
394 
395 //===----------------------------------------------------------------------===//
396 //
397 // LowerWidenableCondition - Lower widenable condition to i1 true.
398 //
400 
401 //===----------------------------------------------------------------------===//
402 //
403 // MergeICmps - Merge integer comparison chains into a memcmp
404 //
406 
407 //===----------------------------------------------------------------------===//
408 //
409 // ValuePropagation - Propagate CFG-derived value information
410 //
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.
459 
460 //===----------------------------------------------------------------------===//
461 //
462 // StraightLineStrengthReduce - This pass strength-reduces some certain
463 // instruction patterns in straight-line code.
464 //
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 //
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 //
543 
544 //===----------------------------------------------------------------------===//
545 //
546 // WarnMissedTransformations - This pass emits warnings for leftover forced
547 // transformations.
548 //
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 //
565 } // End llvm namespace
566 
567 #endif
llvm::createLoopLoadEliminationPass
FunctionPass * createLoopLoadEliminationPass()
Definition: LoopLoadElimination.cpp:704
llvm::createMergedLoadStoreMotionPass
FunctionPass * createMergedLoadStoreMotionPass(bool SplitFooterBB=false)
createMergedLoadStoreMotionPass - The public interface to this file.
Definition: MergedLoadStoreMotion.cpp:401
llvm::createGVNSinkPass
FunctionPass * createGVNSinkPass()
Definition: GVNSink.cpp:927
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::createTailCallEliminationPass
FunctionPass * createTailCallEliminationPass()
Definition: TailRecursionElimination.cpp:920
llvm::createSeparateConstOffsetFromGEPPass
FunctionPass * createSeparateConstOffsetFromGEPPass(bool LowerGEP=false)
Definition: SeparateConstOffsetFromGEP.cpp:499
Pass
print lazy value Lazy Value Info Printer Pass
Definition: LazyValueInfo.cpp:1966
llvm::InferAddressSpacesID
char & InferAddressSpacesID
llvm::createCFGSimplificationPass
FunctionPass * createCFGSimplificationPass(SimplifyCFGOptions Options=SimplifyCFGOptions(), std::function< bool(const Function &)> Ftor=nullptr)
Definition: SimplifyCFGPass.cpp:400
llvm::createLoopSimplifyCFGPass
Pass * createLoopSimplifyCFGPass()
Definition: LoopSimplifyCFG.cpp:771
llvm::DemoteRegisterToMemoryID
char & DemoteRegisterToMemoryID
Definition: Reg2Mem.cpp:138
llvm::createPlaceSafepointsPass
FunctionPass * createPlaceSafepointsPass()
Definition: PlaceSafepoints.cpp:601
llvm::createFlattenCFGPass
FunctionPass * createFlattenCFGPass()
Definition: FlattenCFGPass.cpp:52
llvm::createEarlyCSEPass
FunctionPass * createEarlyCSEPass(bool UseMemorySSA=false)
Definition: EarlyCSE.cpp:1719
llvm::createLoopIdiomPass
Pass * createLoopIdiomPass()
Definition: LoopIdiomRecognize.cpp:346
llvm::createDeadStoreEliminationPass
FunctionPass * createDeadStoreEliminationPass()
Definition: DeadStoreElimination.cpp:2199
llvm::createGuardWideningPass
FunctionPass * createGuardWideningPass()
Definition: GuardWidening.cpp:875
llvm::createLoopStrengthReducePass
Pass * createLoopStrengthReducePass()
Definition: LoopStrengthReduce.cpp:6382
llvm::createMemCpyOptPass
FunctionPass * createMemCpyOptPass()
The public interface to this file...
Definition: MemCpyOptimizer.cpp:301
llvm::createCallSiteSplittingPass
FunctionPass * createCallSiteSplittingPass()
Definition: CallSiteSplitting.cpp:575
llvm::createNameAnonGlobalPass
ModulePass * createNameAnonGlobalPass()
===------------------------------------------------------------------—===//
Definition: NameAnonGlobals.cpp:117
llvm::createRewriteStatepointsForGCLegacyPass
ModulePass * createRewriteStatepointsForGCLegacyPass()
Definition: RewriteStatepointsForGC.cpp:218
llvm::createLoopGuardWideningPass
Pass * createLoopGuardWideningPass()
Definition: GuardWidening.cpp:879
llvm::createFloat2IntPass
FunctionPass * createFloat2IntPass()
Definition: Float2Int.cpp:539
llvm::createDivRemPairsPass
FunctionPass * createDivRemPairsPass()
Definition: DivRemPairs.cpp:429
llvm::createLoopUnswitchPass
Pass * createLoopUnswitchPass(bool OptimizeForSize=false, bool hasBranchDivergence=false)
Definition: LoopUnswitch.cpp:412
llvm::createInferAddressSpacesPass
FunctionPass * createInferAddressSpacesPass(unsigned AddressSpace=~0u)
Definition: InferAddressSpaces.cpp:1208
llvm::createDFAJumpThreadingPass
FunctionPass * createDFAJumpThreadingPass()
Definition: DFAJumpThreading.cpp:208
llvm::createLoopSinkPass
Pass * createLoopSinkPass()
llvm::createLoopInterchangePass
Pass * createLoopInterchangePass()
Definition: LoopInterchange.cpp:1810
llvm::createCanonicalizeAliasesPass
ModulePass * createCanonicalizeAliasesPass()
Definition: CanonicalizeAliases.cpp:102
llvm::createConstantHoistingPass
FunctionPass * createConstantHoistingPass()
Definition: ConstantHoisting.cpp:138
llvm::createNaryReassociatePass
FunctionPass * createNaryReassociatePass()
Definition: NaryReassociate.cpp:165
llvm::createLowerMatrixIntrinsicsPass
Pass * createLowerMatrixIntrinsicsPass()
Definition: LowerMatrixIntrinsics.cpp:2309
llvm::createLoopVersioningLICMPass
Pass * createLoopVersioningLICMPass()
Definition: LoopVersioningLICM.cpp:660
llvm::createNewGVNPass
FunctionPass * createNewGVNPass()
Definition: NewGVN.cpp:4207
llvm::createLibCallsShrinkWrapPass
FunctionPass * createLibCallsShrinkWrapPass()
Definition: LibCallsShrinkWrap.cpp:547
Options
const char LLVMTargetMachineRef LLVMPassBuilderOptionsRef Options
Definition: PassBuilderBindings.cpp:48
llvm::createIndVarSimplifyPass
Pass * createIndVarSimplifyPass()
Definition: IndVarSimplify.cpp:1986
llvm::createAnnotationRemarksLegacyPass
FunctionPass * createAnnotationRemarksLegacyPass()
Definition: AnnotationRemarks.cpp:120
llvm::createLoopDistributePass
FunctionPass * createLoopDistributePass()
llvm::createSinkingPass
FunctionPass * createSinkingPass()
Definition: Sink.cpp:284
llvm::createSpeculativeExecutionPass
FunctionPass * createSpeculativeExecutionPass()
Definition: SpeculativeExecution.cpp:325
llvm::AddressSpace
AddressSpace
Definition: NVPTXBaseInfo.h:21
llvm::createSimpleLoopUnrollPass
Pass * createSimpleLoopUnrollPass(int OptLevel=2, bool OnlyWhenForced=false, bool ForgetAllSCEV=false)
Definition: LoopUnrollPass.cpp:1361
llvm::createRedundantDbgInstEliminationPass
Pass * createRedundantDbgInstEliminationPass()
llvm::createLoopRerollPass
Pass * createLoopRerollPass()
Definition: LoopRerollPass.cpp:506
llvm::createGVNHoistPass
FunctionPass * createGVNHoistPass()
Definition: GVNHoist.cpp:1261
llvm::createLoopFusePass
FunctionPass * createLoopFusePass()
llvm::createLowerExpectIntrinsicPass
FunctionPass * createLowerExpectIntrinsicPass()
llvm::createLowerAtomicPass
Pass * createLowerAtomicPass()
llvm::createPartiallyInlineLibCallsPass
FunctionPass * createPartiallyInlineLibCallsPass()
Definition: PartiallyInlineLibCalls.cpp:211
llvm::createCorrelatedValuePropagationPass
Pass * createCorrelatedValuePropagationPass()
Definition: CorrelatedValuePropagation.cpp:126
llvm::createDemoteRegisterToMemoryPass
FunctionPass * createDemoteRegisterToMemoryPass()
Definition: Reg2Mem.cpp:139
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::createSCCPPass
FunctionPass * createSCCPPass()
Definition: SCCP.cpp:291
llvm::createInductiveRangeCheckEliminationPass
Pass * createInductiveRangeCheckEliminationPass()
Definition: InductiveRangeCheckElimination.cpp:1995
llvm::createStructurizeCFGPass
Pass * createStructurizeCFGPass(bool SkipUniformRegions=false)
When SkipUniformRegions is true the structizer will not structurize regions that only contain uniform...
Definition: StructurizeCFG.cpp:1086
llvm::createReassociatePass
FunctionPass * createReassociatePass()
llvm::createLowerGuardIntrinsicPass
Pass * createLowerGuardIntrinsicPass()
llvm::createAggressiveDCEPass
FunctionPass * createAggressiveDCEPass()
Definition: ADCE.cpp:752
llvm::createScalarizeMaskedMemIntrinLegacyPass
FunctionPass * createScalarizeMaskedMemIntrinLegacyPass()
Definition: ScalarizeMaskedMemIntrin.cpp:89
llvm::createBitTrackingDCEPass
FunctionPass * createBitTrackingDCEPass()
Definition: BDCE.cpp:205
llvm::createAlignmentFromAssumptionsPass
FunctionPass * createAlignmentFromAssumptionsPass()
Definition: AlignmentFromAssumptions.cpp:86
llvm::createLoopRotatePass
Pass * createLoopRotatePass(int MaxHeaderSize=-1, bool PrepareForLTO=false)
Definition: LoopRotation.cpp:156
llvm::createInstSimplifyLegacyPass
FunctionPass * createInstSimplifyLegacyPass()
Definition: InstSimplifyPass.cpp:129
llvm::createLoopInstSimplifyPass
Pass * createLoopInstSimplifyPass()
Definition: LoopInstSimplify.cpp:255
SimplifyCFGOptions.h
llvm::createLICMPass
Pass * createLICMPass()
Definition: LICM.cpp:336
llvm::createConstraintEliminationPass
FunctionPass * createConstraintEliminationPass()
Definition: ConstraintElimination.cpp:516
llvm::createLoopPredicationPass
Pass * createLoopPredicationPass()
Definition: LoopPredication.cpp:354
llvm::createLowerConstantIntrinsicsPass
FunctionPass * createLowerConstantIntrinsicsPass()
Definition: LowerConstantIntrinsics.cpp:197
llvm::createStraightLineStrengthReducePass
FunctionPass * createStraightLineStrengthReducePass()
Definition: StraightLineStrengthReduce.cpp:269
llvm::createLoopFlattenPass
FunctionPass * createLoopFlattenPass()
Definition: LoopFlatten.cpp:745
Threshold
static cl::opt< unsigned > Threshold("loop-unswitch-threshold", cl::desc("Max loop size to unswitch"), cl::init(100), cl::Hidden)
llvm::createLowerWidenableConditionPass
Pass * createLowerWidenableConditionPass()
llvm::createWarnMissedTransformationsPass
Pass * createWarnMissedTransformationsPass()
Definition: WarnMissedTransforms.cpp:148
llvm::createDeadCodeEliminationPass
FunctionPass * createDeadCodeEliminationPass()
Definition: DCE.cpp:178
llvm::createSpeculativeExecutionIfHasBranchDivergencePass
FunctionPass * createSpeculativeExecutionIfHasBranchDivergencePass()
Definition: SpeculativeExecution.cpp:329
llvm::createLowerMatrixIntrinsicsMinimalPass
Pass * createLowerMatrixIntrinsicsMinimalPass()
Definition: LowerMatrixIntrinsics.cpp:2351
llvm::createLoopDeletionPass
Pass * createLoopDeletionPass()
Definition: LoopDeletion.cpp:550
llvm::createSROAPass
FunctionPass * createSROAPass()
Definition: SROA.cpp:4849
llvm::createLoopVersioningPass
FunctionPass * createLoopVersioningPass()
llvm::createLoopUnrollAndJamPass
Pass * createLoopUnrollAndJamPass(int OptLevel=2)
Definition: LoopUnrollAndJamPass.cpp:523
llvm::codeview::PublicSymFlags::Function
@ Function
llvm::createJumpThreadingPass
FunctionPass * createJumpThreadingPass(bool FreezeSelectCond=false, int Threshold=-1)
Definition: JumpThreading.cpp:178
llvm::createLoopDataPrefetchPass
FunctionPass * createLoopDataPrefetchPass()
Definition: LoopDataPrefetch.cpp:151
llvm::createLoopUnrollPass
Pass * createLoopUnrollPass(int OptLevel=2, bool OnlyWhenForced=false, bool ForgetAllSCEV=false, int Threshold=-1, int Count=-1, int AllowPartial=-1, int Runtime=-1, int UpperBound=-1, int AllowPeeling=-1)
Definition: LoopUnrollPass.cpp:1344
llvm::createMergeICmpsLegacyPass
Pass * createMergeICmpsLegacyPass()
Definition: MergeICmps.cpp:914