X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FScalar.h;h=4cc59dd3c7545192b5686e82d87101ea47c705f2;hb=59f6449cff14d7edac319d4eab4b52b8bd858e92;hp=91cc81a1b2e4349528c6701abf9965cd215ea519;hpb=332f3679d042a8c91afe9920e95fa7b5972fe408;p=oota-llvm.git diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 91cc81a1b2e..4cc59dd3c75 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,20 +15,34 @@ #ifndef LLVM_TRANSFORMS_SCALAR_H #define LLVM_TRANSFORMS_SCALAR_H -class Pass; +namespace llvm { + +class ModulePass; +class FunctionPass; +class GetElementPtrInst; +class PassInfo; +class TerminatorInst; + +//===----------------------------------------------------------------------===// +// +// RaisePointerReferences - Try to eliminate as many pointer arithmetic +// expressions as possible, by converting expressions to use getelementptr and +// friends. +// +FunctionPass *createRaisePointerReferencesPass(); //===----------------------------------------------------------------------===// // -// Constant Propogation Pass - A worklist driven constant propogation pass +// Constant Propagation Pass - A worklist driven constant propagation pass // -Pass *createConstantPropogationPass(); +FunctionPass *createConstantPropagationPass(); //===----------------------------------------------------------------------===// // -// Sparse Conditional Constant Propogation Pass +// Sparse Conditional Constant Propagation Pass // -Pass *createSCCPPass(); +FunctionPass *createSCCPPass(); //===----------------------------------------------------------------------===// @@ -30,7 +51,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(); //===----------------------------------------------------------------------===// @@ -40,27 +61,30 @@ 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(); //===----------------------------------------------------------------------===// // -// AgressiveDCE - This pass uses the SSA based Agressive DCE algorithm. This +// 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 *createAgressiveDCEPass(); +FunctionPass *createAggressiveDCEPass(); //===----------------------------------------------------------------------===// -// -// 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]). // -Pass *createDecomposeMultiDimRefsPass(); +// Scalar Replacement of Aggregates - Break up alloca's of aggregates into +// multiple allocas if possible. +// +FunctionPass *createScalarReplAggregatesPass(); //===----------------------------------------------------------------------===// @@ -70,21 +94,21 @@ Pass *createDecomposeMultiDimRefsPass(); // examining the SSA value graph of the function, instead of doing slow // bit-vector computations. // -Pass *createGCSEPass(); +FunctionPass *createGCSEPass(); //===----------------------------------------------------------------------===// // // 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(); +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: @@ -93,8 +117,37 @@ Pass *createIndVarSimplifyPass(); // into: // %Z = add int 2, %X // -Pass *createInstructionCombiningPass(); +FunctionPass *createInstructionCombiningPass(); + +//===----------------------------------------------------------------------===// +// +// LICM - This pass is a loop invariant code motion and memory promotion pass. +// +FunctionPass *createLICMPass(); + +//===----------------------------------------------------------------------===// +// +// LoopStrengthReduce - This pass is strength reduces GEP instructions that use +// a loop's canonical induction variable as one of their indices. The +// MaxTargetAMSize is the largest element size that the target architecture +// can handle in its addressing modes. Power of two multipliers less than or +// equal to this value are not reduced. +// +FunctionPass *createLoopStrengthReducePass(unsigned MaxTargetAMSize = 1); + +//===----------------------------------------------------------------------===// +// +// LoopUnswitch - This pass is a simple loop unswitching pass. +// +FunctionPass *createLoopUnswitchPass(); + + +//===----------------------------------------------------------------------===// +// +// LoopUnroll - This pass is a simple loop unrolling pass. +// +FunctionPass *createLoopUnrollPass(); //===----------------------------------------------------------------------===// // @@ -107,14 +160,141 @@ Pass *createInstructionCombiningPass(); // %Y = load int* %X // ret int %Y // -Pass *createPromoteMemoryToRegister(); +FunctionPass *createPromoteMemoryToRegisterPass(); + + +//===----------------------------------------------------------------------===// +// +// 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) +// +FunctionPass *createReassociatePass(); + +//===----------------------------------------------------------------------===// +// +// This pass eliminates correlated conditions, such as these: +// if (X == 0) +// if (X > 2) ; // Known false +// else +// Y = X * Z; // = 0 +// +FunctionPass *createCorrelatedExpressionEliminationPass(); +// createCondPropagationPass - This pass propagates information about +// conditional expressions through the program, allowing it to eliminate +// conditional branches in some cases. +// +FunctionPass *createCondPropagationPass(); + //===----------------------------------------------------------------------===// // -// These functions removes symbols from functions and modules. +// TailDuplication - Eliminate unconditional branches through controlled code +// duplication, creating simpler CFG structures. // -Pass *createSymbolStrippingPass(); -Pass *createFullSymbolStrippingPass(); +FunctionPass *createTailDuplicationPass(); + + +//===----------------------------------------------------------------------===// +// +// CFG Simplification - Merge basic blocks, eliminate unreachable blocks, +// simplify terminator instructions, etc... +// +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: +// +// AU.addRequiredID(BreakCriticalEdgesID); +// +// This pass obviously invalidates the CFG, but can update forward dominator +// (set, immediate dominators, tree, and frontier) information. +// +FunctionPass *createBreakCriticalEdgesPass(); +extern const PassInfo *BreakCriticalEdgesID; + +//===----------------------------------------------------------------------===// +// +// 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; + +//===----------------------------------------------------------------------===// +// +// This pass eliminates call instructions to the current function which occur +// immediately before return instructions. +// +FunctionPass *createTailCallEliminationPass(); + + +//===----------------------------------------------------------------------===// +// This pass convert malloc and free instructions to %malloc & %free function +// calls. +// +FunctionPass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); + +//===----------------------------------------------------------------------===// +// This pass converts SwitchInst instructions into a sequence of chained binary +// branch instructions. +// +FunctionPass *createLowerSwitchPass(); + +//===----------------------------------------------------------------------===// +// 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); + +//===----------------------------------------------------------------------===// +// This pass converts PackedType operations into low-level scalar operations. +// +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. +// +FunctionPass *createLowerInvokePass(); +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(); + +//===----------------------------------------------------------------------===// +// Returns a pass which converts all instances of ConstantExpression +// into regular LLVM instructions. +FunctionPass* createLowerConstantExpressionsPass(); + +//===----------------------------------------------------------------------===// +// This pass reorders basic blocks in order to increase the number of fall- +// through conditional branches. +FunctionPass *createBlockPlacementPass(); + +//===----------------------------------------------------------------------===// +// This pass does partial redundancy elimination. +FunctionPass *createPREPass(); + +} // End llvm namespace #endif