Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
14 pmbaty 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
// SCCP - Sparse conditional constant propagation.
37
//
38
FunctionPass *createSCCPPass();
39
 
40
//===----------------------------------------------------------------------===//
41
//
42
// RedundantDbgInstElimination - This pass removes redundant dbg intrinsics
43
// without modifying the CFG of the function.  It is a FunctionPass.
44
//
45
Pass *createRedundantDbgInstEliminationPass();
46
 
47
//===----------------------------------------------------------------------===//
48
//
49
// DeadCodeElimination - This pass is more powerful than DeadInstElimination,
50
// because it is worklist driven that can potentially revisit instructions when
51
// their other instructions become dead, to eliminate chains of dead
52
// computations.
53
//
54
FunctionPass *createDeadCodeEliminationPass();
55
 
56
//===----------------------------------------------------------------------===//
57
//
58
// DeadStoreElimination - This pass deletes stores that are post-dominated by
59
// must-aliased stores and are not loaded used between the stores.
60
//
61
FunctionPass *createDeadStoreEliminationPass();
62
 
63
 
64
//===----------------------------------------------------------------------===//
65
//
66
// CallSiteSplitting - This pass split call-site based on its known argument
67
// values.
68
FunctionPass *createCallSiteSplittingPass();
69
 
70
//===----------------------------------------------------------------------===//
71
//
72
// AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm.  This
73
// algorithm assumes instructions are dead until proven otherwise, which makes
74
// it more successful are removing non-obviously dead instructions.
75
//
76
FunctionPass *createAggressiveDCEPass();
77
 
78
//===----------------------------------------------------------------------===//
79
//
80
// GuardWidening - An optimization over the @llvm.experimental.guard intrinsic
81
// that (optimistically) combines multiple guards into one to have fewer checks
82
// at runtime.
83
//
84
FunctionPass *createGuardWideningPass();
85
 
86
 
87
//===----------------------------------------------------------------------===//
88
//
89
// LoopGuardWidening - Analogous to the GuardWidening pass, but restricted to a
90
// single loop at a time for use within a LoopPassManager.  Desired effect is
91
// to widen guards into preheader or a single guard within loop if that's not
92
// possible.
93
//
94
Pass *createLoopGuardWideningPass();
95
 
96
 
97
//===----------------------------------------------------------------------===//
98
//
99
// BitTrackingDCE - This pass uses a bit-tracking DCE algorithm in order to
100
// remove computations of dead bits.
101
//
102
FunctionPass *createBitTrackingDCEPass();
103
 
104
//===----------------------------------------------------------------------===//
105
//
106
// SROA - Replace aggregates or pieces of aggregates with scalar SSA values.
107
//
108
FunctionPass *createSROAPass(bool PreserveCFG = true);
109
 
110
//===----------------------------------------------------------------------===//
111
//
112
// InductiveRangeCheckElimination - Transform loops to elide range checks on
113
// linear functions of the induction variable.
114
//
115
Pass *createInductiveRangeCheckEliminationPass();
116
 
117
//===----------------------------------------------------------------------===//
118
//
119
// InductionVariableSimplify - Transform induction variables in a program to all
120
// use a single canonical induction variable per loop.
121
//
122
Pass *createIndVarSimplifyPass();
123
 
124
//===----------------------------------------------------------------------===//
125
//
126
// LICM - This pass is a loop invariant code motion and memory promotion pass.
127
//
128
Pass *createLICMPass();
129
Pass *createLICMPass(unsigned LicmMssaOptCap,
130
                     unsigned LicmMssaNoAccForPromotionCap,
131
                     bool AllowSpeculation);
132
 
133
//===----------------------------------------------------------------------===//
134
//
135
// LoopSink - This pass sinks invariants from preheader to loop body where
136
// frequency is lower than loop preheader.
137
//
138
Pass *createLoopSinkPass();
139
 
140
//===----------------------------------------------------------------------===//
141
//
142
// LoopPredication - This pass does loop predication on guards.
143
//
144
Pass *createLoopPredicationPass();
145
 
146
//===----------------------------------------------------------------------===//
147
//
148
// LoopInterchange - This pass interchanges loops to provide a more
149
// cache-friendly memory access patterns.
150
//
151
Pass *createLoopInterchangePass();
152
 
153
//===----------------------------------------------------------------------===//
154
//
155
// LoopFlatten - This pass flattens nested loops into a single loop.
156
//
157
FunctionPass *createLoopFlattenPass();
158
 
159
//===----------------------------------------------------------------------===//
160
//
161
// LoopStrengthReduce - This pass is strength reduces GEP instructions that use
162
// a loop's canonical induction variable as one of their indices.
163
//
164
Pass *createLoopStrengthReducePass();
165
 
166
//===----------------------------------------------------------------------===//
167
//
168
// LoopInstSimplify - This pass simplifies instructions in a loop's body.
169
//
170
Pass *createLoopInstSimplifyPass();
171
 
