X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FScalar.h;h=7f055d4461711e68e3e8778f67ba4f68d5b47d20;hb=fc3665c87519850f629c9565535e3be447e10add;hp=85242f8a77d6be8dd44bc775a3ecfd291a197cf9;hpb=2a0013f59fb3b23010c0509fab8bf509eb30fb36;p=oota-llvm.git diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 85242f8a77d..7f055d44617 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -15,12 +15,10 @@ #ifndef LLVM_TRANSFORMS_SCALAR_H #define LLVM_TRANSFORMS_SCALAR_H -#include - namespace llvm { -class ModulePass; class FunctionPass; +class Pass; class GetElementPtrInst; class PassInfo; class TerminatorInst; @@ -28,34 +26,23 @@ class TargetLowering; //===----------------------------------------------------------------------===// // -// RaisePointerReferences - Try to eliminate as many pointer arithmetic -// expressions as possible, by converting expressions to use getelementptr and -// friends. -// -FunctionPass *createRaisePointerReferencesPass(); - -//===----------------------------------------------------------------------===// -// -// Constant Propagation Pass - A worklist driven constant propagation pass +// ConstantPropagation - A worklist driven constant propagation pass // FunctionPass *createConstantPropagationPass(); - //===----------------------------------------------------------------------===// // -// Sparse Conditional Constant Propagation Pass +// SCCP - Sparse conditional constant propagation. // FunctionPass *createSCCPPass(); - //===----------------------------------------------------------------------===// // // DeadInstElimination - This pass quickly removes trivially dead instructions // without modifying the CFG of the function. It is a BasicBlockPass, so it // runs efficiently when queued next to other BasicBlockPass's. // -FunctionPass *createDeadInstEliminationPass(); - +Pass *createDeadInstEliminationPass(); //===----------------------------------------------------------------------===// // @@ -81,38 +68,26 @@ FunctionPass *createDeadStoreEliminationPass(); // FunctionPass *createAggressiveDCEPass(); - -//===----------------------------------------------------------------------===// -// -// Scalar Replacement of Aggregates - Break up alloca's of aggregates into -// multiple allocas if possible. -// -FunctionPass *createScalarReplAggregatesPass(); - - //===----------------------------------------------------------------------===// // -// GCSE - This pass is designed to be a very quick global transformation that -// eliminates global common subexpressions from a function. It does this by -// examining the SSA value graph of the function, instead of doing slow -// bit-vector computations. +// ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas +// if possible. // -FunctionPass *createGCSEPass(); - +FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1, + bool UseDomTree = true); //===----------------------------------------------------------------------===// // // InductionVariableSimplify - Transform induction variables in a program to all // use a single canonical induction variable per loop. // -FunctionPass *createIndVarSimplifyPass(); - +Pass *createIndVarSimplifyPass(); //===----------------------------------------------------------------------===// // // InstructionCombining - Combine instructions to form fewer, simple -// instructions. This pass does not modify the CFG, and has a tendency to -// make instructions dead, so a subsequent DCE pass is useful. +// instructions. This pass does not modify the CFG, and has a tendency to make +// instructions dead, so a subsequent DCE pass is useful. // // This pass combines things like: // %Y = add int 1, %X @@ -122,12 +97,11 @@ FunctionPass *createIndVarSimplifyPass(); // FunctionPass *createInstructionCombiningPass(); - //===----------------------------------------------------------------------===// // // LICM - This pass is a loop invariant code motion and memory promotion pass. // -FunctionPass *createLICMPass(); +Pass *createLICMPass(); //===----------------------------------------------------------------------===// // @@ -136,47 +110,67 @@ FunctionPass *createLICMPass(); // optional parameter used to consult the target machine whether certain // transformations are profitable. // -FunctionPass *createLoopStrengthReducePass(const TargetLowering *TLI = NULL); +Pass *createLoopStrengthReducePass(const TargetLowering *TLI = 0); + +Pass *createGlobalMergePass(const TargetLowering *TLI = 0); //===----------------------------------------------------------------------===// // // LoopUnswitch - This pass is a simple loop unswitching pass. // -FunctionPass *createLoopUnswitchPass(); +Pass *createLoopUnswitchPass(bool OptimizeForSize = false); +//===----------------------------------------------------------------------===// +// +// LoopInstSimplify - This pass simplifies instructions in a loop's body. +// +Pass *createLoopInstSimplifyPass(); //===----------------------------------------------------------------------===// // // LoopUnroll - This pass is a simple loop unrolling pass. // -FunctionPass *createLoopUnrollPass(); +Pass *createLoopUnrollPass(int Threshold = -1, int Count = -1, int AllowPartial = -1); //===----------------------------------------------------------------------===// // -// This pass is used to promote memory references to be register references. A -// simple example of the transformation performed by this pass is: +// LoopRotate - This pass is a simple loop rotating pass. +// +Pass *createLoopRotatePass(); + +//===----------------------------------------------------------------------===// +// +// LoopIdiom - This pass recognizes and replaces idioms in loops. +// +Pass *createLoopIdiomPass(); + +//===----------------------------------------------------------------------===// +// +// PromoteMemoryToRegister - This pass is used to promote memory references to +// be register references. A simple example of the transformation performed by +// this pass is: // // FROM CODE TO CODE -// %X = alloca int, uint 1 ret int 42 -// store int 42, int *%X -// %Y = load int* %X -// ret int %Y +// %X = alloca i32, i32 1 ret i32 42 +// store i32 42, i32 *%X +// %Y = load i32* %X +// ret i32 %Y // FunctionPass *createPromoteMemoryToRegisterPass(); -extern const PassInfo *PromoteMemoryToRegisterID; //===----------------------------------------------------------------------===// // -// This pass is used to demote registers to memory references . -// In basically undoes the PromoteMemoryToRegister pass to -// make cfg hacking easier. +// DemoteRegisterToMemoryPass - This pass is used to demote registers to memory +// references. In basically undoes the PromoteMemoryToRegister pass to make cfg +// hacking easier. +// FunctionPass *createDemoteRegisterToMemoryPass(); -extern const PassInfo *DemoteRegisterToMemoryID; +extern char &DemoteRegisterToMemoryID; //===----------------------------------------------------------------------===// // -// This pass reassociates commutative expressions in an order that is designed -// to promote better constant propagation, GCSE, LICM, PRE... +// Reassociate - This pass reassociates commutative expressions in an order that +// is designed to promote better constant propagation, GCSE, LICM, PRE... // // For example: 4 + (x + 5) -> x + (4 + 5) // @@ -184,133 +178,191 @@ FunctionPass *createReassociatePass(); //===----------------------------------------------------------------------===// // -// This pass eliminates correlated conditions, such as these: -// if (X == 0) -// if (X > 2) ; // Known false -// else -// Y = X * Z; // = 0 +// JumpThreading - Thread control through mult-pred/multi-succ blocks where some +// preds always go to some succ. // -FunctionPass *createCorrelatedExpressionEliminationPass(); - +FunctionPass *createJumpThreadingPass(); + +//===----------------------------------------------------------------------===// +// +// CFGSimplification - Merge basic blocks, eliminate unreachable blocks, +// simplify terminator instructions, etc... +// +FunctionPass *createCFGSimplificationPass(); -// createCondPropagationPass - This pass propagates information about -// conditional expressions through the program, allowing it to eliminate -// conditional branches in some cases. +//===----------------------------------------------------------------------===// // -FunctionPass *createCondPropagationPass(); +// BreakCriticalEdges - Break all of the critical edges in the CFG by inserting +// a dummy basic block. This pass may be "required" by passes that cannot deal +// with critical edges. For this usage, a pass must call: +// +// AU.addRequiredID(BreakCriticalEdgesID); +// +// This pass obviously invalidates the CFG, but can update forward dominator +// (set, immediate dominators, tree, and frontier) information. +// +FunctionPass *createBreakCriticalEdgesPass(); +extern char &BreakCriticalEdgesID; //===----------------------------------------------------------------------===// // -// TailDuplication - Eliminate unconditional branches through controlled code -// duplication, creating simpler CFG structures. +// LoopSimplify - Insert Pre-header blocks into the CFG for every function in +// the module. This pass updates dominator information, loop information, and +// does not add critical edges to the CFG. +// +// AU.addRequiredID(LoopSimplifyID); // -FunctionPass *createTailDuplicationPass(); +Pass *createLoopSimplifyPass(); +extern char &LoopSimplifyID; +//===----------------------------------------------------------------------===// +// +// TailCallElimination - This pass eliminates call instructions to the current +// function which occur immediately before return instructions. +// +FunctionPass *createTailCallEliminationPass(); //===----------------------------------------------------------------------===// // -// CFG Simplification - Merge basic blocks, eliminate unreachable blocks, -// simplify terminator instructions, etc... +// LowerSwitch - This pass converts SwitchInst instructions into a sequence of +// chained binary branch instructions. // -FunctionPass *createCFGSimplificationPass(); +FunctionPass *createLowerSwitchPass(); +extern char &LowerSwitchID; +//===----------------------------------------------------------------------===// +// +// LowerInvoke - This pass converts invoke and unwind instructions to use sjlj +// exception handling mechanisms. Note that after this pass runs the CFG is not +// entirely accurate (exceptional control flow edges are not correct anymore) so +// only very simple things should be done after the lowerinvoke pass has run +// (like generation of native code). This should *NOT* be used as a general +// purpose "my LLVM-to-LLVM pass doesn't support the invoke instruction yet" +// lowering pass. +// +FunctionPass *createLowerInvokePass(const TargetLowering *TLI = 0); +FunctionPass *createLowerInvokePass(const TargetLowering *TLI, + bool useExpensiveEHSupport); +extern char &LowerInvokePassID; //===----------------------------------------------------------------------===// // -// BreakCriticalEdges pass - Break all of the critical edges in the CFG by -// inserting a dummy basic block. This pass may be "required" by passes that -// cannot deal with critical edges. For this usage, a pass must call: +// BlockPlacement - This pass reorders basic blocks in order to increase the +// number of fall-through conditional branches. // -// AU.addRequiredID(BreakCriticalEdgesID); +FunctionPass *createBlockPlacementPass(); + +//===----------------------------------------------------------------------===// // -// This pass obviously invalidates the CFG, but can update forward dominator -// (set, immediate dominators, tree, and frontier) information. +// LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop +// optimizations. // -FunctionPass *createBreakCriticalEdgesPass(); -extern const PassInfo *BreakCriticalEdgesID; +Pass *createLCSSAPass(); +extern char &LCSSAID; //===----------------------------------------------------------------------===// // -// LoopSimplify pass - Insert Pre-header blocks into the CFG for every function -// in the module. This pass updates dominator information, loop information, -// and does not add critical edges to the CFG. +// EarlyCSE - This pass performs a simple and fast CSE pass over the dominator +// tree. // -// AU.addRequiredID(LoopSimplifyID); +FunctionPass *createEarlyCSEPass(); + +//===----------------------------------------------------------------------===// // -FunctionPass *createLoopSimplifyPass(); -extern const PassInfo *LoopSimplifyID; +// GVN - This pass performs global value numbering and redundant load +// elimination cotemporaneously. +// +FunctionPass *createGVNPass(bool NoLoads = false); //===----------------------------------------------------------------------===// -// This pass converts SelectInst instructions into conditional branch and PHI -// instructions. If the OnlyFP flag is set to true, then only floating point -// select instructions are lowered. // -FunctionPass *createLowerSelectPass(bool OnlyFP = false); -extern const PassInfo *LowerSelectID; +// MemCpyOpt - This pass performs optimizations related to eliminating memcpy +// calls and/or combining multiple stores into memset's. +// +FunctionPass *createMemCpyOptPass(); //===----------------------------------------------------------------------===// // -// LowerAllocations Pass - Turn malloc and free instructions into %malloc and -// %free calls. +// LoopDeletion - This pass performs DCE of non-infinite loops that it +// can prove are dead. // -// AU.addRequiredID(LowerAllocationsID); +Pass *createLoopDeletionPass(); + +//===----------------------------------------------------------------------===// // -FunctionPass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); -extern const PassInfo *LowerAllocationsID; +/// createSimplifyLibCallsPass - This pass optimizes specific calls to +/// specific well-known (library) functions. +FunctionPass *createSimplifyLibCallsPass(); //===----------------------------------------------------------------------===// // -// This pass eliminates call instructions to the current function which occur -// immediately before return instructions. +// CodeGenPrepare - This pass prepares a function for instruction selection. // -FunctionPass *createTailCallEliminationPass(); +FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0); //===----------------------------------------------------------------------===// -// This pass converts SwitchInst instructions into a sequence of chained binary -// branch instructions. // -FunctionPass *createLowerSwitchPass(); -extern const PassInfo *LowerSwitchID; +// InstructionNamer - Give any unnamed non-void instructions "tmp" names. +// +FunctionPass *createInstructionNamerPass(); +extern char &InstructionNamerID; + +//===----------------------------------------------------------------------===// +// +// Sink - Code Sinking +// +FunctionPass *createSinkingPass(); //===----------------------------------------------------------------------===// -// This pass converts PackedType operations into low-level scalar operations. // -FunctionPass *createLowerPackedPass(); +// LowerAtomic - Lower atomic intrinsics to non-atomic form +// +Pass *createLowerAtomicPass(); //===----------------------------------------------------------------------===// -// This pass converts invoke and unwind instructions to use sjlj exception -// handling mechanisms. Note that after this pass runs the CFG is not entirely -// accurate (exceptional control flow edges are not correct anymore) so only -// very simple things should be done after the lowerinvoke pass has run (like -// generation of native code). This should *NOT* be used as a general purpose -// "my LLVM-to-LLVM pass doesn't support the invoke instruction yet" lowering -// pass. // -FunctionPass *createLowerInvokePass(const TargetLowering *TLI = NULL); -extern const PassInfo *LowerInvokePassID; +// ValuePropagation - Propagate CFG-derived value information +// +Pass *createCorrelatedValuePropagationPass(); +//===----------------------------------------------------------------------===// +// +// ObjCARCAPElim - ObjC ARC autorelease pool elimination. +// +Pass *createObjCARCAPElimPass(); //===----------------------------------------------------------------------===// -/// createLowerGCPass - This function returns an instance of the "lowergc" -/// pass, which lowers garbage collection intrinsics to normal LLVM code. -/// -FunctionPass *createLowerGCPass(); +// +// ObjCARCExpand - ObjC ARC preliminary simplifications. +// +Pass *createObjCARCExpandPass(); //===----------------------------------------------------------------------===// -// This pass reorders basic blocks in order to increase the number of fall- -// through conditional branches. -FunctionPass *createBlockPlacementPass(); +// +// ObjCARCContract - Late ObjC ARC cleanups. +// +Pass *createObjCARCContractPass(); //===----------------------------------------------------------------------===// -// This pass inserts phi nodes at loop boundaries to simplify other loop -// optimizations. -FunctionPass *createLCSSAPass(); -extern const PassInfo *LCSSAID; +// +// ObjCARCOpt - ObjC ARC optimization. +// +Pass *createObjCARCOptPass(); //===----------------------------------------------------------------------===// -// This pass collapses duplicate variables into one canonical form, -// and tries to simplify expressions along the way. -FunctionPass *createPredicateSimplifierPass(); +// +// InstructionSimplifier - Remove redundant instructions. +// +FunctionPass *createInstructionSimplifierPass(); +extern char &InstructionSimplifierID; + + +//===----------------------------------------------------------------------===// +// +// LowerExpectIntriniscs - Removes llvm.expect intrinsics and creates +// "block_weights" metadata. +FunctionPass *createLowerExpectIntrinsicPass(); + } // End llvm namespace