Scalar.h revision 8226db66a2a1b8df268ed4df9709bfbca7bab156
1//===-- Scalar.h - Scalar Transformations -----------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source 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 18namespace llvm { 19 20class ModulePass; 21class FunctionPass; 22class GetElementPtrInst; 23class PassInfo; 24class TerminatorInst; 25 26//===----------------------------------------------------------------------===// 27// 28// RaisePointerReferences - Try to eliminate as many pointer arithmetic 29// expressions as possible, by converting expressions to use getelementptr and 30// friends. 31// 32FunctionPass *createRaisePointerReferencesPass(); 33 34//===----------------------------------------------------------------------===// 35// 36// Constant Propagation Pass - A worklist driven constant propagation pass 37// 38FunctionPass *createConstantPropagationPass(); 39 40 41//===----------------------------------------------------------------------===// 42// 43// Sparse Conditional Constant Propagation Pass 44// 45FunctionPass *createSCCPPass(); 46 47 48//===----------------------------------------------------------------------===// 49// 50// DeadInstElimination - This pass quickly removes trivially dead instructions 51// without modifying the CFG of the function. It is a BasicBlockPass, so it 52// runs efficiently when queued next to other BasicBlockPass's. 53// 54FunctionPass *createDeadInstEliminationPass(); 55 56 57//===----------------------------------------------------------------------===// 58// 59// DeadCodeElimination - This pass is more powerful than DeadInstElimination, 60// because it is worklist driven that can potentially revisit instructions when 61// their other instructions become dead, to eliminate chains of dead 62// computations. 63// 64FunctionPass *createDeadCodeEliminationPass(); 65 66//===----------------------------------------------------------------------===// 67// 68// DeadStoreElimination - This pass deletes stores that are post-dominated by 69// must-aliased stores and are not loaded used between the stores. 70// 71FunctionPass *createDeadStoreEliminationPass(); 72 73//===----------------------------------------------------------------------===// 74// 75// AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This 76// algorithm assumes instructions are dead until proven otherwise, which makes 77// it more successful are removing non-obviously dead instructions. 78// 79FunctionPass *createAggressiveDCEPass(); 80 81 82//===----------------------------------------------------------------------===// 83// 84// Scalar Replacement of Aggregates - Break up alloca's of aggregates into 85// multiple allocas if possible. 86// 87FunctionPass *createScalarReplAggregatesPass(); 88 89 90//===----------------------------------------------------------------------===// 91// 92// GCSE - This pass is designed to be a very quick global transformation that 93// eliminates global common subexpressions from a function. It does this by 94// examining the SSA value graph of the function, instead of doing slow 95// bit-vector computations. 96// 97FunctionPass *createGCSEPass(); 98 99 100//===----------------------------------------------------------------------===// 101// 102// InductionVariableSimplify - Transform induction variables in a program to all 103// use a single canonical induction variable per loop. 104// 105FunctionPass *createIndVarSimplifyPass(); 106 107 108//===----------------------------------------------------------------------===// 109// 110// InstructionCombining - Combine instructions to form fewer, simple 111// instructions. This pass does not modify the CFG, and has a tendency to 112// make instructions dead, so a subsequent DCE pass is useful. 113// 114// This pass combines things like: 115// %Y = add int 1, %X 116// %Z = add int 1, %Y 117// into: 118// %Z = add int 2, %X 119// 120FunctionPass *createInstructionCombiningPass(); 121 122 123//===----------------------------------------------------------------------===// 124// 125// LICM - This pass is a loop invariant code motion and memory promotion pass. 126// 127FunctionPass *createLICMPass(); 128 129//===----------------------------------------------------------------------===// 130// 131// LoopStrengthReduce - This pass is strength reduces GEP instructions that use 132// a loop's canonical induction variable as one of their indices. 133// 134FunctionPass *createLoopStrengthReducePass(); 135 136//===----------------------------------------------------------------------===// 137// 138// LoopUnswitch - This pass is a simple loop unswitching pass. 139// 140FunctionPass *createLoopUnswitchPass(); 141 142 143//===----------------------------------------------------------------------===// 144// 145// LoopUnroll - This pass is a simple loop unrolling pass. 146// 147FunctionPass *createLoopUnrollPass(); 148 149//===----------------------------------------------------------------------===// 150// 151// This pass is used to promote memory references to be register references. A 152// simple example of the transformation performed by this pass is: 153// 154// FROM CODE TO CODE 155// %X = alloca int, uint 1 ret int 42 156// store int 42, int *%X 157// %Y = load int* %X 158// ret int %Y 159// 160FunctionPass *createPromoteMemoryToRegister(); 161 162 163//===----------------------------------------------------------------------===// 164// 165// This pass reassociates commutative expressions in an order that is designed 166// to promote better constant propagation, GCSE, LICM, PRE... 167// 168// For example: 4 + (x + 5) -> x + (4 + 5) 169// 170FunctionPass *createReassociatePass(); 171 172//===----------------------------------------------------------------------===// 173// 174// This pass eliminates correlated conditions, such as these: 175// if (X == 0) 176// if (X > 2) ; // Known false 177// else 178// Y = X * Z; // = 0 179// 180FunctionPass *createCorrelatedExpressionEliminationPass(); 181 182//===----------------------------------------------------------------------===// 183// 184// TailDuplication - Eliminate unconditional branches through controlled code 185// duplication, creating simpler CFG structures. 186// 187FunctionPass *createTailDuplicationPass(); 188 189 190//===----------------------------------------------------------------------===// 191// 192// CFG Simplification - Merge basic blocks, eliminate unreachable blocks, 193// simplify terminator instructions, etc... 194// 195FunctionPass *createCFGSimplificationPass(); 196 197 198//===----------------------------------------------------------------------===// 199// 200// BreakCriticalEdges pass - Break all of the critical edges in the CFG by 201// inserting a dummy basic block. This pass may be "required" by passes that 202// cannot deal with critical edges. For this usage, a pass must call: 203// 204// AU.addRequiredID(BreakCriticalEdgesID); 205// 206// This pass obviously invalidates the CFG, but can update forward dominator 207// (set, immediate dominators, tree, and frontier) information. 208// 209FunctionPass *createBreakCriticalEdgesPass(); 210extern const PassInfo *BreakCriticalEdgesID; 211 212//===----------------------------------------------------------------------===// 213// 214// LoopSimplify pass - Insert Pre-header blocks into the CFG for every function 215// in the module. This pass updates dominator information, loop information, 216// and does not add critical edges to the CFG. 217// 218// AU.addRequiredID(LoopSimplifyID); 219// 220FunctionPass *createLoopSimplifyPass(); 221extern const PassInfo *LoopSimplifyID; 222 223//===----------------------------------------------------------------------===// 224// 225// This pass eliminates call instructions to the current function which occur 226// immediately before return instructions. 227// 228FunctionPass *createTailCallEliminationPass(); 229 230 231//===----------------------------------------------------------------------===// 232// This pass convert malloc and free instructions to %malloc & %free function 233// calls. 234// 235FunctionPass *createLowerAllocationsPass(); 236 237//===----------------------------------------------------------------------===// 238// This pass converts SwitchInst instructions into a sequence of chained binary 239// branch instructions. 240// 241FunctionPass *createLowerSwitchPass(); 242 243//===----------------------------------------------------------------------===// 244// This pass converts SelectInst instructions into conditional branch and PHI 245// instructions. If the OnlyFP flag is set to true, then only floating point 246// select instructions are lowered. 247// 248FunctionPass *createLowerSelectPass(bool OnlyFP = false); 249 250//===----------------------------------------------------------------------===// 251// This pass converts invoke and unwind instructions to use sjlj exception 252// handling mechanisms. Note that after this pass runs the CFG is not entirely 253// accurate (exceptional control flow edges are not correct anymore) so only 254// very simple things should be done after the lowerinvoke pass has run (like 255// generation of native code). This should *NOT* be used as a general purpose 256// "my LLVM-to-LLVM pass doesn't support the invoke instruction yet" lowering 257// pass. 258// 259FunctionPass *createLowerInvokePass(); 260extern const PassInfo *LowerInvokePassID; 261 262 263//===----------------------------------------------------------------------===// 264/// createLowerGCPass - This function returns an instance of the "lowergc" 265/// pass, which lowers garbage collection intrinsics to normal LLVM code. 266/// 267FunctionPass *createLowerGCPass(); 268 269//===----------------------------------------------------------------------===// 270// Returns a pass which converts all instances of ConstantExpression 271// into regular LLVM instructions. 272FunctionPass* createLowerConstantExpressionsPass(); 273 274 275//===----------------------------------------------------------------------===// 276// 277// These functions removes symbols from functions and modules. 278// 279FunctionPass *createSymbolStrippingPass(); 280FunctionPass *createFullSymbolStrippingPass(); 281 282} // End llvm namespace 283 284#endif 285