JumpThreading.h Source File (original) (raw)

14#ifndef LLVM_TRANSFORMS_SCALAR_JUMPTHREADING_H

15#define LLVM_TRANSFORMS_SCALAR_JUMPTHREADING_H

26#include

27#include

29namespace llvm {

31class AAResults;

33class BinaryOperator;

34class BranchInst;

35class CmpInst;

38class Instruction;

39class IntrinsicInst;

40class LazyValueInfo;

41class LoadInst;

42class PHINode;

43class SelectInst;

44class SwitchInst;

45class TargetLibraryInfo;

46class TargetTransformInfo;

52namespace jumpthreading {

62}

86 std::unique_ptr DTU;

87 std::optional<BlockFrequencyInfo *> BFI;

88 std::optional<BranchProbabilityInfo *> BPI;

89 bool ChangedSinceLastAnalysisUpdate = false;

90 bool HasGuards = false;

91#ifndef LLVM_ENABLE_ABI_BREAKING_CHECKS

93#else

95#endif

97 unsigned BBDupThreshold;

98 unsigned DefaultBBDupThreshold;

100public:

102

103

107 std::unique_ptr DTU,

108 std::optional<BlockFrequencyInfo *> BFI,

109 std::optional<BranchProbabilityInfo *> BPI);

110

112

129

134 bool

141 RecursionSet, CxtI);

142 }

143

152

156

160

164

167

168private:

170 const char *Suffix);

175 bool HasProfile);

176

177 bool doesBlockHaveProfileData(BasicBlock *BB);

178

179

181

182

183

184

185 template

186 typename AnalysisT::Result *runExternalAnalysis();

187

188

189

190

192

193

194

195

197

198

199

200

202

203

204

205

207};

208

209}

210

211#endif

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx

This file defines the DenseSet and SmallDenseSet classes.

FunctionAnalysisManager FAM

const SmallVectorImpl< MachineOperand > & Cond

This file defines the SmallSet class.

This file defines the SmallVector class.

A container for analyses that lazily runs them and caches their results.

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.

This pass performs 'jump threading', which looks at blocks that have multiple predecessors and multip...

bool simplifyPartiallyRedundantLoad(LoadInst *LI)

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

bool processBranchOnXOR(BinaryOperator *BO)

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

bool processGuards(BasicBlock *BB)

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

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)

void findLoopHeaders(Function &F)

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

bool maybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB)

Merge basic block BB into its sole predecessor if possible.

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

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

PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)

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

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

bool processBranchOnPHI(PHINode *PN)

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

bool maybethreadThroughTwoBasicBlocks(BasicBlock *BB, Value *Cond)

Attempt to thread through two successive basic blocks.

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 ...

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

DomTreeUpdater * getDomTreeUpdater() const

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

bool processBlock(BasicBlock *BB)

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

bool processImpliedCondition(BasicBlock *BB)

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

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

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

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

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

bool tryToUnfoldSelect(CmpInst *CondCmp, BasicBlock *BB)

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

bool tryToUnfoldSelectInCurrBB(BasicBlock *BB)

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

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...

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.

@ BasicBlock

Various leaf nodes.

This is an optimization pass for GlobalISel generic memory operations.

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