X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FScalar.h;h=7159f86e1e16a920a486825d16e0b0a2fddd725e;hb=eb6eb153d9dc22bf006f260d3975babe075da5f2;hp=9f06d6f30da172038f3ca401fe14d3d0dfbbdef4;hpb=a7f98e2919c2e1ac39e6b82b11fd9e3a7aef00a0;p=oota-llvm.git diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 9f06d6f30da..0a37d838a93 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,17 +15,21 @@ #ifndef LLVM_TRANSFORMS_SCALAR_H #define LLVM_TRANSFORMS_SCALAR_H -#include +#include "llvm/ADT/StringRef.h" +#include namespace llvm { +class BasicBlockPass; +class Function; class FunctionPass; -class LoopPass; +class ModulePass; class Pass; class GetElementPtrInst; class PassInfo; class TerminatorInst; class TargetLowering; +class TargetMachine; //===----------------------------------------------------------------------===// // @@ -33,6 +37,13 @@ class TargetLowering; // FunctionPass *createConstantPropagationPass(); +//===----------------------------------------------------------------------===// +// +// AlignmentFromAssumptions - Use assume intrinsics to set load/store +// alignments. +// +FunctionPass *createAlignmentFromAssumptionsPass(); + //===----------------------------------------------------------------------===// // // SCCP - Sparse conditional constant propagation. @@ -71,28 +82,43 @@ FunctionPass *createDeadStoreEliminationPass(); // FunctionPass *createAggressiveDCEPass(); +//===----------------------------------------------------------------------===// +// +// BitTrackingDCE - This pass uses a bit-tracking DCE algorithm in order to +// remove computations of dead bits. +// +FunctionPass *createBitTrackingDCEPass(); + +//===----------------------------------------------------------------------===// +// +// SROA - Replace aggregates or pieces of aggregates with scalar SSA values. +// +FunctionPass *createSROAPass(bool RequiresDomTree = true); + //===----------------------------------------------------------------------===// // // ScalarReplAggregates - Break up alloca's of aggregates into multiple allocas // if possible. // -FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1); +FunctionPass *createScalarReplAggregatesPass(signed Threshold = -1, + bool UseDomTree = true, + signed StructMemberThreshold = -1, + signed ArrayElementThreshold = -1, + signed ScalarLoadThreshold = -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. +// InductiveRangeCheckElimination - Transform loops to elide range checks on +// linear functions of the induction variable. // -FunctionPass *createGCSEPass(); +Pass *createInductiveRangeCheckEliminationPass(); //===----------------------------------------------------------------------===// // // InductionVariableSimplify - Transform induction variables in a program to all // use a single canonical induction variable per loop. // -LoopPass *createIndVarSimplifyPass(); +Pass *createIndVarSimplifyPass(); //===----------------------------------------------------------------------===// // @@ -112,35 +138,70 @@ FunctionPass *createInstructionCombiningPass(); // // LICM - This pass is a loop invariant code motion and memory promotion pass. // -LoopPass *createLICMPass(); +Pass *createLICMPass(); + +//===----------------------------------------------------------------------===// +// +// LoopInterchange - This pass interchanges loops to provide a more +// cache-friendly memory access patterns. +// +Pass *createLoopInterchangePass(); //===----------------------------------------------------------------------===// // // 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. +// a loop's canonical induction variable as one of their indices. // -LoopPass *createLoopStrengthReducePass(const TargetLowering *TLI = 0); +Pass *createLoopStrengthReducePass(); + +//===----------------------------------------------------------------------===// +// +// GlobalMerge - This pass merges internal (by default) globals into structs +// to enable reuse of a base pointer by indexed addressing modes. +// It can also be configured to focus on size optimizations only. +// +Pass *createGlobalMergePass(const TargetMachine *TM, unsigned MaximalOffset, + bool OnlyOptimizeForSize = false, + bool MergeExternalByDefault = false); //===----------------------------------------------------------------------===// // // 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, int Runtime = -1); +// Create an unrolling pass for full unrolling only. +Pass *createSimpleLoopUnrollPass(); + +//===----------------------------------------------------------------------===// +// +// LoopReroll - This pass is a simple loop rerolling pass. +// +Pass *createLoopRerollPass(); //===----------------------------------------------------------------------===// // // LoopRotate - This pass is a simple loop rotating pass. // -LoopPass *createLoopRotatePass(); +Pass *createLoopRotatePass(int MaxHeaderSize = -1); +//===----------------------------------------------------------------------===// +// +// LoopIdiom - This pass recognizes and replaces idioms in loops. +// +Pass *createLoopIdiomPass(); //===----------------------------------------------------------------------===// // @@ -149,13 +210,12 @@ LoopPass *createLoopRotatePass(); // 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; //===----------------------------------------------------------------------===// // @@ -164,7 +224,7 @@ extern const PassInfo *PromoteMemoryToRegisterID; // hacking easier. // FunctionPass *createDemoteRegisterToMemoryPass(); -extern const PassInfo *DemoteRegisterToMemoryID; +extern char &DemoteRegisterToMemoryID; //===----------------------------------------------------------------------===// // @@ -177,36 +237,32 @@ FunctionPass *createReassociatePass(); //===----------------------------------------------------------------------===// // -// CorrelatedExpressionElimination - This pass eliminates correlated -// conditions, such as these: -// if (X == 0) -// if (X > 2) ; // Known false -// else -// Y = X * Z; // = 0 +// JumpThreading - Thread control through mult-pred/multi-succ blocks where some +// preds always go to some succ. Thresholds other than minus one override the +// internal BB duplication default threshold. // -FunctionPass *createCorrelatedExpressionEliminationPass(); +FunctionPass *createJumpThreadingPass(int Threshold = -1); //===----------------------------------------------------------------------===// // -// CondPropagationPass - This pass propagates information about conditional -// expressions through the program, allowing it to eliminate conditional -// branches in some cases. +// CFGSimplification - Merge basic blocks, eliminate unreachable blocks, +// simplify terminator instructions, etc... // -FunctionPass *createCondPropagationPass(); +FunctionPass *createCFGSimplificationPass( + int Threshold = -1, std::function Ftor = nullptr); //===----------------------------------------------------------------------===// // -// TailDuplication - Eliminate unconditional branches through controlled code -// duplication, creating simpler CFG structures. +// FlattenCFG - flatten CFG, reduce number of conditional branches by using +// parallel-and and parallel-or mode, etc... // -FunctionPass *createTailDuplicationPass(); +FunctionPass *createFlattenCFGPass(); //===----------------------------------------------------------------------===// // -// CFGSimplification - Merge basic blocks, eliminate unreachable blocks, -// simplify terminator instructions, etc... +// CFG Structurization - Remove irreducible control flow // -FunctionPass *createCFGSimplificationPass(); +Pass *createStructurizeCFGPass(); //===----------------------------------------------------------------------===// // @@ -220,7 +276,7 @@ FunctionPass *createCFGSimplificationPass(); // (set, immediate dominators, tree, and frontier) information. // FunctionPass *createBreakCriticalEdgesPass(); -extern const PassInfo *BreakCriticalEdgesID; +extern char &BreakCriticalEdgesID; //===----------------------------------------------------------------------===// // @@ -230,118 +286,199 @@ extern const PassInfo *BreakCriticalEdgesID; // // AU.addRequiredID(LoopSimplifyID); // -FunctionPass *createLoopSimplifyPass(); -extern const PassInfo *LoopSimplifyID; +Pass *createLoopSimplifyPass(); +extern char &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. +// TailCallElimination - This pass eliminates call instructions to the current +// function which occur immediately before return instructions. // -FunctionPass *createLowerSelectPass(bool OnlyFP = false); -extern const PassInfo *LowerSelectID; +FunctionPass *createTailCallEliminationPass(); //===----------------------------------------------------------------------===// // -// LowerAllocations - Turn malloc and free instructions into %malloc and %free -// calls. +// LowerSwitch - This pass converts SwitchInst instructions into a sequence of +// chained binary branch instructions. +// +FunctionPass *createLowerSwitchPass(); +extern char &LowerSwitchID; + +//===----------------------------------------------------------------------===// // -// AU.addRequiredID(LowerAllocationsID); +// LowerInvoke - This pass removes invoke instructions, converting them to call +// instructions. // -Pass *createLowerAllocationsPass(bool LowerMallocArgToInteger = false); -extern const PassInfo *LowerAllocationsID; +FunctionPass *createLowerInvokePass(); +extern char &LowerInvokePassID; //===----------------------------------------------------------------------===// // -// TailCallElimination - This pass eliminates call instructions to the current -// function which occur immediately before return instructions. +// LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop +// optimizations. // -FunctionPass *createTailCallEliminationPass(); +Pass *createLCSSAPass(); +extern char &LCSSAID; //===----------------------------------------------------------------------===// // -// LowerSwitch - This pass converts SwitchInst instructions into a sequence of -// chained binary branch instructions. +// EarlyCSE - This pass performs a simple and fast CSE pass over the dominator +// tree. // -FunctionPass *createLowerSwitchPass(); -extern const PassInfo *LowerSwitchID; +FunctionPass *createEarlyCSEPass(); //===----------------------------------------------------------------------===// // -// LowerPacked - This pass converts VectorType operations into low-level scalar -// operations. +// MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads +// are hoisted into the header, while stores sink into the footer. // -FunctionPass *createLowerPackedPass(); +FunctionPass *createMergedLoadStoreMotionPass(); //===----------------------------------------------------------------------===// // -// 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. +// GVN - This pass performs global value numbering and redundant load +// elimination cotemporaneously. // -FunctionPass *createLowerInvokePass(const TargetLowering *TLI = NULL); -extern const PassInfo *LowerInvokePassID; +FunctionPass *createGVNPass(bool NoLoads = false); //===----------------------------------------------------------------------===// // -// LowerGCPass - This function returns an instance of the "lowergc" pass, which -// lowers garbage collection intrinsics to normal LLVM code. +// MemCpyOpt - This pass performs optimizations related to eliminating memcpy +// calls and/or combining multiple stores into memset's. // -FunctionPass *createLowerGCPass(); +FunctionPass *createMemCpyOptPass(); //===----------------------------------------------------------------------===// // -// BlockPlacement - This pass reorders basic blocks in order to increase the -// number of fall-through conditional branches. +// LoopDeletion - This pass performs DCE of non-infinite loops that it +// can prove are dead. // -FunctionPass *createBlockPlacementPass(); +Pass *createLoopDeletionPass(); //===----------------------------------------------------------------------===// // -// LCSSA - This pass inserts phi nodes at loop boundaries to simplify other loop -// optimizations. +// ConstantHoisting - This pass prepares a function for expensive constants. // -LoopPass *createLCSSAPass(); -extern const PassInfo *LCSSAID; +FunctionPass *createConstantHoistingPass(); //===----------------------------------------------------------------------===// // -// PredicateSimplifier - This pass collapses duplicate variables into one -// canonical form, and tries to simplify expressions along the way. +// InstructionNamer - Give any unnamed non-void instructions "tmp" names. // -FunctionPass *createPredicateSimplifierPass(); +FunctionPass *createInstructionNamerPass(); +extern char &InstructionNamerID; //===----------------------------------------------------------------------===// // -// GVN-PRE - This pass performs global value numbering and partial redundancy -// elimination. +// Sink - Code Sinking // -FunctionPass *createGVNPREPass(); +FunctionPass *createSinkingPass(); //===----------------------------------------------------------------------===// // -// FastDeadStoreElimination - This pass deletes stores that are post-dominated by -// must-aliased stores and are not loaded used between the stores. +// LowerAtomic - Lower atomic intrinsics to non-atomic form +// +Pass *createLowerAtomicPass(); + +//===----------------------------------------------------------------------===// +// +// ValuePropagation - Propagate CFG-derived value information +// +Pass *createCorrelatedValuePropagationPass(); + +//===----------------------------------------------------------------------===// +// +// InstructionSimplifier - Remove redundant instructions. +// +FunctionPass *createInstructionSimplifierPass(); +extern char &InstructionSimplifierID; + +//===----------------------------------------------------------------------===// +// +// LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates +// "block_weights" metadata. +FunctionPass *createLowerExpectIntrinsicPass(); + +//===----------------------------------------------------------------------===// +// +// PartiallyInlineLibCalls - Tries to inline the fast path of library +// calls such as sqrt. +// +FunctionPass *createPartiallyInlineLibCallsPass(); + +//===----------------------------------------------------------------------===// +// +// ScalarizerPass - Converts vector operations into scalar operations +// +FunctionPass *createScalarizerPass(); + +//===----------------------------------------------------------------------===// +// +// AddDiscriminators - Add DWARF path discriminators to the IR. +FunctionPass *createAddDiscriminatorsPass(); + +//===----------------------------------------------------------------------===// +// +// SeparateConstOffsetFromGEP - Split GEPs for better CSE +// +FunctionPass * +createSeparateConstOffsetFromGEPPass(const TargetMachine *TM = nullptr, + bool LowerGEP = false); + +//===----------------------------------------------------------------------===// +// +// SpeculativeExecution - Aggressively hoist instructions to enable +// speculative execution on targets where branches are expensive. +// +FunctionPass *createSpeculativeExecutionPass(); + +//===----------------------------------------------------------------------===// +// +// LoadCombine - Combine loads into bigger loads. +// +BasicBlockPass *createLoadCombinePass(); + +//===----------------------------------------------------------------------===// +// +// StraightLineStrengthReduce - This pass strength-reduces some certain +// instruction patterns in straight-line code. +// +FunctionPass *createStraightLineStrengthReducePass(); + +//===----------------------------------------------------------------------===// +// +// PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any +// safepoint polls (method entry, backedge) that might be required. This pass +// does not generate explicit relocation sequences - that's handled by +// RewriteStatepointsForGC which can be run at an arbitrary point in the pass +// order following this pass. +// +FunctionPass *createPlaceSafepointsPass(); + +//===----------------------------------------------------------------------===// +// +// RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have +// explicit relocations to include explicit relocations. +// +ModulePass *createRewriteStatepointsForGCPass(); + +//===----------------------------------------------------------------------===// +// +// Float2Int - Demote floats to ints where possible. // -FunctionPass *createFastDeadStoreEliminationPass(); +FunctionPass *createFloat2IntPass(); //===----------------------------------------------------------------------===// // -// RedundantLoadElimination - This pass deletes loads that are dominated by -// must-aliased loads and are not stored to between the loads. +// NaryReassociate - Simplify n-ary operations by reassociation. // -FunctionPass *createRedundantLoadEliminationPass(); +FunctionPass *createNaryReassociatePass(); //===----------------------------------------------------------------------===// // -// CodeGenPrepare - This pass prepares a function for instruction selection. +// LoopDistribute - Distribute loops. // -FunctionPass *createCodeGenPreparePass(const TargetLowering *TLI = 0); +FunctionPass *createLoopDistributePass(); } // End llvm namespace