X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FScalar.h;h=971baeef910011ef09772ec4ac694db31a39dd82;hb=a119de86a064414622562cfe32953de7f9b0ee40;hp=58dcd428acc0798b271b1dff1507b73beb0991bd;hpb=bf3c4cfaad706db21ac82a4376e1899d0d7f0935;p=oota-llvm.git diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 58dcd428acc..971baeef910 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -1,4 +1,11 @@ -//===-- Scalar.h - Scalar Transformations ------------------------*- C++ -*-==// +//===-- Scalar.h - Scalar Transformations -----------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // // This header file defines prototypes for accessor functions that expose passes // in the Scalar transformations library. @@ -8,25 +15,26 @@ #ifndef LLVM_TRANSFORMS_SCALAR_H #define LLVM_TRANSFORMS_SCALAR_H -class Pass; +namespace llvm { + class FunctionPass; +class Pass; class GetElementPtrInst; class PassInfo; class TerminatorInst; +class TargetLowering; //===----------------------------------------------------------------------===// // -// Constant Propagation Pass - A worklist driven constant propagation pass +// ConstantPropagation - A worklist driven constant propagation pass // -Pass *createConstantPropagationPass(); - +FunctionPass *createConstantPropagationPass(); //===----------------------------------------------------------------------===// // -// Sparse Conditional Constant Propagation Pass +// SCCP - Sparse conditional constant propagation. // -Pass *createSCCPPass(); - +FunctionPass *createSCCPPass(); //===----------------------------------------------------------------------===// // @@ -36,7 +44,6 @@ Pass *createSCCPPass(); // Pass *createDeadInstEliminationPass(); - //===----------------------------------------------------------------------===// // // DeadCodeElimination - This pass is more powerful than DeadInstElimination, @@ -44,64 +51,42 @@ Pass *createDeadInstEliminationPass(); // their other instructions become dead, to eliminate chains of dead // computations. // -Pass *createDeadCodeEliminationPass(); - +FunctionPass *createDeadCodeEliminationPass(); //===----------------------------------------------------------------------===// // -// AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This -// algorithm assumes instructions are dead until proven otherwise, which makes -// it more successful are removing non-obviously dead instructions. +// DeadStoreElimination - This pass deletes stores that are post-dominated by +// must-aliased stores and are not loaded used between the stores. // -Pass *createAggressiveDCEPass(); - +FunctionPass *createDeadStoreEliminationPass(); //===----------------------------------------------------------------------===// // -// Scalar Replacement of Aggregates - Break up alloca's of aggregates into -// multiple allocas if possible. +// AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This +// algorithm assumes instructions are dead until proven otherwise, which makes +// it more successful are removing non-obviously dead instructions. // -Pass *createScalarReplAggregatesPass(); - -//===----------------------------------------------------------------------===// -// -// DecomposeMultiDimRefs - Convert multi-dimensional references consisting of -// any combination of 2 or more array and structure indices into a sequence of -// instructions (using getelementpr and cast) so that each instruction has at -// most one index (except structure references, which need an extra leading -// index of [0]). - -// This pass decomposes all multi-dimensional references in a function. -FunctionPass *createDecomposeMultiDimRefsPass(); - -// This function decomposes a single instance of such a reference. -// Return value: true if the instruction was replaced; false otherwise. -// -bool DecomposeArrayRef(GetElementPtrInst* GEP); +FunctionPass *createAggressiveDCEPass(); //===----------------------------------------------------------------------===// // -// 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. // -Pass *createGCSEPass(); - +FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1); //===----------------------------------------------------------------------===// // // InductionVariableSimplify - Transform induction variables in a program to all -// use a single cannonical induction variable per loop. +// use a single canonical induction variable per loop. // Pass *createIndVarSimplifyPass(); - //===----------------------------------------------------------------------===// // // InstructionCombining - Combine instructions to form fewer, simple -// instructions. This pass does not modify the CFG, and has a tendancy 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 @@ -109,149 +94,249 @@ Pass *createIndVarSimplifyPass(); // into: // %Z = add int 2, %X // -Pass *createInstructionCombiningPass(); - +FunctionPass *createInstructionCombiningPass(); //===----------------------------------------------------------------------===// // -// LICM - This pass is a simple natural loop based loop invariant code motion -// pass. +// LICM - This pass is a loop invariant code motion and memory promotion pass. // Pass *createLICMPass(); +//===----------------------------------------------------------------------===// +// +// LoopStrengthReduce - This pass is strength reduces GEP instructions that use +// a loop's canonical induction variable as one of their indices. It takes an +// optional parameter used to consult the target machine whether certain +// transformations are profitable. +// +Pass *createLoopStrengthReducePass(const TargetLowering *TLI = 0); //===----------------------------------------------------------------------===// // -// PiNodeInsertion - This pass inserts single entry Phi nodes into basic blocks -// that are preceeded by a conditional branch, where the branch gives -// information about the operands of the condition. For example, this C code: -// if (x == 0) { ... = x + 4; -// becomes: -// if (x == 0) { -// x2 = phi(x); // Node that can hold data flow information about X -// ... = x2 + 4; +// LoopUnswitch - This pass is a simple loop unswitching pass. // -// Since the direction of the condition branch gives information about X itself -// (whether or not it is zero), some passes (like value numbering or ABCD) can -// use the inserted Phi/Pi nodes as a place to attach information, in this case -// saying that X has a value of 0 in this scope. The power of this analysis -// information is that "in the scope" translates to "for all uses of x2". +Pass *createLoopUnswitchPass(bool OptimizeForSize = false); + +//===----------------------------------------------------------------------===// // -// This special form of Phi node is refered to as a Pi node, following the -// terminology defined in the "Array Bounds Checks on Demand" paper. +// LoopUnroll - This pass is a simple loop unrolling pass. // -Pass *createPiNodeInsertionPass(); +Pass *createLoopUnrollPass(); +//===----------------------------------------------------------------------===// +// +// LoopRotate - This pass is a simple loop rotating pass. +// +Pass *createLoopRotatePass(); //===----------------------------------------------------------------------===// // -// This pass is used to promote memory references to be register references. A -// simple example of the transformation performed by this pass is: +// LoopIndexSplit - This pass divides loop's iteration range by spliting loop +// such that each individual loop is executed efficiently. +// +Pass *createLoopIndexSplitPass(); + +//===----------------------------------------------------------------------===// +// +// 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 // -Pass *createPromoteMemoryToRegister(); +FunctionPass *createPromoteMemoryToRegisterPass(); +extern const PassInfo *const PromoteMemoryToRegisterID; +//===----------------------------------------------------------------------===// +// +// 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 *const 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) // -Pass *createReassociatePass(); +FunctionPass *createReassociatePass(); //===----------------------------------------------------------------------===// // -// This pass eliminates correlated conditions, such as these: -// if (X == 0) -// if (X > 2) ; // Known false -// else -// Y = X * Z; // = 0 +// CondPropagationPass - This pass propagates information about conditional +// expressions through the program, allowing it to eliminate conditional +// branches in some cases. // -Pass *createCorrelatedExpressionEliminationPass(); +FunctionPass *createCondPropagationPass(); //===----------------------------------------------------------------------===// // // TailDuplication - Eliminate unconditional branches through controlled code // duplication, creating simpler CFG structures. // -Pass *createTailDuplicationPass(); - +FunctionPass *createTailDuplicationPass(); //===----------------------------------------------------------------------===// // -// CFG Simplification - Merge basic blocks, eliminate unreachable blocks, +// JumpThreading - Thread control through mult-pred/multi-succ blocks where some +// preds always go to some succ. +// +FunctionPass *createJumpThreadingPass(); + +//===----------------------------------------------------------------------===// +// +// CFGSimplification - Merge basic blocks, eliminate unreachable blocks, // simplify terminator instructions, etc... // -Pass *createCFGSimplificationPass(); - +FunctionPass *createCFGSimplificationPass(); //===----------------------------------------------------------------------===// // -// 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: +// 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, and tree) information. +// (set, immediate dominators, tree, and frontier) information. // -Pass *createBreakCriticalEdgesPass(); -extern const PassInfo *BreakCriticalEdgesID; +FunctionPass *createBreakCriticalEdgesPass(); +extern const PassInfo *const BreakCriticalEdgesID; -// The BreakCriticalEdges pass also exposes some low-level functionality that -// may be used by other passes. +//===----------------------------------------------------------------------===// +// +// 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 *createLoopSimplifyPass(); +extern const PassInfo *const LoopSimplifyID; -/// isCriticalEdge - Return true if the specified edge is a critical edge. -/// Critical edges are edges from a block with multiple successors to a block -/// with multiple predecessors. -/// -bool isCriticalEdge(const TerminatorInst *TI, unsigned SuccNum); +//===----------------------------------------------------------------------===// +// +// LowerAllocations - Turn malloc and free instructions into %malloc and %free +// calls. +// +// AU.addRequiredID(LowerAllocationsID); +// +Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); +extern const PassInfo *const LowerAllocationsID; -/// SplitCriticalEdge - Insert a new node node to split the critical edge. This -/// will update DominatorSet, ImmediateDominator and DominatorTree information -/// if a pass is specified, thus calling this pass will not invalidate these -/// analyses. -/// -void SplitCriticalEdge(TerminatorInst *TI, unsigned SuccNum, Pass *P = 0); +//===----------------------------------------------------------------------===// +// +// TailCallElimination - This pass eliminates call instructions to the current +// function which occur immediately before return instructions. +// +FunctionPass *createTailCallEliminationPass(); //===----------------------------------------------------------------------===// // -// LoopPreheaders 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. +// LowerSwitch - This pass converts SwitchInst instructions into a sequence of +// chained binary branch instructions. // -// AU.addRequiredID(LoopPreheadersID); +FunctionPass *createLowerSwitchPass(); +extern const PassInfo *const 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. // -Pass *createLoopPreheaderInsertionPass(); -extern const PassInfo *LoopPreheadersID; +FunctionPass *createLowerInvokePass(const TargetLowering *TLI = 0); +extern const PassInfo *const LowerInvokePassID; +//===----------------------------------------------------------------------===// +// +// BlockPlacement - This pass reorders basic blocks in order to increase the +// number of fall-through conditional branches. +// +FunctionPass *createBlockPlacementPass(); //===----------------------------------------------------------------------===// -// These two passes convert malloc and free instructions to and from %malloc & -// %free function calls. // -FunctionPass *createLowerAllocationsPass(); -Pass *createRaiseAllocationsPass(); +// LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop +// optimizations. +// +Pass *createLCSSAPass(); +extern const PassInfo *const LCSSAID; //===----------------------------------------------------------------------===// -// This pass converts SwitchInst instructions into a sequence of chained binary -// branch instructions. // -FunctionPass *createLowerSwitchPass(); +// PredicateSimplifier - This pass collapses duplicate variables into one +// canonical form, and tries to simplify expressions along the way. +// +FunctionPass *createPredicateSimplifierPass(); + +//===----------------------------------------------------------------------===// +// +// GVN-PRE - This pass performs global value numbering and partial redundancy +// elimination. +// +FunctionPass *createGVNPREPass(); + +//===----------------------------------------------------------------------===// +// +// GVN - This pass performs global value numbering and redundant load +// elimination cotemporaneously. +// +FunctionPass *createGVNPass(); + +//===----------------------------------------------------------------------===// +// +// MemCpyOpt - This pass performs optimizations related to eliminating memcpy +// calls and/or combining multiple stores into memset's. +// +FunctionPass *createMemCpyOptPass(); + +//===----------------------------------------------------------------------===// +// +// LoopDeletion - This pass performs DCE of non-infinite loops that it +// can prove are dead. +// +Pass *createLoopDeletionPass(); + +//===----------------------------------------------------------------------===// +// +/// createSimplifyLibCallsPass - This pass optimizes specific calls to +/// specific well-known (library) functions. +FunctionPass *createSimplifyLibCallsPass(); + +//===----------------------------------------------------------------------===// +// +/// createSimplifyHalfPowrLibCallsPass - This is an experimental pass that +/// optimizes specific half_pow functions. +FunctionPass *createSimplifyHalfPowrLibCallsPass(); + +//===----------------------------------------------------------------------===// +// +// CodeGenPrepare - This pass prepares a function for instruction selection. +// +FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0); + //===----------------------------------------------------------------------===// // -// These functions removes symbols from functions and modules. +// InstructionNamer - Give any unnamed non-void instructions "tmp" names. // -Pass *createSymbolStrippingPass(); -Pass *createFullSymbolStrippingPass(); +FunctionPass *createInstructionNamerPass(); +extern const PassInfo *const InstructionNamerID; + +} // End llvm namespace #endif