LLVM  14.0.0git
Macros | Functions | Variables
LICM.cpp File Reference
#include "llvm/Transforms/Scalar/LICM.h"
#include "llvm/ADT/SetOperations.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/AliasSetTracker.h"
#include "llvm/Analysis/BasicAliasAnalysis.h"
#include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/Analysis/CaptureTracking.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/GuardUtils.h"
#include "llvm/Analysis/LazyBlockFrequencyInfo.h"
#include "llvm/Analysis/Loads.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/LoopIterator.h"
#include "llvm/Analysis/LoopPass.h"
#include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/Analysis/MemorySSA.h"
#include "llvm/Analysis/MemorySSAUpdater.h"
#include "llvm/Analysis/MustExecute.h"
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/CFG.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugInfoMetadata.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/PatternMatch.h"
#include "llvm/IR/PredIteratorCache.h"
#include "llvm/InitializePasses.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Scalar/LoopPassManager.h"
#include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Transforms/Utils/LoopUtils.h"
#include "llvm/Transforms/Utils/SSAUpdater.h"
#include <algorithm>
#include <utility>

Go to the source code of this file.

Macros

#define DEBUG_TYPE   "licm"
 

Functions

 STATISTIC (NumCreatedBlocks, "Number of blocks created")
 
 STATISTIC (NumClonedBranches, "Number of branches cloned")
 
 STATISTIC (NumSunk, "Number of instructions sunk out of loop")
 
 STATISTIC (NumHoisted, "Number of instructions hoisted out of loop")
 
 STATISTIC (NumMovedLoads, "Number of load insts hoisted or sunk")
 
 STATISTIC (NumMovedCalls, "Number of call insts hoisted or sunk")
 
 STATISTIC (NumPromoted, "Number of memory locations promoted to registers")
 
static bool inSubLoop (BasicBlock *BB, Loop *CurLoop, LoopInfo *LI)
 Little predicate that returns true if the specified basic block is in a subloop of the current one, not the current one itself. More...
 
static bool isNotUsedOrFreeInLoop (const Instruction &I, const Loop *CurLoop, const LoopSafetyInfo *SafetyInfo, TargetTransformInfo *TTI, bool &FreeInLoop, bool LoopNestMode)
 Return true if the only users of this instruction are outside of the loop. More...
 
static void hoist (Instruction &I, const DominatorTree *DT, const Loop *CurLoop, BasicBlock *Dest, ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU, ScalarEvolution *SE, OptimizationRemarkEmitter *ORE)
 When an instruction is found to only use loop invariant operands that is safe to hoist, this instruction is called to do the dirty work. More...
 
static bool sink (Instruction &I, LoopInfo *LI, DominatorTree *DT, BlockFrequencyInfo *BFI, const Loop *CurLoop, ICFLoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU, OptimizationRemarkEmitter *ORE)
 When an instruction is found to only be used outside of the loop, this function moves it to the exit blocks and patches up SSA form as needed. More...
 
static bool isSafeToExecuteUnconditionally (Instruction &Inst, const DominatorTree *DT, const TargetLibraryInfo *TLI, const Loop *CurLoop, const LoopSafetyInfo *SafetyInfo, OptimizationRemarkEmitter *ORE, const Instruction *CtxI)
 Only sink or hoist an instruction if it is not a trapping instruction, or if the instruction is known not to trap when moved to the preheader. More...
 
static bool pointerInvalidatedByLoop (MemoryLocation MemLoc, AliasSetTracker *CurAST, Loop *CurLoop, AAResults *AA)
 
static bool pointerInvalidatedByLoopWithMSSA (MemorySSA *MSSA, MemoryUse *MU, Loop *CurLoop, Instruction &I, SinkAndHoistLICMFlags &Flags)
 
static bool pointerInvalidatedByBlockWithMSSA (BasicBlock &BB, MemorySSA &MSSA, MemoryUse &MU)
 
static InstructioncloneInstructionInExitBlock (Instruction &I, BasicBlock &ExitBlock, PHINode &PN, const LoopInfo *LI, const LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU)
 
static void eraseInstruction (Instruction &I, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater *MSSAU)
 
static void moveInstructionBefore (Instruction &I, Instruction &Dest, ICFLoopSafetyInfo &SafetyInfo, MemorySSAUpdater *MSSAU, ScalarEvolution *SE)
 
static void foreachMemoryAccess (MemorySSA *MSSA, Loop *L, function_ref< void(Instruction *)> Fn)
 
