X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FScalar.h;h=7f055d4461711e68e3e8778f67ba4f68d5b47d20;hb=fc3665c87519850f629c9565535e3be447e10add;hp=650be05aea327d521dc6f96ff74fc316f1027837;hpb=6ddba2b933645d308428201e942abe1274fa5085;p=oota-llvm.git diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 650be05aea3..7f055d44617 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -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; @@ -76,23 +73,15 @@ FunctionPass *createAggressiveDCEPass(); // ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas // if possible. // -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(); +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. // -LoopPass *createIndVarSimplifyPass(); +Pass *createIndVarSimplifyPass(); //===----------------------------------------------------------------------===// // @@ -112,7 +101,7 @@ FunctionPass *createInstructionCombiningPass(); // // LICM - This pass is a loop invariant code motion and memory promotion pass. // -LoopPass *createLICMPass(); +Pass *createLICMPass(); //===----------------------------------------------------------------------===// // @@ -121,34 +110,40 @@ 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); + +Pass *createGlobalMergePass(const TargetLowering *TLI = 0); //===----------------------------------------------------------------------===// // // LoopUnswitch - This pass is a simple loop unswitching pass. // -LoopPass *createLoopUnswitchPass(bool OptimizeForSize = false); +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. // -LoopPass *createLoopUnrollPass(); +Pass *createLoopUnrollPass(int Threshold = -1, int Count = -1, int AllowPartial = -1); //===----------------------------------------------------------------------===// // // LoopRotate - This pass is a simple loop rotating pass. // -LoopPass *createLoopRotatePass(); +Pass *createLoopRotatePass(); //===----------------------------------------------------------------------===// // -// LoopIndexSplit - This pass divides loop's iteration range by spliting loop -// such that each individual loop is executed efficiently. +// LoopIdiom - This pass recognizes and replaces idioms in loops. // -LoopPass *createLoopIndexSplitPass(); - - +Pass *createLoopIdiomPass(); + //===----------------------------------------------------------------------===// // // PromoteMemoryToRegister - This pass is used to promote memory references to @@ -156,13 +151,12 @@ 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 *const PromoteMemoryToRegisterID; //===----------------------------------------------------------------------===// // @@ -171,7 +165,7 @@ extern const PassInfo *const PromoteMemoryToRegisterID; // hacking easier. // FunctionPass *createDemoteRegisterToMemoryPass(); -extern const PassInfo *const DemoteRegisterToMemoryID; +extern char &DemoteRegisterToMemoryID; //===----------------------------------------------------------------------===// // @@ -182,21 +176,6 @@ extern const PassInfo *const DemoteRegisterToMemoryID; // FunctionPass *createReassociatePass(); -//===----------------------------------------------------------------------===// -// -// CondPropagationPass - 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. -// -FunctionPass *createTailDuplicationPass(); - //===----------------------------------------------------------------------===// // // JumpThreading - Thread control through mult-pred/multi-succ blocks where some @@ -204,7 +183,7 @@ FunctionPass *createTailDuplicationPass(); // FunctionPass *createJumpThreadingPass(); - //===----------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// // // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, // simplify terminator instructions, etc... @@ -223,7 +202,7 @@ FunctionPass *createCFGSimplificationPass(); // (set, immediate dominators, tree, and frontier) information. // FunctionPass *createBreakCriticalEdgesPass(); -extern const PassInfo *const BreakCriticalEdgesID; +extern char &BreakCriticalEdgesID; //===----------------------------------------------------------------------===// // @@ -233,18 +212,8 @@ extern const PassInfo *const BreakCriticalEdgesID; // // AU.addRequiredID(LoopSimplifyID); // -FunctionPass *createLoopSimplifyPass(); -extern const PassInfo *const LoopSimplifyID; - -//===----------------------------------------------------------------------===// -// -// LowerAllocations - Turn malloc and free instructions into %malloc and %free -// calls. -// -// AU.addRequiredID(LowerAllocationsID); -// -Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); -extern const PassInfo *const LowerAllocationsID; +Pass *createLoopSimplifyPass(); +extern char &LoopSimplifyID; //===----------------------------------------------------------------------===// // @@ -259,7 +228,7 @@ FunctionPass *createTailCallEliminationPass(); // chained binary branch instructions. // FunctionPass *createLowerSwitchPass(); -extern const PassInfo *const LowerSwitchID; +extern char &LowerSwitchID; //===----------------------------------------------------------------------===// // @@ -271,8 +240,10 @@ extern const PassInfo *const LowerSwitchID; // purpose "my LLVM-to-LLVM pass doesn't support the invoke instruction yet" // lowering pass. // -FunctionPass *createLowerInvokePass(const TargetLowering *TLI = NULL); -extern const PassInfo *const LowerInvokePassID; +FunctionPass *createLowerInvokePass(const TargetLowering *TLI = 0); +FunctionPass *createLowerInvokePass(const TargetLowering *TLI, + bool useExpensiveEHSupport); +extern char &LowerInvokePassID; //===----------------------------------------------------------------------===// // @@ -286,29 +257,22 @@ FunctionPass *createBlockPlacementPass(); // LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop // optimizations. // -LoopPass *createLCSSAPass(); -extern const PassInfo *const LCSSAID; - -//===----------------------------------------------------------------------===// -// -// PredicateSimplifier - This pass collapses duplicate variables into one -// canonical form, and tries to simplify expressions along the way. -// -FunctionPass *createPredicateSimplifierPass(); +Pass *createLCSSAPass(); +extern char &LCSSAID; //===----------------------------------------------------------------------===// // -// GVN-PRE - This pass performs global value numbering and partial redundancy -// elimination. +// EarlyCSE - This pass performs a simple and fast CSE pass over the dominator +// tree. // -FunctionPass *createGVNPREPass(); - +FunctionPass *createEarlyCSEPass(); + //===----------------------------------------------------------------------===// // // GVN - This pass performs global value numbering and redundant load // elimination cotemporaneously. // -FunctionPass *createGVNPass(); +FunctionPass *createGVNPass(bool NoLoads = false); //===----------------------------------------------------------------------===// // @@ -322,7 +286,7 @@ FunctionPass *createMemCpyOptPass(); // LoopDeletion - This pass performs DCE of non-infinite loops that it // can prove are dead. // -LoopPass *createLoopDeletionPass(); +Pass *createLoopDeletionPass(); //===----------------------------------------------------------------------===// // @@ -336,6 +300,70 @@ FunctionPass *createSimplifyLibCallsPass(); // FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0); +//===----------------------------------------------------------------------===// +// +// InstructionNamer - Give any unnamed non-void instructions "tmp" names. +// +FunctionPass *createInstructionNamerPass(); +extern char &InstructionNamerID; + +//===----------------------------------------------------------------------===// +// +// Sink - Code Sinking +// +FunctionPass *createSinkingPass(); + +//===----------------------------------------------------------------------===// +// +// LowerAtomic - Lower atomic intrinsics to non-atomic form +// +Pass *createLowerAtomicPass(); + +//===----------------------------------------------------------------------===// +// +// ValuePropagation - Propagate CFG-derived value information +// +Pass *createCorrelatedValuePropagationPass(); + +//===----------------------------------------------------------------------===// +// +// ObjCARCAPElim - ObjC ARC autorelease pool elimination. +// +Pass *createObjCARCAPElimPass(); + +//===----------------------------------------------------------------------===// +// +// ObjCARCExpand - ObjC ARC preliminary simplifications. +// +Pass *createObjCARCExpandPass(); + +//===----------------------------------------------------------------------===// +// +// ObjCARCContract - Late ObjC ARC cleanups. +// +Pass *createObjCARCContractPass(); + +//===----------------------------------------------------------------------===// +// +// ObjCARCOpt - ObjC ARC optimization. +// +Pass *createObjCARCOptPass(); + +//===----------------------------------------------------------------------===// +// +// InstructionSimplifier - Remove redundant instructions. +// +FunctionPass *createInstructionSimplifierPass(); +extern char &InstructionSimplifierID; + + +//===----------------------------------------------------------------------===// +// +// LowerExpectIntriniscs - Removes llvm.expect intrinsics and creates +// "block_weights" metadata. +FunctionPass *createLowerExpectIntrinsicPass(); + + } // End llvm namespace #endif