172
//===----------------------------------------------------------------------===//
173
//
174
// LoopUnroll - This pass is a simple loop unrolling pass.
175
//
176
Pass *createLoopUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false,
177
                           bool ForgetAllSCEV = false, int Threshold = -1,
178
                           int Count = -1, int AllowPartial = -1,
179
                           int Runtime = -1, int UpperBound = -1,
180
                           int AllowPeeling = -1);
181
// Create an unrolling pass for full unrolling that uses exact trip count only
182
// and also does peeling.
183
Pass *createSimpleLoopUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false,
184
                                 bool ForgetAllSCEV = false);
185
 
186
//===----------------------------------------------------------------------===//
187
//
188
// LoopUnrollAndJam - This pass is a simple loop unroll and jam pass.
189
//
190
Pass *createLoopUnrollAndJamPass(int OptLevel = 2);
191
 
192
//===----------------------------------------------------------------------===//
193
//
194
// LoopReroll - This pass is a simple loop rerolling pass.
195
//
196
Pass *createLoopRerollPass();
197
 
198
//===----------------------------------------------------------------------===//
199
//
200
// LoopRotate - This pass is a simple loop rotating pass.
201
//
202
Pass *createLoopRotatePass(int MaxHeaderSize = -1, bool PrepareForLTO = false);
203
 
204
//===----------------------------------------------------------------------===//
205
//
206
// LoopIdiom - This pass recognizes and replaces idioms in loops.
207
//
208
Pass *createLoopIdiomPass();
209
 
210
//===----------------------------------------------------------------------===//
211
//
212
// LoopVersioningLICM - This pass is a loop versioning pass for LICM.
213
//
214
Pass *createLoopVersioningLICMPass();
215
 
216
//===----------------------------------------------------------------------===//
217
//
218
// DemoteRegisterToMemoryPass - This pass is used to demote registers to memory
219
// references. In basically undoes the PromoteMemoryToRegister pass to make cfg
220
// hacking easier.
221
//
222
FunctionPass *createDemoteRegisterToMemoryPass();
223
extern char &DemoteRegisterToMemoryID;
224
 
225
//===----------------------------------------------------------------------===//
226
//
227
// Reassociate - This pass reassociates commutative expressions in an order that
228
// is designed to promote better constant propagation, GCSE, LICM, PRE...
229
//
230
// For example:  4 + (x + 5)  ->  x + (4 + 5)
231
//
232
FunctionPass *createReassociatePass();
233
 
234
//===----------------------------------------------------------------------===//
235
//
236
// JumpThreading - Thread control through mult-pred/multi-succ blocks where some
237
// preds always go to some succ. Thresholds other than minus one
238
// override the internal BB duplication default threshold.
239
//
240
FunctionPass *createJumpThreadingPass(int Threshold = -1);
241
 
242
//===----------------------------------------------------------------------===//
243
//
244
// DFAJumpThreading - When a switch statement inside a loop is used to
245
// implement a deterministic finite automata we can jump thread the switch
246
// statement reducing number of conditional jumps.
247
//
248
FunctionPass *createDFAJumpThreadingPass();
249
 