static SmallVector< SmallSetVector< Value *, 8 >, 0 > collectPromotionCandidates (MemorySSA *MSSA, AliasAnalysis *AA, Loop *L)
 
 INITIALIZE_PASS_BEGIN (LegacyLICMPass, "licm", "Loop Invariant Code Motion", false, false) INITIALIZE_PASS_END(LegacyLICMPass
 
static bool worthSinkOrHoistInst (Instruction &I, BasicBlock *DstBlock, OptimizationRemarkEmitter *ORE, BlockFrequencyInfo *BFI)
 
static bool isLoadInvariantInLoop (LoadInst *LI, DominatorTree *DT, Loop *CurLoop)
 
static bool isTriviallyReplaceablePHI (const PHINode &PN, const Instruction &I)
 Returns true if a PHINode is a trivially replaceable with an Instruction. More...
 
static bool isFreeInLoop (const Instruction &I, const Loop *CurLoop, const TargetTransformInfo *TTI)
 Return true if the instruction is free in the loop. More...
 
static InstructionsinkThroughTriviallyReplaceablePHI (PHINode *TPN, Instruction *I, LoopInfo *LI, SmallDenseMap< BasicBlock *, Instruction *, 32 > &SunkCopies, const LoopSafetyInfo *SafetyInfo, const Loop *CurLoop, MemorySSAUpdater *MSSAU)
 
static bool canSplitPredecessors (PHINode *PN, LoopSafetyInfo *SafetyInfo)
 
static void splitPredecessorsOfLoopExit (PHINode *PN, DominatorTree *DT, LoopInfo *LI, const Loop *CurLoop, LoopSafetyInfo *SafetyInfo, MemorySSAUpdater *MSSAU)
 

Variables

static cl::opt< bool > DisablePromotion ("disable-licm-promotion", cl::Hidden, cl::init(false), cl::desc("Disable memory promotion in LICM pass"))
 Memory promotion is enabled by default. More...
 
static cl::opt< bool > ControlFlowHoisting ("licm-control-flow-hoisting", cl::Hidden, cl::init(false), cl::desc("Enable control flow (and PHI) hoisting in LICM"))
 
static cl::opt< unsigned > HoistSinkColdnessThreshold ("licm-coldness-threshold", cl::Hidden, cl::init(4), cl::desc("Relative coldness Threshold of hoisting/sinking destination " "block for LICM to be considered beneficial"))
 
static cl::opt< uint32_tMaxNumUsesTraversed ("licm-max-num-uses-traversed", cl::Hidden, cl::init(8), cl::desc("Max num uses visited for identifying load " "invariance in loop using invariant start (default = 8)"))
 
 licm
 
Loop Invariant Code Motion
 
Loop Invariant Code false
 

Macro Definition Documentation

◆ DEBUG_TYPE

#define DEBUG_TYPE   "licm"

Definition at line 91 of file LICM.cpp.

Function Documentation

◆ canSplitPredecessors()

static bool canSplitPredecessors ( PHINode PN,
LoopSafetyInfo SafetyInfo 
)
static

◆ cloneInstructionInExitBlock()

static Instruction * cloneInstructionInExitBlock ( Instruction I,
BasicBlock ExitBlock,
PHINode PN,
const LoopInfo LI,
const LoopSafetyInfo SafetyInfo,
MemorySSAUpdater MSSAU 
)
static

◆ collectPromotionCandidates()

static SmallVector< SmallSetVector< Value *, 8 >, 0 > collectPromotionCandidates ( MemorySSA MSSA,
AliasAnalysis AA,
Loop L 
)
static

◆ eraseInstruction()

static void eraseInstruction ( Instruction I,
ICFLoopSafetyInfo SafetyInfo,
MemorySSAUpdater MSSAU 
)
static

◆ foreachMemoryAccess()

static void foreachMemoryAccess ( MemorySSA MSSA,
Loop L,
function_ref< void(Instruction *)>  Fn 
)
static

◆ hoist()

static void hoist ( Instruction I,
const DominatorTree DT,
const Loop CurLoop,
BasicBlock Dest,
ICFLoopSafetyInfo SafetyInfo,
MemorySSAUpdater MSSAU,
ScalarEvolution SE,
OptimizationRemarkEmitter ORE 
)
static

When an instruction is found to only use loop invariant operands that is safe to hoist, this instruction is called to do the dirty work.

Definition at line 1777 of file LICM.cpp.

References llvm::dbgs(), DEBUG_TYPE, llvm::OptimizationRemarkEmitter::emit(), llvm::BasicBlock::getFirstNonPHI(), llvm::Value::getNameOrAsOperand(), llvm::BasicBlock::getTerminator(), I, llvm::ICFLoopSafetyInfo::isGuaranteedToExecute(), LLVM_DEBUG, and moveInstructionBefore().

Referenced by llvm::hoistRegion().

◆ INITIALIZE_PASS_BEGIN()

INITIALIZE_PASS_BEGIN ( LegacyLICMPass  ,
"licm"  ,
"Loop Invariant Code Motion ,
false  ,
false   
)

◆ inSubLoop()

static bool inSubLoop ( BasicBlock BB,
Loop CurLoop,
LoopInfo LI 
)
static

Little predicate that returns true if the specified basic block is in a subloop of the current one, not the current one itself.

Definition at line 2389 of file LICM.cpp.

References assert(), BB, llvm::LoopBase< BlockT, LoopT >::contains(), and llvm::LoopInfoBase< BlockT, LoopT >::getLoopFor().

Referenced by llvm::hoistRegion(), and llvm::sinkRegion().

◆ isFreeInLoop()

static bool isFreeInLoop ( const Instruction I,
const Loop CurLoop,
const TargetTransformInfo TTI 
)
static

Return true if the instruction is free in the loop.

Definition at line 1385 of file LICM.cpp.

References BB, llvm::LoopBase< BlockT, LoopT >::contains(), GEP, llvm::Instruction::getParent(), llvm::TargetTransformInfo::getUserCost(), and I.

Referenced by isNotUsedOrFreeInLoop().

◆ isLoadInvariantInLoop()

static bool isLoadInvariantInLoop ( LoadInst LI,
DominatorTree DT,
Loop CurLoop 
)
static

◆ isNotUsedOrFreeInLoop()

static bool isNotUsedOrFreeInLoop ( const Instruction I,
const Loop CurLoop,
const LoopSafetyInfo SafetyInfo,
TargetTransformInfo TTI,
bool &  FreeInLoop,
bool  LoopNestMode 
)
static

Return true if the only users of this instruction are outside of the loop.

If this is true, we can sink the instruction to the exit blocks of the loop.

We also return true if the instruction could be folded away in lowering. (e.g., a GEP can be folded into a load as an addressing mode in the loop).

Definition at line 1415 of file LICM.cpp.

References BB, llvm::LoopBase< BlockT, LoopT >::contains(), llvm::LoopSafetyInfo::getBlockColors(), llvm::User::getNumOperands(), llvm::Instruction::getParent(), llvm::Value::hasOneUser(), I, isFreeInLoop(), and llvm::Instruction::user_back().

Referenced by llvm::sinkRegion().

◆ isSafeToExecuteUnconditionally()

static bool isSafeToExecuteUnconditionally ( Instruction Inst,
const DominatorTree DT,
const TargetLibraryInfo TLI,
const Loop CurLoop,
const LoopSafetyInfo SafetyInfo,
OptimizationRemarkEmitter ORE,
const Instruction CtxI 
)
static

Only sink or hoist an instruction if it is not a trapping instruction, or if the instruction is known not to trap when moved to the preheader.

or if it is a trapping instruction and is guaranteed to execute.

Definition at line 1822 of file LICM.cpp.

References DEBUG_TYPE, llvm::OptimizationRemarkEmitter::emit(), llvm::LoopSafetyInfo::isGuaranteedToExecute(), llvm::Loop::isLoopInvariant(), and llvm::isSafeToSpeculativelyExecute().

Referenced by llvm::hoistRegion(), and llvm::promoteLoopAccessesToScalars().

◆ isTriviallyReplaceablePHI()

static bool isTriviallyReplaceablePHI ( const PHINode PN,
const Instruction I 
)
static

Returns true if a PHINode is a trivially replaceable with an Instruction.

This is true when all incoming values are that instruction. This pattern occurs most often with LCSSA PHI nodes.

Definition at line 1376 of file LICM.cpp.

References I, and llvm::PHINode::incoming_values().

Referenced by sink(), and sinkThroughTriviallyReplaceablePHI().

◆ moveInstructionBefore()

static void moveInstructionBefore ( Instruction I,
Instruction Dest,
ICFLoopSafetyInfo SafetyInfo,
MemorySSAUpdater MSSAU,
ScalarEvolution SE 
)
static

◆ pointerInvalidatedByBlockWithMSSA()

bool pointerInvalidatedByBlockWithMSSA ( BasicBlock BB,
MemorySSA MSSA,
MemoryUse MU 
)
static

◆ pointerInvalidatedByLoop()

static bool pointerInvalidatedByLoop ( MemoryLocation  MemLoc,
AliasSetTracker CurAST,
Loop CurLoop,
AAResults AA 
)
static

◆ pointerInvalidatedByLoopWithMSSA()

bool pointerInvalidatedByLoopWithMSSA ( MemorySSA MSSA,
MemoryUse MU,
Loop CurLoop,
Instruction I,
SinkAndHoistLICMFlags Flags 
)
static

◆ sink()

static bool sink ( Instruction I,
LoopInfo LI,
DominatorTree DT,
BlockFrequencyInfo BFI,
const Loop CurLoop,
ICFLoopSafetyInfo SafetyInfo,
MemorySSAUpdater MSSAU,
OptimizationRemarkEmitter ORE 
)
static

◆ sinkThroughTriviallyReplaceablePHI()

static Instruction* sinkThroughTriviallyReplaceablePHI ( PHINode TPN,
Instruction I,
LoopInfo LI,
SmallDenseMap< BasicBlock *, Instruction *, 32 > &  SunkCopies,
const LoopSafetyInfo SafetyInfo,
const Loop CurLoop,
MemorySSAUpdater MSSAU 
)
static

◆ splitPredecessorsOfLoopExit()

static void splitPredecessorsOfLoopExit ( PHINode PN,
DominatorTree DT,
LoopInfo LI,
const Loop CurLoop,
LoopSafetyInfo SafetyInfo,
MemorySSAUpdater MSSAU 
)
static

◆ STATISTIC() [1/7]

STATISTIC ( NumClonedBranches  ,
"Number of branches cloned"   
)

◆ STATISTIC() [2/7]

STATISTIC ( NumCreatedBlocks  ,
"Number of blocks created"   
)

◆ STATISTIC() [3/7]

STATISTIC ( NumHoisted  ,
"Number of instructions hoisted out of loop  
)

◆ STATISTIC() [4/7]

STATISTIC ( NumMovedCalls  ,
"Number of call insts hoisted or sunk"   
)

◆ STATISTIC() [5/7]

STATISTIC ( NumMovedLoads  ,
"Number of load insts hoisted or sunk"   
)

◆ STATISTIC() [6/7]

STATISTIC ( NumPromoted  ,
"Number of memory locations promoted to registers  
)

◆ STATISTIC() [7/7]

STATISTIC ( NumSunk  ,
"Number of instructions sunk out of loop  
)

◆ worthSinkOrHoistInst()

static bool worthSinkOrHoistInst ( Instruction I,
BasicBlock DstBlock,
OptimizationRemarkEmitter ORE,
BlockFrequencyInfo BFI 
)
static

Variable Documentation

◆ ControlFlowHoisting

cl::opt<bool> ControlFlowHoisting("licm-control-flow-hoisting", cl::Hidden, cl::init(false), cl::desc("Enable control flow (and PHI) hoisting in LICM"))
static

Referenced by llvm::hoistRegion().

◆ DisablePromotion

cl::opt<bool> DisablePromotion("disable-licm-promotion", cl::Hidden, cl::init(false), cl::desc("Disable memory promotion in LICM pass"))
static

Memory promotion is enabled by default.

◆ false

Loop Invariant Code false

Definition at line 324 of file LICM.cpp.

◆ HoistSinkColdnessThreshold

cl::opt<unsigned> HoistSinkColdnessThreshold("licm-coldness-threshold", cl::Hidden, cl::init(4), cl::desc("Relative coldness Threshold of hoisting/sinking destination " "block for LICM to be considered beneficial"))
static

Referenced by worthSinkOrHoistInst().

◆ licm

licm

Definition at line 324 of file LICM.cpp.

◆ MaxNumUsesTraversed

cl::opt<uint32_t> MaxNumUsesTraversed("licm-max-num-uses-traversed", cl::Hidden, cl::init(8), cl::desc("Max num uses visited for identifying load " "invariance in loop using invariant start (default = 8)"))
static

Referenced by isLoadInvariantInLoop().

◆ Motion

Loop Invariant Code Motion

Definition at line 324 of file LICM.cpp.