X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FScalar.h;h=111ced11d64b6f80d749c461bcd381d5a4b208a5;hb=11f510b577878e61e62a3a9c5c8d86483961d20c;hp=b240f58dc83cddc1dc0ace1638dcf5c58ea12a97;hpb=065a616adad624152618b1b0084ff074e5b03bbb;p=oota-llvm.git diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index b240f58dc83..111ced11d64 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 was developed by the LLVM research group and 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,11 +15,16 @@ #ifndef LLVM_TRANSFORMS_SCALAR_H #define LLVM_TRANSFORMS_SCALAR_H -class Pass; +#include + +namespace llvm { + +class ModulePass; class FunctionPass; class GetElementPtrInst; class PassInfo; class TerminatorInst; +class TargetLowering; //===----------------------------------------------------------------------===// // @@ -20,20 +32,20 @@ class TerminatorInst; // expressions as possible, by converting expressions to use getelementptr and // friends. // -Pass *createRaisePointerReferencesPass(); +FunctionPass *createRaisePointerReferencesPass(); //===----------------------------------------------------------------------===// // // Constant Propagation Pass - A worklist driven constant propagation pass // -Pass *createConstantPropagationPass(); +FunctionPass *createConstantPropagationPass(); //===----------------------------------------------------------------------===// // // Sparse Conditional Constant Propagation Pass // -Pass *createSCCPPass(); +FunctionPass *createSCCPPass(); //===----------------------------------------------------------------------===// @@ -42,7 +54,7 @@ Pass *createSCCPPass(); // without modifying the CFG of the function. It is a BasicBlockPass, so it // runs efficiently when queued next to other BasicBlockPass's. // -Pass *createDeadInstEliminationPass(); +FunctionPass *createDeadInstEliminationPass(); //===----------------------------------------------------------------------===// @@ -52,8 +64,14 @@ Pass *createDeadInstEliminationPass(); // their other instructions become dead, to eliminate chains of dead // computations. // -Pass *createDeadCodeEliminationPass(); +FunctionPass *createDeadCodeEliminationPass(); +//===----------------------------------------------------------------------===// +// +// DeadStoreElimination - This pass deletes stores that are post-dominated by +// must-aliased stores and are not loaded used between the stores. +// +FunctionPass *createDeadStoreEliminationPass(); //===----------------------------------------------------------------------===// // @@ -61,7 +79,7 @@ Pass *createDeadCodeEliminationPass(); // algorithm assumes instructions are dead until proven otherwise, which makes // it more successful are removing non-obviously dead instructions. // -Pass *createAggressiveDCEPass(); +FunctionPass *createAggressiveDCEPass(); //===----------------------------------------------------------------------===// @@ -69,23 +87,8 @@ Pass *createAggressiveDCEPass(); // Scalar Replacement of Aggregates - Break up alloca's of aggregates into // multiple allocas if possible. // -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(); +FunctionPass *createScalarReplAggregatesPass(); -// This function decomposes a single instance of such a reference. -// Return value: true if the instruction was replaced; false otherwise. -// -bool DecomposeArrayRef(GetElementPtrInst* GEP); //===----------------------------------------------------------------------===// // @@ -94,7 +97,7 @@ bool DecomposeArrayRef(GetElementPtrInst* GEP); // examining the SSA value graph of the function, instead of doing slow // bit-vector computations. // -Pass *createGCSEPass(); +FunctionPass *createGCSEPass(); //===----------------------------------------------------------------------===// @@ -102,13 +105,13 @@ Pass *createGCSEPass(); // InductionVariableSimplify - Transform induction variables in a program to all // use a single canonical induction variable per loop. // -Pass *createIndVarSimplifyPass(); +FunctionPass *createIndVarSimplifyPass(); //===----------------------------------------------------------------------===// // // InstructionCombining - Combine instructions to form fewer, simple -// instructions. This pass does not modify the CFG, and has a tendancy to +// 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: @@ -117,39 +120,36 @@ 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(); - +FunctionPass *createLICMPass(); //===----------------------------------------------------------------------===// // -// 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; +// 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. // -// 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". +FunctionPass *createLoopStrengthReducePass(const TargetLowering *TLI = NULL); + +//===----------------------------------------------------------------------===// // -// 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. +// LoopUnswitch - This pass is a simple loop unswitching pass. // -Pass *createPiNodeInsertionPass(); +FunctionPass *createLoopUnswitchPass(); + +//===----------------------------------------------------------------------===// +// +// LoopUnroll - This pass is a simple loop unrolling pass. +// +FunctionPass *createLoopUnrollPass(); //===----------------------------------------------------------------------===// // @@ -162,8 +162,16 @@ Pass *createPiNodeInsertionPass(); // %Y = load int* %X // ret int %Y // -Pass *createPromoteMemoryToRegister(); +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. +FunctionPass *createDemoteRegisterToMemoryPass(); +extern const PassInfo *DemoteRegisterToMemoryID; //===----------------------------------------------------------------------===// // @@ -172,7 +180,7 @@ Pass *createPromoteMemoryToRegister(); // // For example: 4 + (x + 5) -> x + (4 + 5) // -Pass *createReassociatePass(); +FunctionPass *createReassociatePass(); //===----------------------------------------------------------------------===// // @@ -182,14 +190,21 @@ Pass *createReassociatePass(); // else // Y = X * Z; // = 0 // -Pass *createCorrelatedExpressionEliminationPass(); +FunctionPass *createCorrelatedExpressionEliminationPass(); + + +// createCondPropagationPass - This pass propagates information about +// conditional expressions through the program, allowing it to eliminate +// conditional branches in some cases. +// +FunctionPass *createCondPropagationPass(); //===----------------------------------------------------------------------===// // // TailDuplication - Eliminate unconditional branches through controlled code // duplication, creating simpler CFG structures. // -Pass *createTailDuplicationPass(); +FunctionPass *createTailDuplicationPass(); //===----------------------------------------------------------------------===// @@ -197,7 +212,7 @@ Pass *createTailDuplicationPass(); // CFG Simplification - Merge basic blocks, eliminate unreachable blocks, // simplify terminator instructions, etc... // -Pass *createCFGSimplificationPass(); +FunctionPass *createCFGSimplificationPass(); //===----------------------------------------------------------------------===// @@ -209,56 +224,89 @@ Pass *createCFGSimplificationPass(); // 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(); +FunctionPass *createBreakCriticalEdgesPass(); extern const PassInfo *BreakCriticalEdgesID; -// The BreakCriticalEdges pass also exposes some low-level functionality that -// may be used by other passes. - -/// 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); +//===----------------------------------------------------------------------===// +// +// 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. +// +// AU.addRequiredID(LoopSimplifyID); +// +FunctionPass *createLoopSimplifyPass(); +extern const PassInfo *LoopSimplifyID; -/// 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); +//===----------------------------------------------------------------------===// +// 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; //===----------------------------------------------------------------------===// // -// 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. +// LowerAllocations Pass - Turn malloc and free instructions into %malloc and +// %free calls. // -// AU.addRequiredID(LoopPreheadersID); +// AU.addRequiredID(LowerAllocationsID); // -Pass *createLoopPreheaderInsertionPass(); -extern const PassInfo *LoopPreheadersID; - +FunctionPass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); +extern const PassInfo *LowerAllocationsID; //===----------------------------------------------------------------------===// -// This pass convert malloc and free instructions to %malloc & %free function -// calls. // -FunctionPass *createLowerAllocationsPass(); +// This pass eliminates call instructions to the current function which occur +// immediately before return instructions. +// +FunctionPass *createTailCallEliminationPass(); //===----------------------------------------------------------------------===// // This pass converts SwitchInst instructions into a sequence of chained binary // branch instructions. // FunctionPass *createLowerSwitchPass(); +extern const PassInfo *LowerSwitchID; //===----------------------------------------------------------------------===// +// This pass converts PackedType operations into low-level scalar operations. // -// These functions removes symbols from functions and modules. +FunctionPass *createLowerPackedPass(); + +//===----------------------------------------------------------------------===// +// 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 *createSymbolStrippingPass(); -Pass *createFullSymbolStrippingPass(); +FunctionPass *createLowerInvokePass(unsigned JumBufSize = 200, + unsigned JumpBufAlign = 0); +extern const PassInfo *LowerInvokePassID; + + +//===----------------------------------------------------------------------===// +/// createLowerGCPass - This function returns an instance of the "lowergc" +/// pass, which lowers garbage collection intrinsics to normal LLVM code. +/// +FunctionPass *createLowerGCPass(); + +//===----------------------------------------------------------------------===// +// This pass reorders basic blocks in order to increase the number of fall- +// through conditional branches. +FunctionPass *createBlockPlacementPass(); + +//===----------------------------------------------------------------------===// +// This pass inserts phi nodes at loop boundaries to simplify other loop +// optimizations. +FunctionPass *createLCSSAPass(); + +} // End llvm namespace #endif