8e06dc8271190cd842fdeac653c5ee8f214a18a7
[oota-llvm.git] / 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 <cstdlib>
19
20 namespace llvm {
21
22 class FunctionPass;
23 class LoopPass;
24 class Pass;
25 class GetElementPtrInst;
26 class PassInfo;
27 class TerminatorInst;
28 class TargetLowering;
29
30 //===----------------------------------------------------------------------===//
31 //
32 // ConstantPropagation - A worklist driven constant propagation pass
33 //
34 FunctionPass *createConstantPropagationPass();
35
36 //===----------------------------------------------------------------------===//
37 //
38 // SCCP - Sparse conditional constant propagation.
39 //
40 FunctionPass *createSCCPPass();
41
42 //===----------------------------------------------------------------------===//
43 //
44 // DeadInstElimination - This pass quickly removes trivially dead instructions
45 // without modifying the CFG of the function.  It is a BasicBlockPass, so it
46 // runs efficiently when queued next to other BasicBlockPass's.
47 //
48 Pass *createDeadInstEliminationPass();
49
50 //===----------------------------------------------------------------------===//
51 //
52 // DeadCodeElimination - This pass is more powerful than DeadInstElimination,
53 // because it is worklist driven that can potentially revisit instructions when
54 // their other instructions become dead, to eliminate chains of dead
55 // computations.
56 //
57 FunctionPass *createDeadCodeEliminationPass();
58
59 //===----------------------------------------------------------------------===//
60 //
61 // DeadStoreElimination - This pass deletes stores that are post-dominated by
62 // must-aliased stores and are not loaded used between the stores.
63 //
64 FunctionPass *createDeadStoreEliminationPass();
65
66 //===----------------------------------------------------------------------===//
67 //
68 // AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm.  This
69 // algorithm assumes instructions are dead until proven otherwise, which makes
70 // it more successful are removing non-obviously dead instructions.
71 //
72 FunctionPass *createAggressiveDCEPass();
73
74 //===----------------------------------------------------------------------===//
75 //
76 // ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas
77 // if possible.
78 //
79 FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1);
80
81 //===----------------------------------------------------------------------===//
82 //
83 // GCSE - This pass is designed to be a very quick global transformation that
84 // eliminates global common subexpressions from a function.  It does this by
85 // examining the SSA value graph of the function, instead of doing slow
86 // bit-vector computations.
87 //
88 FunctionPass *createGCSEPass();
89
90 //===----------------------------------------------------------------------===//
91 //
92 // InductionVariableSimplify - Transform induction variables in a program to all
93 // use a single canonical induction variable per loop.
94 //
95 LoopPass *createIndVarSimplifyPass();
96
97 //===----------------------------------------------------------------------===//
98 //
99 // InstructionCombining - Combine instructions to form fewer, simple
100 // instructions. This pass does not modify the CFG, and has a tendency to make
101 // instructions dead, so a subsequent DCE pass is useful.
102 //
103 // This pass combines things like:
104 //    %Y = add int 1, %X
105 //    %Z = add int 1, %Y
106 // into:
107 //    %Z = add int 2, %X
108 //
109 FunctionPass *createInstructionCombiningPass();
110
111 //===----------------------------------------------------------------------===//
112 //
113 // LICM - This pass is a loop invariant code motion and memory promotion pass.
114 //
115 LoopPass *createLICMPass();
116
117 //===----------------------------------------------------------------------===//
118 //
119 // LoopStrengthReduce - This pass is strength reduces GEP instructions that use
120 // a loop's canonical induction variable as one of their indices.  It takes an
121 // optional parameter used to consult the target machine whether certain
122 // transformations are profitable.
123 //
124 LoopPass *createLoopStrengthReducePass(const TargetLowering *TLI = 0);
125
126 //===----------------------------------------------------------------------===//
127 //
128 // LoopUnswitch - This pass is a simple loop unswitching pass.
129 //
130 LoopPass *createLoopUnswitchPass(bool OptimizeForSize = false);
131
132 //===----------------------------------------------------------------------===//
133 //
134 // LoopUnroll - This pass is a simple loop unrolling pass.
135 //
136 LoopPass *createLoopUnrollPass();
137
138 //===----------------------------------------------------------------------===//
139 //
140 // LoopRotate - This pass is a simple loop rotating pass.
141 //
142 LoopPass *createLoopRotatePass();
143
144 //===----------------------------------------------------------------------===//
145 //
146 // LoopIndexSplit - This pass divides loop's iteration range by spliting loop
147 // such that each individual loop is executed efficiently.
148 //
149 LoopPass *createLoopIndexSplitPass();
150
151
152 //===----------------------------------------------------------------------===//
153 //
154 // PromoteMemoryToRegister - This pass is used to promote memory references to
155 // be register references. A simple example of the transformation performed by
156 // this pass is:
157 //
158 //        FROM CODE                           TO CODE
159 //   %X = alloca int, uint 1                 ret int 42
160 //   store int 42, int *%X
161 //   %Y = load int* %X
162 //   ret int %Y
163 //
164 FunctionPass *createPromoteMemoryToRegisterPass();
165 extern const PassInfo *PromoteMemoryToRegisterID;
166
167 //===----------------------------------------------------------------------===//
168 //
169 // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory
170 // references. In basically undoes the PromoteMemoryToRegister pass to make cfg
171 // hacking easier.
172 //
173 FunctionPass *createDemoteRegisterToMemoryPass();
174 extern const PassInfo *DemoteRegisterToMemoryID;
175
176 //===----------------------------------------------------------------------===//
177 //
178 // Reassociate - This pass reassociates commutative expressions in an order that
179 // is designed to promote better constant propagation, GCSE, LICM, PRE...
180 //
181 // For example:  4 + (x + 5)  ->  x + (4 + 5)
182 //
183 FunctionPass *createReassociatePass();
184
185 //===----------------------------------------------------------------------===//
186 //
187 // CondPropagationPass - This pass propagates information about conditional
188 // expressions through the program, allowing it to eliminate conditional
189 // branches in some cases.
190 //
191 FunctionPass *createCondPropagationPass();
192
193 //===----------------------------------------------------------------------===//
194 //
195 // TailDuplication - Eliminate unconditional branches through controlled code
196 // duplication, creating simpler CFG structures.
197 //
198 FunctionPass *createTailDuplicationPass();
199
200 //===----------------------------------------------------------------------===//
201 //
202 // CFGSimplification - Merge basic blocks, eliminate unreachable blocks,
203 // simplify terminator instructions, etc...
204 //
205 FunctionPass *createCFGSimplificationPass();
206
207 //===----------------------------------------------------------------------===//
208 //
209 // BreakCriticalEdges - Break all of the critical edges in the CFG by inserting
210 // a dummy basic block. This pass may be "required" by passes that cannot deal
211 // with critical edges. For this usage, a pass must call:
212 //
213 //   AU.addRequiredID(BreakCriticalEdgesID);
214 //
215 // This pass obviously invalidates the CFG, but can update forward dominator
216 // (set, immediate dominators, tree, and frontier) information.
217 //
218 FunctionPass *createBreakCriticalEdgesPass();
219 extern const PassInfo *BreakCriticalEdgesID;
220
221 //===----------------------------------------------------------------------===//
222 //
223 // LoopSimplify - Insert Pre-header blocks into the CFG for every function in
224 // the module.  This pass updates dominator information, loop information, and
225 // does not add critical edges to the CFG.
226 //
227 //   AU.addRequiredID(LoopSimplifyID);
228 //
229 FunctionPass *createLoopSimplifyPass();
230 extern const PassInfo *LoopSimplifyID;
231
232 //===----------------------------------------------------------------------===//
233 //
234 // LowerSelect - This pass converts SelectInst instructions into conditional
235 // branch and PHI instructions. If the OnlyFP flag is set to true, then only
236 // floating point select instructions are lowered.
237 //
238 FunctionPass *createLowerSelectPass(bool OnlyFP = false);
239 extern const PassInfo *LowerSelectID;
240
241 //===----------------------------------------------------------------------===//
242 //
243 // LowerAllocations - Turn malloc and free instructions into %malloc and %free
244 // calls.
245 //
246 //   AU.addRequiredID(LowerAllocationsID);
247 //
248 Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false);
249 extern const PassInfo *LowerAllocationsID;
250
251 //===----------------------------------------------------------------------===//
252 //
253 // TailCallElimination - This pass eliminates call instructions to the current
254 // function which occur immediately before return instructions.
255 //
256 FunctionPass *createTailCallEliminationPass();
257
258 //===----------------------------------------------------------------------===//
259 //
260 // LowerSwitch - This pass converts SwitchInst instructions into a sequence of
261 // chained binary branch instructions.
262 //
263 FunctionPass *createLowerSwitchPass();
264 extern const PassInfo *LowerSwitchID;
265
266 //===----------------------------------------------------------------------===//
267 //
268 // LowerPacked - This pass converts VectorType operations into low-level scalar
269 // operations.
270 //
271 FunctionPass *createLowerPackedPass();
272
273 //===----------------------------------------------------------------------===//
274 //
275 // LowerInvoke - This pass converts invoke and unwind instructions to use sjlj
276 // exception handling mechanisms.  Note that after this pass runs the CFG is not
277 // entirely accurate (exceptional control flow edges are not correct anymore) so
278 // only very simple things should be done after the lowerinvoke pass has run
279 // (like generation of native code).  This should *NOT* be used as a general
280 // purpose "my LLVM-to-LLVM pass doesn't support the invoke instruction yet"
281 // lowering pass.
282 //
283 FunctionPass *createLowerInvokePass(const TargetLowering *TLI = NULL);
284 extern const PassInfo *LowerInvokePassID;
285
286 //===----------------------------------------------------------------------===//
287 //
288 // BlockPlacement - This pass reorders basic blocks in order to increase the
289 // number of fall-through conditional branches.
290 //
291 FunctionPass *createBlockPlacementPass();
292
293 //===----------------------------------------------------------------------===//
294 //
295 // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop
296 // optimizations.
297 //
298 LoopPass *createLCSSAPass();
299 extern const PassInfo *LCSSAID;
300
301 //===----------------------------------------------------------------------===//
302 //
303 // PredicateSimplifier - This pass collapses duplicate variables into one
304 // canonical form, and tries to simplify expressions along the way.
305 //
306 FunctionPass *createPredicateSimplifierPass();
307
308 //===----------------------------------------------------------------------===//
309 //
310 // GVN-PRE - This pass performs global value numbering and partial redundancy
311 // elimination.
312 //
313 FunctionPass *createGVNPREPass();
314
315 //===----------------------------------------------------------------------===//
316 //
317 // GVN - This pass performs global value numbering and redundant load 
318 // elimination cotemporaneously.
319 //
320 FunctionPass *createGVNPass();
321
322 //===----------------------------------------------------------------------===//
323 //
324 // CodeGenPrepare - This pass prepares a function for instruction selection.
325 //
326 FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0);
327
328 } // End llvm namespace
329
330 #endif