Scalar.h revision 0ff7708a5bbde331f9f54fb955bf7a2e96af710e
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 20namespace llvm { 21 22class FunctionPass; 23class LoopPass; 24class Pass; 25class GetElementPtrInst; 26class PassInfo; 27class TerminatorInst; 28class TargetLowering; 29 30//===----------------------------------------------------------------------===// 31// 32// ConstantPropagation - A worklist driven constant propagation pass 33// 34FunctionPass *createConstantPropagationPass(); 35 36//===----------------------------------------------------------------------===// 37// 38// SCCP - Sparse conditional constant propagation. 39// 40FunctionPass *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// 48Pass *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// 57FunctionPass *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// 64FunctionPass *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// 72FunctionPass *createAggressiveDCEPass(); 73 74//===----------------------------------------------------------------------===// 75// 76// ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas 77// if possible. 78// 79FunctionPass *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// 88FunctionPass *createGCSEPass(); 89 90//===----------------------------------------------------------------------===// 91// 92// InductionVariableSimplify - Transform induction variables in a program to all 93// use a single canonical induction variable per loop. 94// 95LoopPass *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// 109FunctionPass *createInstructionCombiningPass(); 110 111//===----------------------------------------------------------------------===// 112// 113// LICM - This pass is a loop invariant code motion and memory promotion pass. 114// 115LoopPass *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// 124LoopPass *createLoopStrengthReducePass(const TargetLowering *TLI = 0); 125 126//===----------------------------------------------------------------------===// 127// 128// LoopUnswitch - This pass is a simple loop unswitching pass. 129// 130LoopPass *createLoopUnswitchPass(bool OptimizeForSize = false); 131 132//===----------------------------------------------------------------------===// 133// 134// LoopUnroll - This pass is a simple loop unrolling pass. 135// 136LoopPass *createLoopUnrollPass(); 137 138//===----------------------------------------------------------------------===// 139// 140// LoopRotate - This pass is a simple loop rotating pass. 141// 142LoopPass *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// 149LoopPass *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// 164FunctionPass *createPromoteMemoryToRegisterPass(); 165extern 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// 173FunctionPass *createDemoteRegisterToMemoryPass(); 174extern 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// 183FunctionPass *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// 191FunctionPass *createCondPropagationPass(); 192 193//===----------------------------------------------------------------------===// 194// 195// TailDuplication - Eliminate unconditional branches through controlled code 196// duplication, creating simpler CFG structures. 197// 198FunctionPass *createTailDuplicationPass(); 199 200//===----------------------------------------------------------------------===// 201// 202// JumpThreading - Thread control through mult-pred/multi-succ blocks where some 203// preds always go to some succ. 204// 205FunctionPass *createJumpThreadingPass(); 206 207 //===----------------------------------------------------------------------===// 208// 209// CFGSimplification - Merge basic blocks, eliminate unreachable blocks, 210// simplify terminator instructions, etc... 211// 212FunctionPass *createCFGSimplificationPass(); 213 214//===----------------------------------------------------------------------===// 215// 216// BreakCriticalEdges - Break all of the critical edges in the CFG by inserting 217// a dummy basic block. This pass may be "required" by passes that cannot deal 218// with critical edges. For this usage, a pass must call: 219// 220// AU.addRequiredID(BreakCriticalEdgesID); 221// 222// This pass obviously invalidates the CFG, but can update forward dominator 223// (set, immediate dominators, tree, and frontier) information. 224// 225FunctionPass *createBreakCriticalEdgesPass(); 226extern const PassInfo *BreakCriticalEdgesID; 227 228//===----------------------------------------------------------------------===// 229// 230// LoopSimplify - Insert Pre-header blocks into the CFG for every function in 231// the module. This pass updates dominator information, loop information, and 232// does not add critical edges to the CFG. 233// 234// AU.addRequiredID(LoopSimplifyID); 235// 236FunctionPass *createLoopSimplifyPass(); 237extern const PassInfo *LoopSimplifyID; 238 239//===----------------------------------------------------------------------===// 240// 241// LowerAllocations - Turn malloc and free instructions into %malloc and %free 242// calls. 243// 244// AU.addRequiredID(LowerAllocationsID); 245// 246Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); 247extern const PassInfo *LowerAllocationsID; 248 249//===----------------------------------------------------------------------===// 250// 251// TailCallElimination - This pass eliminates call instructions to the current 252// function which occur immediately before return instructions. 253// 254FunctionPass *createTailCallEliminationPass(); 255 256//===----------------------------------------------------------------------===// 257// 258// LowerSwitch - This pass converts SwitchInst instructions into a sequence of 259// chained binary branch instructions. 260// 261FunctionPass *createLowerSwitchPass(); 262extern const PassInfo *LowerSwitchID; 263 264//===----------------------------------------------------------------------===// 265// 266// LowerInvoke - This pass converts invoke and unwind instructions to use sjlj 267// exception handling mechanisms. Note that after this pass runs the CFG is not 268// entirely accurate (exceptional control flow edges are not correct anymore) so 269// only very simple things should be done after the lowerinvoke pass has run 270// (like generation of native code). This should *NOT* be used as a general 271// purpose "my LLVM-to-LLVM pass doesn't support the invoke instruction yet" 272// lowering pass. 273// 274FunctionPass *createLowerInvokePass(const TargetLowering *TLI = NULL); 275extern const PassInfo *LowerInvokePassID; 276 277//===----------------------------------------------------------------------===// 278// 279// BlockPlacement - This pass reorders basic blocks in order to increase the 280// number of fall-through conditional branches. 281// 282FunctionPass *createBlockPlacementPass(); 283 284//===----------------------------------------------------------------------===// 285// 286// LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop 287// optimizations. 288// 289LoopPass *createLCSSAPass(); 290extern const PassInfo *LCSSAID; 291 292//===----------------------------------------------------------------------===// 293// 294// PredicateSimplifier - This pass collapses duplicate variables into one 295// canonical form, and tries to simplify expressions along the way. 296// 297FunctionPass *createPredicateSimplifierPass(); 298 299//===----------------------------------------------------------------------===// 300// 301// GVN-PRE - This pass performs global value numbering and partial redundancy 302// elimination. 303// 304FunctionPass *createGVNPREPass(); 305 306//===----------------------------------------------------------------------===// 307// 308// GVN - This pass performs global value numbering and redundant load 309// elimination cotemporaneously. 310// 311FunctionPass *createGVNPass(); 312 313//===----------------------------------------------------------------------===// 314// 315// MemCpyOpt - This pass performs optimizations related to eliminating memcpy 316// calls and/or combining multiple stores into memset's. 317// 318FunctionPass *createMemCpyOptPass(); 319 320//===----------------------------------------------------------------------===// 321// 322// DeadLoopElimination - This pass performs DCE of non-infinite loops that it 323// can prove are dead. 324// 325LoopPass *createDeadLoopEliminationPass(); 326 327//===----------------------------------------------------------------------===// 328// 329// CodeGenPrepare - This pass prepares a function for instruction selection. 330// 331FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0); 332 333} // End llvm namespace 334 335#endif 336