X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FScalar.h;h=971baeef910011ef09772ec4ac694db31a39dd82;hb=4b35f83b91a1a313f0730c600e5178aaf7df98d6;hp=7ba7ce85092ef0bbbfb7a117dccc6f12d53457a9;hpb=fee76bd9ba038a4640259ffcbb2c6e2bd970a3ca;p=oota-llvm.git diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 7ba7ce85092..971baeef910 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,9 @@ #ifndef LLVM_TRANSFORMS_SCALAR_H #define LLVM_TRANSFORMS_SCALAR_H -#include - namespace llvm { class FunctionPass; -class LoopPass; class Pass; class GetElementPtrInst; class PassInfo; @@ -78,21 +75,12 @@ FunctionPass *createAggressiveDCEPass(); // FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1); -//===----------------------------------------------------------------------===// -// -// 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. -// -FunctionPass *createGCSEPass(); - //===----------------------------------------------------------------------===// // // InductionVariableSimplify - Transform induction variables in a program to all // use a single canonical induction variable per loop. // -LoopPass *createIndVarSimplifyPass(); +Pass *createIndVarSimplifyPass(); //===----------------------------------------------------------------------===// // @@ -112,7 +100,7 @@ FunctionPass *createInstructionCombiningPass(); // // LICM - This pass is a loop invariant code motion and memory promotion pass. // -LoopPass *createLICMPass(); +Pass *createLICMPass(); //===----------------------------------------------------------------------===// // @@ -121,32 +109,32 @@ LoopPass *createLICMPass(); // optional parameter used to consult the target machine whether certain // transformations are profitable. // -LoopPass *createLoopStrengthReducePass(const TargetLowering *TLI = 0); +Pass *createLoopStrengthReducePass(const TargetLowering *TLI = 0); //===----------------------------------------------------------------------===// // // LoopUnswitch - This pass is a simple loop unswitching pass. // -LoopPass *createLoopUnswitchPass(bool OptimizeForSize = false); +Pass *createLoopUnswitchPass(bool OptimizeForSize = false); //===----------------------------------------------------------------------===// // // LoopUnroll - This pass is a simple loop unrolling pass. // -LoopPass *createLoopUnrollPass(); +Pass *createLoopUnrollPass(); //===----------------------------------------------------------------------===// // // LoopRotate - This pass is a simple loop rotating pass. // -LoopPass *createLoopRotatePass(); +Pass *createLoopRotatePass(); //===----------------------------------------------------------------------===// // -// LoopIndexSplit - This pass splits loop +// LoopIndexSplit - This pass divides loop's iteration range by spliting loop +// such that each individual loop is executed efficiently. // -LoopPass *createLoopIndexSplitPass(); - +Pass *createLoopIndexSplitPass(); //===----------------------------------------------------------------------===// // @@ -155,13 +143,13 @@ LoopPass *createLoopIndexSplitPass(); // 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; +extern const PassInfo *const PromoteMemoryToRegisterID; //===----------------------------------------------------------------------===// // @@ -170,7 +158,7 @@ extern const PassInfo *PromoteMemoryToRegisterID; // hacking easier. // FunctionPass *createDemoteRegisterToMemoryPass(); -extern const PassInfo *DemoteRegisterToMemoryID; +extern const PassInfo *const DemoteRegisterToMemoryID; //===----------------------------------------------------------------------===// // @@ -181,17 +169,6 @@ extern const PassInfo *DemoteRegisterToMemoryID; // FunctionPass *createReassociatePass(); -//===----------------------------------------------------------------------===// -// -// CorrelatedExpressionElimination - This pass eliminates correlated -// conditions, such as these: -// if (X == 0) -// if (X > 2) ; // Known false -// else -// Y = X * Z; // = 0 -// -FunctionPass *createCorrelatedExpressionEliminationPass(); - //===----------------------------------------------------------------------===// // // CondPropagationPass - This pass propagates information about conditional @@ -207,6 +184,13 @@ FunctionPass *createCondPropagationPass(); // FunctionPass *createTailDuplicationPass(); +//===----------------------------------------------------------------------===// +// +// 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, @@ -226,7 +210,7 @@ FunctionPass *createCFGSimplificationPass(); // (set, immediate dominators, tree, and frontier) information. // FunctionPass *createBreakCriticalEdgesPass(); -extern const PassInfo *BreakCriticalEdgesID; +extern const PassInfo *const BreakCriticalEdgesID; //===----------------------------------------------------------------------===// // @@ -237,16 +221,7 @@ extern const PassInfo *BreakCriticalEdgesID; // AU.addRequiredID(LoopSimplifyID); // FunctionPass *createLoopSimplifyPass(); -extern const PassInfo *LoopSimplifyID; - -//===----------------------------------------------------------------------===// -// -// LowerSelect - 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; +extern const PassInfo *const LoopSimplifyID; //===----------------------------------------------------------------------===// // @@ -256,7 +231,7 @@ extern const PassInfo *LowerSelectID; // AU.addRequiredID(LowerAllocationsID); // Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); -extern const PassInfo *LowerAllocationsID; +extern const PassInfo *const LowerAllocationsID; //===----------------------------------------------------------------------===// // @@ -271,14 +246,7 @@ FunctionPass *createTailCallEliminationPass(); // chained binary branch instructions. // FunctionPass *createLowerSwitchPass(); -extern const PassInfo *LowerSwitchID; - -//===----------------------------------------------------------------------===// -// -// LowerPacked - This pass converts VectorType operations into low-level scalar -// operations. -// -FunctionPass *createLowerPackedPass(); +extern const PassInfo *const LowerSwitchID; //===----------------------------------------------------------------------===// // @@ -290,15 +258,8 @@ FunctionPass *createLowerPackedPass(); // 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; - -//===----------------------------------------------------------------------===// -// -// LowerGCPass - This function returns an instance of the "lowergc" pass, which -// lowers garbage collection intrinsics to normal LLVM code. -// -FunctionPass *createLowerGCPass(); +FunctionPass *createLowerInvokePass(const TargetLowering *TLI = 0); +extern const PassInfo *const LowerInvokePassID; //===----------------------------------------------------------------------===// // @@ -312,8 +273,8 @@ FunctionPass *createBlockPlacementPass(); // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop // optimizations. // -LoopPass *createLCSSAPass(); -extern const PassInfo *LCSSAID; +Pass *createLCSSAPass(); +extern const PassInfo *const LCSSAID; //===----------------------------------------------------------------------===// // @@ -331,17 +292,36 @@ FunctionPass *createGVNPREPass(); //===----------------------------------------------------------------------===// // -// RedundantLoadElimination - This pass deletes loads that are dominated by -// must-aliased loads and are not stored to between the loads. +// GVN - This pass performs global value numbering and redundant load +// elimination cotemporaneously. // -FunctionPass *createRedundantLoadEliminationPass(); +FunctionPass *createGVNPass(); //===----------------------------------------------------------------------===// // -// GVN - This pass performs global value numbering and redundant load -// elimination cotemporaneously. +// MemCpyOpt - This pass performs optimizations related to eliminating memcpy +// calls and/or combining multiple stores into memset's. // -FunctionPass *createGVNPass(); +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(); //===----------------------------------------------------------------------===// // @@ -349,6 +329,14 @@ FunctionPass *createGVNPass(); // FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0); + +//===----------------------------------------------------------------------===// +// +// InstructionNamer - Give any unnamed non-void instructions "tmp" names. +// +FunctionPass *createInstructionNamerPass(); +extern const PassInfo *const InstructionNamerID; + } // End llvm namespace #endif