[StripGCRelocates] New pass to remove gc.relocates added by RS4GC
[lldb.git] / llvm / include / llvm / Transforms / Scalar.h
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 // LoopInterchange - This pass interchanges loops to provide a more
144 // cache-friendly memory access patterns.
145 //
146 Pass *createLoopInterchangePass();
147
148 //===----------------------------------------------------------------------===//
149 //
150 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use
151 // a loop's canonical induction variable as one of their indices.
152 //
153 Pass *createLoopStrengthReducePass();
154
155 //===----------------------------------------------------------------------===//
156 //
157 // LoopUnswitch - This pass is a simple loop unswitching pass.
158 //
159 Pass *createLoopUnswitchPass(bool OptimizeForSize = false);
160
161 //===----------------------------------------------------------------------===//
162 //
163 // LoopInstSimplify - This pass simplifies instructions in a loop's body.
164 //
165 Pass *createLoopInstSimplifyPass();
166
167 //===----------------------------------------------------------------------===//
168 //
169 // LoopUnroll - This pass is a simple loop unrolling pass.
170 //
171 Pass *createLoopUnrollPass(int Threshold = -1, int Count = -1,
172                            int AllowPartial = -1, int Runtime = -1,
173                            int UpperBound = -1);
174 // Create an unrolling pass for full unrolling that uses exact trip count only.
175 Pass *createSimpleLoopUnrollPass();
176
177 //===----------------------------------------------------------------------===//
178 //
179 // LoopReroll - This pass is a simple loop rerolling pass.
180 //
181 Pass *createLoopRerollPass();
182
183 //===----------------------------------------------------------------------===//
184 //
185 // LoopRotate - This pass is a simple loop rotating pass.
186 //
187 Pass *createLoopRotatePass(int MaxHeaderSize = -1);
188
189 //===----------------------------------------------------------------------===//
190 //
191 // LoopIdiom - This pass recognizes and replaces idioms in loops.
192 //
193 Pass *createLoopIdiomPass();
194
195 //===----------------------------------------------------------------------===//
196 //
197 // LoopVersioningLICM - This pass is a loop versioning pass for LICM.
198 //
199 Pass *createLoopVersioningLICMPass();
200
201 //===----------------------------------------------------------------------===//
202 //
203 // PromoteMemoryToRegister - This pass is used to promote memory references to
204 // be register references. A simple example of the transformation performed by
205 // this pass is:
206 //
207 //        FROM CODE                           TO CODE
208 //   %X = alloca i32, i32 1                 ret i32 42
209 //   store i32 42, i32 *%X
210 //   %Y = load i32* %X
211 //   ret i32 %Y
212 //
213 FunctionPass *createPromoteMemoryToRegisterPass();
214
215 //===----------------------------------------------------------------------===//
216 //
217 // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory
218 // references. In basically undoes the PromoteMemoryToRegister pass to make cfg
219 // hacking easier.
220 //
221 FunctionPass *createDemoteRegisterToMemoryPass();
222 extern char &DemoteRegisterToMemoryID;
223
224 //===----------------------------------------------------------------------===//
225 //
226 // Reassociate - This pass reassociates commutative expressions in an order that
227 // is designed to promote better constant propagation, GCSE, LICM, PRE...
228 //
229 // For example:  4 + (x + 5)  ->  x + (4 + 5)
230 //
231 FunctionPass *createReassociatePass();
232
233 //===----------------------------------------------------------------------===//
234 //
235 // JumpThreading - Thread control through mult-pred/multi-succ blocks where some
236 // preds always go to some succ. Thresholds other than minus one override the
237 // internal BB duplication default threshold.
238 //
239 FunctionPass *createJumpThreadingPass(int Threshold = -1);
240
241 //===----------------------------------------------------------------------===//
242 //
243 // CFGSimplification - Merge basic blocks, eliminate unreachable blocks,
244 // simplify terminator instructions, etc...
245 //
246 FunctionPass *createCFGSimplificationPass(
247     int Threshold = -1, std::function<bool(const Function &)> Ftor = nullptr);
248
249 //===----------------------------------------------------------------------===//
250 //
251 // FlattenCFG - flatten CFG, reduce number of conditional branches by using
252 // parallel-and and parallel-or mode, etc...
253 //
254 FunctionPass *createFlattenCFGPass();
255
256 //===----------------------------------------------------------------------===//
257 //
258 // CFG Structurization - Remove irreducible control flow
259 //
260 ///
261 /// When \p SkipUniformRegions is true the structizer will not structurize
262 /// regions that only contain uniform branches.
263 Pass *createStructurizeCFGPass(bool SkipUniformRegions = false);
264
265 //===----------------------------------------------------------------------===//
266 //
267 // BreakCriticalEdges - Break all of the critical edges in the CFG by inserting
268 // a dummy basic block. This pass may be "required" by passes that cannot deal
269 // with critical edges. For this usage, a pass must call:
270 //
271 //   AU.addRequiredID(BreakCriticalEdgesID);
272 //
273 // This pass obviously invalidates the CFG, but can update forward dominator
274 // (set, immediate dominators, tree, and frontier) information.
275 //
276 FunctionPass *createBreakCriticalEdgesPass();
277 extern char &BreakCriticalEdgesID;
278
279 //===----------------------------------------------------------------------===//
280 //
281 // LoopSimplify - Insert Pre-header blocks into the CFG for every function in
282 // the module.  This pass updates dominator information, loop information, and
283 // does not add critical edges to the CFG.
284 //
285 //   AU.addRequiredID(LoopSimplifyID);
286 //
287 Pass *createLoopSimplifyPass();
288 extern char &LoopSimplifyID;
289
290 //===----------------------------------------------------------------------===//
291 //
292 // TailCallElimination - This pass eliminates call instructions to the current
293 // function which occur immediately before return instructions.
294 //
295 FunctionPass *createTailCallEliminationPass();
296
297 //===----------------------------------------------------------------------===//
298 //
299 // LowerSwitch - This pass converts SwitchInst instructions into a sequence of
300 // chained binary branch instructions.
301 //
302 FunctionPass *createLowerSwitchPass();
303 extern char &LowerSwitchID;
304
305 //===----------------------------------------------------------------------===//
306 //
307 // LowerInvoke - This pass removes invoke instructions, converting them to call
308 // instructions.
309 //
310 FunctionPass *createLowerInvokePass();
311 extern char &LowerInvokePassID;
312
313 //===----------------------------------------------------------------------===//
314 //
315 // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop
316 // optimizations.
317 //
318 Pass *createLCSSAPass();
319 extern char &LCSSAID;
320
321 //===----------------------------------------------------------------------===//
322 //
323 // EarlyCSE - This pass performs a simple and fast CSE pass over the dominator
324 // tree.
325 //
326 FunctionPass *createEarlyCSEPass(bool UseMemorySSA = false);
327
328 //===----------------------------------------------------------------------===//
329 //
330 // GVNHoist - This pass performs a simple and fast GVN pass over the dominator
331 // tree to hoist common expressions from sibling branches.
332 //
333 FunctionPass *createGVNHoistPass();
334
335 //===----------------------------------------------------------------------===//
336 //
337 // MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads
338 // are hoisted into the header, while stores sink into the footer.
339 //
340 FunctionPass *createMergedLoadStoreMotionPass();
341
342 //===----------------------------------------------------------------------===//
343 //
344 // MemCpyOpt - This pass performs optimizations related to eliminating memcpy
345 // calls and/or combining multiple stores into memset's.
346 //
347 FunctionPass *createMemCpyOptPass();
348
349 //===----------------------------------------------------------------------===//
350 //
351 // LoopDeletion - This pass performs DCE of non-infinite loops that it
352 // can prove are dead.
353 //
354 Pass *createLoopDeletionPass();
355
356 //===----------------------------------------------------------------------===//
357 //
358 // ConstantHoisting - This pass prepares a function for expensive constants.
359 //
360 FunctionPass *createConstantHoistingPass();
361
362 //===----------------------------------------------------------------------===//
363 //
364 // InstructionNamer - Give any unnamed non-void instructions "tmp" names.
365 //
366 FunctionPass *createInstructionNamerPass();
367 extern char &InstructionNamerID;
368
369 //===----------------------------------------------------------------------===//
370 //
371 // Sink - Code Sinking
372 //
373 FunctionPass *createSinkingPass();
374
375 //===----------------------------------------------------------------------===//
376 //
377 // LowerAtomic - Lower atomic intrinsics to non-atomic form
378 //
379 Pass *createLowerAtomicPass();
380
381 //===----------------------------------------------------------------------===//
382 //
383 // LowerGuardIntrinsic - Lower guard intrinsics to normal control flow.
384 //
385 Pass *createLowerGuardIntrinsicPass();
386
387 //===----------------------------------------------------------------------===//
388 //
389 // ValuePropagation - Propagate CFG-derived value information
390 //
391 Pass *createCorrelatedValuePropagationPass();
392
393 //===----------------------------------------------------------------------===//
394 //
395 // InstructionSimplifier - Remove redundant instructions.
396 //
397 FunctionPass *createInstructionSimplifierPass();
398 extern char &InstructionSimplifierID;
399
400 //===----------------------------------------------------------------------===//
401 //
402 // LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates
403 // "block_weights" metadata.
404 FunctionPass *createLowerExpectIntrinsicPass();
405
406 //===----------------------------------------------------------------------===//
407 //
408 // PartiallyInlineLibCalls - Tries to inline the fast path of library
409 // calls such as sqrt.
410 //
411 FunctionPass *createPartiallyInlineLibCallsPass();
412
413 //===----------------------------------------------------------------------===//
414 //
415 // ScalarizerPass - Converts vector operations into scalar operations
416 //
417 FunctionPass *createScalarizerPass();
418
419 //===----------------------------------------------------------------------===//
420 //
421 // AddDiscriminators - Add DWARF path discriminators to the IR.
422 FunctionPass *createAddDiscriminatorsPass();
423
424 //===----------------------------------------------------------------------===//
425 //
426 // SeparateConstOffsetFromGEP - Split GEPs for better CSE
427 //
428 FunctionPass *
429 createSeparateConstOffsetFromGEPPass(const TargetMachine *TM = nullptr,
430                                      bool LowerGEP = false);
431
432 //===----------------------------------------------------------------------===//
433 //
434 // SpeculativeExecution - Aggressively hoist instructions to enable
435 // speculative execution on targets where branches are expensive.
436 //
437 FunctionPass *createSpeculativeExecutionPass();
438
439 // Same as createSpeculativeExecutionPass, but does nothing unless
440 // TargetTransformInfo::hasBranchDivergence() is true.
441 FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass();
442
443 //===----------------------------------------------------------------------===//
444 //
445 // LoadCombine - Combine loads into bigger loads.
446 //
447 BasicBlockPass *createLoadCombinePass();
448
449 //===----------------------------------------------------------------------===//
450 //
451 // StraightLineStrengthReduce - This pass strength-reduces some certain
452 // instruction patterns in straight-line code.
453 //
454 FunctionPass *createStraightLineStrengthReducePass();
455
456 //===----------------------------------------------------------------------===//
457 //
458 // PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any
459 // safepoint polls (method entry, backedge) that might be required.  This pass
460 // does not generate explicit relocation sequences - that's handled by
461 // RewriteStatepointsForGC which can be run at an arbitrary point in the pass
462 // order following this pass.
463 //
464 FunctionPass *createPlaceSafepointsPass();
465
466 //===----------------------------------------------------------------------===//
467 //
468 // RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have
469 // explicit relocations to include explicit relocations.
470 //
471 ModulePass *createRewriteStatepointsForGCPass();
472
473 //===----------------------------------------------------------------------===//
474 //
475 // StripGCRelocates - Remove GC relocates that have been inserted by
476 // RewriteStatepointsForGC. The resulting IR is incorrect, but this is useful
477 // for manual inspection.
478 FunctionPass *createStripGCRelocatesPass();
479
480 //===----------------------------------------------------------------------===//
481 //
482 // Float2Int - Demote floats to ints where possible.
483 //
484 FunctionPass *createFloat2IntPass();
485
486 //===----------------------------------------------------------------------===//
487 //
488 // NaryReassociate - Simplify n-ary operations by reassociation.
489 //
490 FunctionPass *createNaryReassociatePass();
491
492 //===----------------------------------------------------------------------===//
493 //
494 // LoopDistribute - Distribute loops.
495 //
496 // ProcessAllLoopsByDefault instructs the pass to look for distribution
497 // opportunities in all loops unless -enable-loop-distribute or the
498 // llvm.loop.distribute.enable metadata data override this default.
499 FunctionPass *createLoopDistributePass(bool ProcessAllLoopsByDefault);
500
501 //===----------------------------------------------------------------------===//
502 //
503 // LoopLoadElimination - Perform loop-aware load elimination.
504 //
505 FunctionPass *createLoopLoadEliminationPass();
506
507 //===----------------------------------------------------------------------===//
508 //
509 // LoopSimplifyCFG - This pass performs basic CFG simplification on loops,
510 // primarily to help other loop passes.
511 //
512 Pass *createLoopSimplifyCFGPass();
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
529 //===----------------------------------------------------------------------===//
530 //
531 // LibCallsShrinkWrap - Shrink-wraps a call to function if the result is not
532 // used.
533 //
534 FunctionPass *createLibCallsShrinkWrapPass();
535 } // End llvm namespace
536
537 #endif