JumpThreading.h Source File (original) (raw)

14#ifndef LLVM_TRANSFORMS_SCALAR_JUMPTHREADING_H

15#define LLVM_TRANSFORMS_SCALAR_JUMPTHREADING_H

27#include

29namespace llvm {

86 std::unique_ptr DTU;

89 bool ChangedSinceLastAnalysisUpdate = false;

90 bool HasGuards = false;

91#ifndef LLVM_ENABLE_ABI_BREAKING_CHECKS

93#else

95#endif

100

101 unsigned BBDupThreshold;

102 unsigned DefaultBBDupThreshold;

103

104public:

106

107

111 std::unique_ptr DTU,

113

115

134

139 bool

146 RecursionSet, CxtI);

147 }

148

161

165

169

173

177

178private:

180 const char *Suffix);

185 bool HasProfile);

186

187 bool doesBlockHaveProfileData(BasicBlock *BB);

188

189

191

192

193

194

195 template

196 typename AnalysisT::Result *runExternalAnalysis();

197

198

199

200

202

203

204

205

207

208

209

210

212

213

214

215

217

218

222};

223

224}

225

226#endif

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

This file defines the DenseSet and SmallDenseSet classes.

const SmallVectorImpl< MachineOperand > & Cond

This file defines the SmallSet class.

This file defines the SmallVector class.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

LLVM Basic Block Representation.

InstListType::iterator iterator

Instruction iterators...

BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...

Conditional or Unconditional Branch instruction.

Analysis providing branch probability information.

This class is the base class for the comparison instructions.

This is an important base class in LLVM.

A parsed version of the target data layout string in and methods for querying it.

A wrapper class for inspecting calls to intrinsic functions.

LLVM_ABI bool simplifyPartiallyRedundantLoad(LoadInst *LI)

simplifyPartiallyRedundantLoad - If LoadI is an obviously partially redundant load instruction,...

LLVM_ABI bool processBranchOnXOR(BinaryOperator *BO)

processBranchOnXOR - We have an otherwise unthreadable conditional branch on a xor instruction in the...

LLVM_ABI bool processGuards(BasicBlock *BB)

Try to propagate a guard from the current BB into one of its predecessors in case if another branch o...

LLVM_ABI void updateSSA(BasicBlock *BB, BasicBlock *NewBB, ValueToValueMapTy &ValueMapping)

Update the SSA form.

bool computeValueKnownInPredecessors(Value *V, BasicBlock *BB, jumpthreading::PredValueInfo &Result, jumpthreading::ConstantPreference Preference, Instruction *CxtI=nullptr)

Definition JumpThreading.h:140

LLVM_ABI void findLoopHeaders(Function &F)

findLoopHeaders - We do not want jump threading to turn proper loop structures into irreducible loops...

LLVM_ABI bool maybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB)

Merge basic block BB into its sole predecessor if possible.

LLVM_ABI JumpThreadingPass(int T=-1)

LLVM_ABI void cloneInstructions(ValueToValueMapTy &ValueMapping, BasicBlock::iterator BI, BasicBlock::iterator BE, BasicBlock *NewBB, BasicBlock *PredBB)

Clone instructions in range [BI, BE) to NewBB.

LLVM_ABI PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)

LLVM_ABI Constant * evaluateOnPredecessorEdge(BasicBlock *BB, BasicBlock *PredPredBB, Value *cond, const DataLayout &DL)

LLVM_ABI bool processBranchOnPHI(PHINode *PN)

processBranchOnPHI - We have an otherwise unthreadable conditional branch on a PHI node (or freeze PH...

LLVM_ABI bool maybethreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond)

Attempt to thread through two successive basic blocks.

LLVM_ABI bool computeValueKnownInPredecessorsImpl(Value *V, BasicBlock *BB, jumpthreading::PredValueInfo &Result, jumpthreading::ConstantPreference Preference, SmallPtrSet< Value *, 4 > &RecursionSet, Instruction *CxtI=nullptr)

computeValueKnownInPredecessors - Given a basic block BB and a value V, see if we can infer that the ...

LLVM_ABI void unfoldSelectInstr(BasicBlock *Pred, BasicBlock *BB, SelectInst *SI, PHINode *SIUse, unsigned Idx)

DomTreeUpdater * getDomTreeUpdater() const

Definition JumpThreading.h:116

LLVM_ABI bool runImpl(Function &F, FunctionAnalysisManager *FAM, TargetLibraryInfo *TLI, TargetTransformInfo *TTI, LazyValueInfo *LVI, AAResults *AA, std::unique_ptr< DomTreeUpdater > DTU, BlockFrequencyInfo *BFI, BranchProbabilityInfo *BPI)

LLVM_ABI bool processThreadableEdges(Value *Cond, BasicBlock *BB, jumpthreading::ConstantPreference Preference, Instruction *CxtI=nullptr)

LLVM_ABI bool processBlock(BasicBlock *BB)

processBlock - If there are any predecessors whose control can be threaded through to a successor,...

LLVM_ABI bool processImpliedCondition(BasicBlock *BB)

LLVM_ABI bool duplicateCondBranchOnPHIIntoPred(BasicBlock *BB, const SmallVectorImpl< BasicBlock * > &PredBBs)

duplicateCondBranchOnPHIIntoPred - PredBB contains an unconditional branch to BB which contains an i1...

LLVM_ABI void threadThroughTwoBasicBlocks(BasicBlock *PredPredBB, BasicBlock *PredBB, BasicBlock *BB, BasicBlock *SuccBB)

LLVM_ABI bool tryThreadEdge(BasicBlock *BB, const SmallVectorImpl< BasicBlock * > &PredBBs, BasicBlock *SuccBB)

tryThreadEdge - Thread an edge if it's safe and profitable to do so.

LLVM_ABI bool tryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB)

tryToUnfoldSelect - Look for blocks of the form bb1: a = select br bb2

LLVM_ABI bool tryToUnfoldSelectInCurrBB(BasicBlock *BB)

tryToUnfoldSelectInCurrBB - Look for PHI/Select or PHI/CMP/Select in the same BB in the form bb: p = ...

LLVM_ABI void threadEdge(BasicBlock *BB, const SmallVectorImpl< BasicBlock * > &PredBBs, BasicBlock *SuccBB)

threadEdge - We have decided that it is safe and profitable to factor the blocks in PredBBs to one pr...

LLVM_ABI bool threadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI)

Try to propagate the guard from BB which is the lower block of a diamond to one of its branches,...

This pass computes, caches, and vends lazy value constraint information.

An instruction for reading from memory.

A set of analyses that are preserved following a run of a transformation pass.

This class represents the LLVM 'select' instruction.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Provides information about what library functions are available for the current target.

This pass provides access to the codegen interfaces that are needed for IR-level transformations.

LLVM Value Representation.

A private "module" namespace for types and utilities used by JumpThreading.

Definition JumpThreading.h:52

SmallVector< std::pair< Constant *, BasicBlock * >, 8 > PredValueInfoTy

Definition JumpThreading.h:56

ConstantPreference

Definition JumpThreading.h:60

@ WantBlockAddress

Definition JumpThreading.h:60

@ WantInteger

Definition JumpThreading.h:60

SmallVectorImpl< std::pair< Constant *, BasicBlock * > > PredValueInfo

Definition JumpThreading.h:55

This is an optimization pass for GlobalISel generic memory operations.

ValueMap< const Value *, WeakTrackingVH > ValueToValueMapTy

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

A CRTP mix-in to automatically provide informational APIs needed for passes.