250
//===----------------------------------------------------------------------===//
251
//
252
// CFGSimplification - Merge basic blocks, eliminate unreachable blocks,
253
// simplify terminator instructions, convert switches to lookup tables, etc.
254
//
255
FunctionPass *createCFGSimplificationPass(
256
    SimplifyCFGOptions Options = SimplifyCFGOptions(),
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(bool SplitFooterBB = false);
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
// LowerMatrixIntrinsics - Lower matrix intrinsics to vector operations.
364
//
365
Pass *createLowerMatrixIntrinsicsPass();
366
 
367
//===----------------------------------------------------------------------===//
368
//
369
// LowerMatrixIntrinsicsMinimal - Lower matrix intrinsics to vector operations
370
//                               (lightweight, does not require extra analysis)
371
//
372
Pass *createLowerMatrixIntrinsicsMinimalPass();
373
 
374
//===----------------------------------------------------------------------===//
375
//
376
// LowerWidenableCondition - Lower widenable condition to i1 true.
377
//
378
Pass *createLowerWidenableConditionPass();
379
 
380
//===----------------------------------------------------------------------===//
381
//
382
// MergeICmps - Merge integer comparison chains into a memcmp
383
//
384
Pass *createMergeICmpsLegacyPass();
385
 
386
//===----------------------------------------------------------------------===//
387
//
388
// ValuePropagation - Propagate CFG-derived value information
389
//
390
Pass *createCorrelatedValuePropagationPass();
391
 
392
//===----------------------------------------------------------------------===//
393
//
394
// InferAddressSpaces - Modify users of addrspacecast instructions with values
395
// in the source address space if using the destination address space is slower
396
// on the target. If AddressSpace is left to its default value, it will be
397
// obtained from the TargetTransformInfo.
398
//
399
FunctionPass *createInferAddressSpacesPass(unsigned AddressSpace = ~0u);
400
extern char &InferAddressSpacesID;
401
 
402
//===----------------------------------------------------------------------===//
403
//
404
// LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates
405
// "block_weights" metadata.
406
FunctionPass *createLowerExpectIntrinsicPass();
407
 
408
//===----------------------------------------------------------------------===//
409
//
410
// TLSVariableHoist - This pass reduce duplicated TLS address call.
411
//
412
FunctionPass *createTLSVariableHoistPass();
413
 
414
//===----------------------------------------------------------------------===//
415
//
416
// LowerConstantIntrinsicss - Expand any remaining llvm.objectsize and
417
// llvm.is.constant intrinsic calls, even for the unknown cases.
418
//
419
FunctionPass *createLowerConstantIntrinsicsPass();
420
 
421
//===----------------------------------------------------------------------===//
422
//
423
// PartiallyInlineLibCalls - Tries to inline the fast path of library
424
// calls such as sqrt.
425
//
426
FunctionPass *createPartiallyInlineLibCallsPass();
427
 
428
//===----------------------------------------------------------------------===//
429
//
430
// SeparateConstOffsetFromGEP - Split GEPs for better CSE
431
//
432
FunctionPass *createSeparateConstOffsetFromGEPPass(bool LowerGEP = false);
433
 
434
//===----------------------------------------------------------------------===//
435
//
436
// SpeculativeExecution - Aggressively hoist instructions to enable
437
// speculative execution on targets where branches are expensive.
438
//
439
FunctionPass *createSpeculativeExecutionPass();
440
 
441
// Same as createSpeculativeExecutionPass, but does nothing unless
442
// TargetTransformInfo::hasBranchDivergence() is true.
443
FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass();
444
 
445
//===----------------------------------------------------------------------===//
446
//
447
// StraightLineStrengthReduce - This pass strength-reduces some certain
448
// instruction patterns in straight-line code.
449
//
450
FunctionPass *createStraightLineStrengthReducePass();
451
 
452
//===----------------------------------------------------------------------===//
453
//
454
// PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any
455
// safepoint polls (method entry, backedge) that might be required.  This pass
456
// does not generate explicit relocation sequences - that's handled by
457
// RewriteStatepointsForGC which can be run at an arbitrary point in the pass
458
// order following this pass.
459
//
460
FunctionPass *createPlaceSafepointsPass();
461
 
462
//===----------------------------------------------------------------------===//
463
//
464
// RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have
465
// explicit relocations to include explicit relocations.
466
//
467
ModulePass *createRewriteStatepointsForGCLegacyPass();
468
 
469
//===----------------------------------------------------------------------===//
470
//
471
// Float2Int - Demote floats to ints where possible.
472
//
473
FunctionPass *createFloat2IntPass();
474
 
475
//===----------------------------------------------------------------------===//
476
//
477
// NaryReassociate - Simplify n-ary operations by reassociation.
478
//
479
FunctionPass *createNaryReassociatePass();
480
 
481
//===----------------------------------------------------------------------===//
482
//
483
// LoopDistribute - Distribute loops.
484
//
485
FunctionPass *createLoopDistributePass();
486
 
487
//===----------------------------------------------------------------------===//
488
//
489
// LoopFuse - Fuse loops.
490
//
491
FunctionPass *createLoopFusePass();
492
 
493
//===----------------------------------------------------------------------===//
494
//
495
// LoopLoadElimination - Perform loop-aware load elimination.
496
//
497
FunctionPass *createLoopLoadEliminationPass();
498
 
499
//===----------------------------------------------------------------------===//
500
//
501
// LoopVersioning - Perform loop multi-versioning.
502
//
503
FunctionPass *createLoopVersioningPass();
504
 
505
//===----------------------------------------------------------------------===//
506
//
507
// LoopDataPrefetch - Perform data prefetching in loops.
508
//
509
FunctionPass *createLoopDataPrefetchPass();
510
 
511
//===----------------------------------------------------------------------===//
512
//
513
// LibCallsShrinkWrap - Shrink-wraps a call to function if the result is not
514
// used.
515
//
516
FunctionPass *createLibCallsShrinkWrapPass();
517
 
518
//===----------------------------------------------------------------------===//
519
//
520
// LoopSimplifyCFG - This pass performs basic CFG simplification on loops,
521
// primarily to help other loop passes.
522
//
523
Pass *createLoopSimplifyCFGPass();
524
 
525
//===----------------------------------------------------------------------===//
526
//
527
// WarnMissedTransformations - This pass emits warnings for leftover forced
528
// transformations.
529
//
530
Pass *createWarnMissedTransformationsPass();
531
 
532
//===----------------------------------------------------------------------===//
533
//
534
// This pass does instruction simplification on each
535
// instruction in a function.
536
//
537
FunctionPass *createInstSimplifyLegacyPass();
538
 
539
 
540
//===----------------------------------------------------------------------===//
541
//
542
// createScalarizeMaskedMemIntrinPass - Replace masked load, store, gather
543
// and scatter intrinsics with scalar code when target doesn't support them.
544
//
545
FunctionPass *createScalarizeMaskedMemIntrinLegacyPass();
546
} // End llvm namespace
547
 
548
#endif