|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
include/llvm/IR/PassManagerInternal.h 137 template <typename T> struct Checker : CheckerBase, T {};
Declarations
include/llvm/Analysis/AliasAnalysis.h 61 class DominatorTree;
include/llvm/Analysis/BasicAliasAnalysis.h 38 class DominatorTree;
include/llvm/Analysis/CFG.h 23 class DominatorTree;
include/llvm/Analysis/CaptureTracking.h 22 class DominatorTree;
include/llvm/Analysis/DemandedBits.h 34 class DominatorTree;
include/llvm/Analysis/IVUsers.h 25 class DominatorTree;
include/llvm/Analysis/InstructionSimplify.h 45 class DominatorTree;
include/llvm/Analysis/LazyValueInfo.h 25 class DominatorTree;
include/llvm/Analysis/LoopInfo.h 57 class DominatorTree;
include/llvm/Analysis/MemoryDependenceAnalysis.h 39 class DominatorTree;
include/llvm/Analysis/MustExecute.h 37 class DominatorTree;
include/llvm/Analysis/PHITransAddr.h 21 class DominatorTree;
include/llvm/Analysis/RegionInfo.h 62 class DominatorTree;
include/llvm/Analysis/ScalarEvolution.h 60 class DominatorTree;
include/llvm/Analysis/SyncDependenceAnalysis.h 28 class DominatorTree;
include/llvm/Analysis/TypeMetadataUtils.h 22 class DominatorTree;
include/llvm/Analysis/ValueTracking.h 33 class DominatorTree;
include/llvm/CodeGen/StackProtector.h 29 class DominatorTree;
include/llvm/Transforms/IPO/HotColdSplitting.h 25 class DominatorTree;
include/llvm/Transforms/Scalar/ConstantHoisting.h 56 class DominatorTree;
include/llvm/Transforms/Scalar/MemCpyOptimizer.h 28 class DominatorTree;
include/llvm/Transforms/Scalar/NaryReassociate.h 91 class DominatorTree;
include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h 23 class DominatorTree;
include/llvm/Transforms/Scalar/SROA.h 27 class DominatorTree;
include/llvm/Transforms/Utils/BasicBlockUtils.h 30 class DominatorTree;
include/llvm/Transforms/Utils/Cloning.h 40 class DominatorTree;
include/llvm/Transforms/Utils/CodeExtractor.h 32 class DominatorTree;
include/llvm/Transforms/Utils/LoopRotationUtils.h 19 class DominatorTree;
include/llvm/Transforms/Utils/PredicateInfo.h 88 class DominatorTree;
include/llvm/Transforms/Utils/PromoteMemToReg.h 21 class DominatorTree;
include/llvm/Transforms/Utils/SSAUpdaterBulk.h 29 class DominatorTree;
include/llvm/Transforms/Utils/SimplifyIndVar.h 23 class DominatorTree;
include/llvm/Transforms/Utils/UnrollLoop.h 29 class DominatorTree;
include/llvm/Transforms/Vectorize/LoopVectorize.h 68 class DominatorTree;
include/llvm/Transforms/Vectorize/SLPVectorizer.h 35 class DominatorTree;
lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h 49 class DominatorTree;
lib/Transforms/InstCombine/InstCombineInternal.h 57 class DominatorTree;
lib/Transforms/Vectorize/VPlan.h 53 class DominatorTree;
tools/polly/include/polly/CodeGen/Utils.h 21 class DominatorTree;
tools/polly/include/polly/Support/ScopHelper.h 28 class DominatorTree;
References
include/llvm/ADT/Optional.h 87 template <class... Args> void emplace(Args &&... args) {
237 template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
include/llvm/Analysis/AliasAnalysis.h 651 const MemoryLocation &MemLoc, DominatorTree *DT,
656 LocationSize Size, DominatorTree *DT,
include/llvm/Analysis/BasicAliasAnalysis.h 61 DominatorTree *DT;
68 DominatorTree *DT = nullptr, LoopInfo *LI = nullptr,
170 DominatorTree *DT, bool &NSW, bool &NUW);
173 const DataLayout &DL, AssumptionCache *AC, DominatorTree *DT);
191 DominatorTree *DT);
include/llvm/Analysis/CFG.h 70 const DominatorTree *DT = nullptr, const LoopInfo *LI = nullptr);
79 const DominatorTree *DT = nullptr,
91 const DominatorTree *DT = nullptr,
106 const DominatorTree *DT = nullptr, const LoopInfo *LI = nullptr);
include/llvm/Analysis/CaptureTracking.h 62 const DominatorTree *DT, bool IncludeI = false,
include/llvm/Analysis/DemandedBits.h 42 DemandedBits(Function &F, AssumptionCache &AC, DominatorTree &DT) :
73 DominatorTree &DT;
include/llvm/Analysis/DivergenceAnalysis.h 47 const DominatorTree &DT, const LoopInfo &LI,
153 const DominatorTree &DT;
185 GPUDivergenceAnalysis(Function &F, const DominatorTree &DT,
include/llvm/Analysis/DomTreeUpdater.h 31 DomTreeUpdater(DominatorTree &DT_, UpdateStrategy Strategy_)
33 DomTreeUpdater(DominatorTree *DT_, UpdateStrategy Strategy_)
39 DomTreeUpdater(DominatorTree &DT_, PostDominatorTree &PDT_,
42 DomTreeUpdater(DominatorTree *DT_, PostDominatorTree *PDT_,
121 void applyUpdates(ArrayRef<DominatorTree::UpdateType> Updates);
144 void applyUpdatesPermissive(ArrayRef<DominatorTree::UpdateType> Updates);
226 DominatorTree &getDomTree();
260 SmallVector<DominatorTree::UpdateType, 16> PendUpdates;
263 DominatorTree *DT = nullptr;
302 bool isUpdateValid(DominatorTree::UpdateType Update) const;
305 bool isSelfDominance(DominatorTree::UpdateType Update) const;
include/llvm/Analysis/IVDescriptors.h 175 DominatorTree *DT = nullptr);
185 DominatorTree *DT = nullptr);
197 DominatorTree *DT);
include/llvm/Analysis/IVUsers.h 98 DominatorTree *DT;
110 IVUsers(Loop *L, AssumptionCache *AC, LoopInfo *LI, DominatorTree *DT,
include/llvm/Analysis/InstructionPrecedenceTracking.h 52 InstructionPrecedenceTracking(DominatorTree *DT)
99 ImplicitControlFlowTracking(DominatorTree *DT)
124 MemoryWriteTracking(DominatorTree *DT) : InstructionPrecedenceTracking(DT) {}
include/llvm/Analysis/InstructionSimplify.h 93 const DominatorTree *DT = nullptr;
106 const DominatorTree *DT = nullptr,
278 const DominatorTree *DT = nullptr, AssumptionCache *AC = nullptr,
289 const DominatorTree *DT = nullptr,
include/llvm/Analysis/LazyValueInfo.h 36 DominatorTree *DT = nullptr;
44 DominatorTree *DT_)
113 void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
include/llvm/Analysis/Loads.h 33 const DominatorTree *DT = nullptr);
43 const DominatorTree *DT = nullptr);
52 const DominatorTree *DT = nullptr);
65 const DominatorTree *DT = nullptr);
76 DominatorTree &DT);
89 const DominatorTree *DT = nullptr);
include/llvm/Analysis/LoopAccessAnalysis.h 519 AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI);
543 DominatorTree *DT);
611 const TargetLibraryInfo *TLI, DominatorTree *DT);
756 DominatorTree *DT;
include/llvm/Analysis/LoopAnalysisManager.h 56 DominatorTree &DT;
include/llvm/Analysis/LoopInfo.h 764 bool isLCSSAForm(DominatorTree &DT) const;
767 bool isRecursivelyLCSSAForm(DominatorTree &DT, const LoopInfo &LI) const;
include/llvm/Analysis/MemoryDependenceAnalysis.h 361 DominatorTree &DT;
369 const TargetLibraryInfo &TLI, DominatorTree &DT,
include/llvm/Analysis/MemorySSA.h 705 MemorySSA(Function &, AliasAnalysis *, DominatorTree *);
872 DominatorTree *DT;
include/llvm/Analysis/MemorySSAUpdater.h 131 DominatorTree &DT);
134 ArrayRef<std::unique_ptr<ValueToValueMapTy>> VMaps, DominatorTree &DT);
137 void applyUpdates(ArrayRef<CFGUpdate> Updates, DominatorTree &DT);
139 void applyInsertUpdates(ArrayRef<CFGUpdate> Updates, DominatorTree &DT);
303 DominatorTree &DT);
304 void applyInsertUpdates(ArrayRef<CFGUpdate>, DominatorTree &DT,
include/llvm/Analysis/MustExecute.h 80 const DominatorTree *DT) const;
92 const DominatorTree *DT,
117 const DominatorTree *DT,
146 const DominatorTree *DT,
169 ICFLoopSafetyInfo(DominatorTree *DT) : LoopSafetyInfo(), ICF(DT), MW(DT) {};
include/llvm/Analysis/OrderedInstructions.h 35 DominatorTree *DT;
44 OrderedInstructions(DominatorTree *DT) : DT(DT) {}
include/llvm/Analysis/PHITransAddr.h 82 const DominatorTree *DT, bool MustDominate);
92 const DominatorTree &DT,
104 const DominatorTree *DT);
112 BasicBlock *PredBB, const DominatorTree &DT,
include/llvm/Analysis/RegionInfo.h 92 using DomTreeT = DominatorTree;
895 Region(BasicBlock *Entry, BasicBlock *Exit, RegionInfo *RI, DominatorTree *DT,
929 void recalculate(Function &F, DominatorTree *DT, PostDominatorTree *PDT,
include/llvm/Analysis/ScalarEvolution.h 475 DominatorTree &DT, LoopInfo &LI);
1122 DominatorTree &DT;
include/llvm/Analysis/ScalarEvolutionExpander.h 201 unsigned replaceCongruentIVs(Loop *L, const DominatorTree *DT,
408 void hoistBeforePos(DominatorTree *DT, Instruction *InstToHoist,
include/llvm/Analysis/SyncDependenceAnalysis.h 47 SyncDependenceAnalysis(const DominatorTree &DT, const PostDominatorTree &PDT,
74 const DominatorTree &DT;
include/llvm/Analysis/TargetTransformInfo.h 101 DominatorTree &DT, bool ForceNestedLoop = false,
566 DominatorTree *DT, AssumptionCache *AC,
1209 LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC,
1490 LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC,
include/llvm/Analysis/TargetTransformInfoImpl.h 237 DominatorTree *DT, AssumptionCache *AC,
include/llvm/Analysis/TypeMetadataUtils.h 44 DominatorTree &DT);
52 const CallInst *CI, DominatorTree &DT);
include/llvm/Analysis/ValueTracking.h 58 const DominatorTree *DT = nullptr,
66 const DominatorTree *DT = nullptr,
81 const DominatorTree *DT = nullptr,
93 const DominatorTree *DT = nullptr,
107 const DominatorTree *DT = nullptr,
121 const DominatorTree *DT = nullptr,
129 const DominatorTree *DT = nullptr,
137 const DominatorTree *DT = nullptr,
145 const DominatorTree *DT = nullptr,
161 const DominatorTree *DT = nullptr,
174 const DominatorTree *DT = nullptr,
419 const DominatorTree *DT = nullptr);
439 const DominatorTree *DT = nullptr);
457 const DominatorTree *DT,
463 const DominatorTree *DT,
470 const DominatorTree *DT,
476 const DominatorTree *DT = nullptr);
482 const DominatorTree *DT = nullptr);
487 const DominatorTree *DT);
492 const DominatorTree *DT);
498 const DominatorTree &DT);
include/llvm/Analysis/VectorUtils.h 528 DominatorTree *DT, LoopInfo *LI,
593 DominatorTree *DT;
include/llvm/CodeGen/StackProtector.h 53 DominatorTree *DT;
include/llvm/IR/Dominators.h 150 explicit DominatorTree(DominatorTree &DT, DomTreeBuilder::BBUpdates U) {
218 static NodeRef getEntryNode(DominatorTree *DT) { return DT->getRootNode(); }
220 static nodes_iterator nodes_begin(DominatorTree *N) {
224 static nodes_iterator nodes_end(DominatorTree *N) {
236 using Result = DominatorTree;
239 DominatorTree run(Function &F, FunctionAnalysisManager &);
260 DominatorTree DT;
269 DominatorTree &getDomTree() { return DT; }
270 const DominatorTree &getDomTree() const { return DT; }
include/llvm/IR/PassManagerInternal.h 137 template <typename T> struct Checker : CheckerBase, T {};
147 enum { Value = sizeof(check<ResultT>(rank<2>())) == sizeof(EnabledType) };
208 explicit AnalysisResultModel(ResultT Result) : Result(std::move(Result)) {}
231 ResultT Result;
include/llvm/Transforms/IPO/HotColdSplitting.h 49 DominatorTree &DT, BlockFrequencyInfo *BFI,
include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h 33 DominatorTree *DT_);
36 DominatorTree *DT = nullptr;
include/llvm/Transforms/Scalar/ConstantHoisting.h 129 bool runImpl(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
150 DominatorTree *DT;
include/llvm/Transforms/Scalar/Float2Int.h 30 bool runImpl(Function &F, const DominatorTree &DT);
33 void findRoots(Function &F, const DominatorTree &DT,
include/llvm/Transforms/Scalar/GVN.h 82 DominatorTree &getDominatorTree() const { return *DT; }
112 DominatorTree *DT;
148 void setDomTree(DominatorTree *D) { DT = D; }
158 DominatorTree *DT;
197 bool runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
include/llvm/Transforms/Scalar/MemCpyOptimizer.h 44 std::function<DominatorTree &()> LookupDomTree;
56 std::function<DominatorTree &()> LookupDomTree_);
include/llvm/Transforms/Scalar/NaryReassociate.h 107 bool runImpl(Function &F, AssumptionCache *AC_, DominatorTree *DT_,
169 DominatorTree *DT;
include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h 32 bool runOnFunction(Function &F, DominatorTree &, TargetTransformInfo &,
include/llvm/Transforms/Scalar/SCCP.h 44 DominatorTree *DT;
include/llvm/Transforms/Scalar/SROA.h 66 DominatorTree *DT = nullptr;
122 PreservedAnalyses runImpl(Function &F, DominatorTree &RunDT,
include/llvm/Transforms/Utils/BasicBlockUtils.h 48 SmallVectorImpl<DominatorTree::UpdateType> *Updates,
118 DominatorTree *DT;
127 CriticalEdgeSplittingOptions(DominatorTree *DT = nullptr,
222 DominatorTree *DT = nullptr, LoopInfo *LI = nullptr,
230 DominatorTree *DT = nullptr, LoopInfo *LI = nullptr,
250 DominatorTree *DT = nullptr,
269 DominatorTree *DT = nullptr, LoopInfo *LI = nullptr,
304 DominatorTree *DT = nullptr,
include/llvm/Transforms/Utils/Cloning.h 249 DominatorTree *DT,
include/llvm/Transforms/Utils/CodeExtractor.h 89 DominatorTree *const DT;
119 CodeExtractor(ArrayRef<BasicBlock *> BBs, DominatorTree *DT = nullptr,
130 CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs = false,
include/llvm/Transforms/Utils/Local.h 264 const DominatorTree *DT = nullptr);
270 const DominatorTree *DT = nullptr) {
384 DominatorTree &DT);
450 unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT,
454 unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT,
include/llvm/Transforms/Utils/LoopRotationUtils.h 34 AssumptionCache *AC, DominatorTree *DT, ScalarEvolution *SE,
include/llvm/Transforms/Utils/LoopSimplify.h 62 bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE,
include/llvm/Transforms/Utils/LoopUtils.h 53 BasicBlock *InsertPreheaderForLoop(Loop *L, DominatorTree *DT, LoopInfo *LI,
61 bool formDedicatedExitBlocks(Loop *L, DominatorTree *DT, LoopInfo *LI,
76 DominatorTree &DT, LoopInfo &LI);
90 bool formLCSSA(Loop &L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution *SE);
101 bool formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
120 bool sinkRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,
133 bool hoistRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,
149 void deleteDeadLoop(Loop *L, DominatorTree *DT, ScalarEvolution *SE,
163 PredIteratorCache &, LoopInfo *, DominatorTree *, const TargetLibraryInfo *,
289 bool canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT,
include/llvm/Transforms/Utils/LoopVersioning.h 42 DominatorTree *DT, ScalarEvolution *SE,
146 DominatorTree *DT;
include/llvm/Transforms/Utils/PredicateInfo.h 213 PredicateInfo(Function &, DominatorTree &, AssumptionCache &);
247 DominatorTree &DT;
include/llvm/Transforms/Utils/PromoteMemToReg.h 40 void PromoteMemToReg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
include/llvm/Transforms/Utils/SSAUpdaterBulk.h 53 Value *computeValueAt(BasicBlock *BB, RewriteInfo &R, DominatorTree *DT);
85 void RewriteAllUses(DominatorTree *DT,
include/llvm/Transforms/Utils/SimplifyIndVar.h 34 const DominatorTree *DT = nullptr;
42 const DominatorTree *getDomTree() const { return DT; }
48 bool simplifyUsersOfIV(PHINode *CurrIV, ScalarEvolution *SE, DominatorTree *DT,
54 bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, DominatorTree *DT,
include/llvm/Transforms/Utils/UnrollLoop.h 82 ScalarEvolution *SE, DominatorTree *DT,
90 ScalarEvolution *SE, DominatorTree *DT,
101 DominatorTree *DT, AssumptionCache *AC, bool PreserveLCSSA);
106 DominatorTree *DT, AssumptionCache *AC,
110 bool isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
114 DominatorTree &DT, LoopInfo *LI, ScalarEvolution &SE,
125 ScalarEvolution *SE, DominatorTree *DT,
include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h 200 Loop *L, PredicatedScalarEvolution &PSE, DominatorTree *DT,
405 DominatorTree *DT;
include/llvm/Transforms/Vectorize/LoopVectorize.h 135 DominatorTree *DT;
149 TargetTransformInfo &TTI_, DominatorTree &DT_,
include/llvm/Transforms/Vectorize/SLPVectorizer.h 70 DominatorTree *DT = nullptr;
81 DominatorTree *DT_, AssumptionCache *AC_, DemandedBits *DB_,
lib/Analysis/BasicAliasAnalysis.cpp 280 AssumptionCache *AC, DominatorTree *DT, bool &NSW, bool &NUW) {
464 DominatorTree *DT) {
1980 AssumptionCache *AC, DominatorTree *DT) {
lib/Analysis/CFG.cpp 132 const SmallPtrSetImpl<BasicBlock *> *ExclusionSet, const DominatorTree *DT,
207 const DominatorTree *DT, const LoopInfo *LI) {
220 const SmallPtrSetImpl<BasicBlock *> *ExclusionSet, const DominatorTree *DT,
lib/Analysis/CaptureTracking.cpp 78 CapturesBefore(bool ReturnCaptures, const Instruction *I, const DominatorTree *DT,
158 const DominatorTree *DT;
203 const DominatorTree *DT, bool IncludeI,
lib/Analysis/DemandedBits.cpp 297 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
480 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Analysis/DivergenceAnalysis.cpp 95 const Function &F, const Loop *RegionLoop, const DominatorTree &DT,
433 const DominatorTree &DT,
lib/Analysis/DomPrinter.cpp 56 static std::string getGraphName(DominatorTree *DT) {
60 std::string getNodeLabel(DomTreeNode *Node, DominatorTree *G) {
100 static DominatorTree *getGraph(DominatorTreeWrapperPass *DTWP) {
106 DominatorTreeWrapperPass, false, DominatorTree *,
118 DominatorTreeWrapperPass, true, DominatorTree *,
185 DominatorTreeWrapperPass, false, DominatorTree *,
197 DominatorTreeWrapperPass, true, DominatorTree *,
lib/Analysis/DomTreeUpdater.cpp 26 const DominatorTree::UpdateType Update) const {
42 if (Kind == DominatorTree::Insert && !HasEdge)
46 if (Kind == DominatorTree::Delete && HasEdge)
53 const DominatorTree::UpdateType Update) const {
231 void DomTreeUpdater::applyUpdates(ArrayRef<DominatorTree::UpdateType> Updates) {
250 ArrayRef<DominatorTree::UpdateType> Updates) {
255 SmallVector<DominatorTree::UpdateType, 8> DeduplicatedUpdates;
303 DominatorTree &DomTreeUpdater::getDomTree() {
339 PendUpdates.push_back({DominatorTree::Insert, From, To});
349 if (!isUpdateValid({DominatorTree::Insert, From, To}))
360 PendUpdates.push_back({DominatorTree::Insert, From, To});
385 PendUpdates.push_back({DominatorTree::Delete, From, To});
395 if (!isUpdateValid({DominatorTree::Delete, From, To}))
406 PendUpdates.push_back({DominatorTree::Delete, From, To});
463 if (U.getKind() == DominatorTree::Insert)
lib/Analysis/IVDescriptors.cpp 115 DominatorTree *DT) {
195 DominatorTree *DT) {
614 DominatorTree *DT) {
673 DenseMap<Instruction *, Instruction *> &SinkAfter, DominatorTree *DT) {
lib/Analysis/IVUsers.cpp 94 static bool isSimplifiedLoopNest(BasicBlock *BB, const DominatorTree *DT,
129 const Loop *L, DominatorTree *DT) {
304 IVUsers::IVUsers(Loop *L, AssumptionCache *AC, LoopInfo *LI, DominatorTree *DT,
369 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Analysis/InlineCost.cpp 1917 DominatorTree DT(F);
lib/Analysis/InstructionSimplify.cpp 141 static bool valueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) {
2301 const DominatorTree *DT, CmpInst::Predicate Pred,
5418 const DominatorTree *DT, AssumptionCache *AC,
5477 const DominatorTree *DT,
5484 const DominatorTree *DT, AssumptionCache *AC,
5495 auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
5511 auto *DT = AM.template getCachedResult<DominatorTreeAnalysis>(F);
lib/Analysis/LazyValueInfo.cpp 359 DominatorTree &DT;
362 LazyValueInfoAnnotatedWriter(LazyValueInfoImpl *L, DominatorTree &DTree)
403 DominatorTree *DT; ///< An optional DT pointer.
404 DominatorTree *DisabledDT; ///< Stores DT if it's disabled.
470 void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
503 DominatorTree *DT = nullptr)
1615 DominatorTree *DT = nullptr) {
1675 auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F);
1966 void LazyValueInfo::printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
2055 auto &DTree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Analysis/LegacyDivergenceAnalysis.cpp 95 DivergencePropagator(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
118 DominatorTree &DT;
332 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Analysis/Lint.cpp 132 DominatorTree *DT;
549 static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT,
lib/Analysis/LoopAccessAnalysis.cpp 1791 DominatorTree *DT) {
2079 DominatorTree *DT) {
2346 DominatorTree *DT, LoopInfo *LI)
lib/Analysis/LoopInfo.cpp 422 DominatorTree &DT) {
448 bool Loop::isLCSSAForm(DominatorTree &DT) const {
455 bool Loop::isRecursivelyLCSSAForm(DominatorTree &DT, const LoopInfo &LI) const {
1074 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1091 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Analysis/MemoryDependenceAnalysis.cpp 1757 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
1820 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Analysis/MemorySSA.cpp 516 DominatorTree &DT;
925 ClobberWalker(const MemorySSA &MSSA, AliasAnalysisType &AA, DominatorTree &DT)
994 ClobberWalkerBase(MemorySSA *M, AliasAnalysisType *A, DominatorTree *D)
1224 MemorySSA::MemorySSA(Function &Func, AliasAnalysis *AA, DominatorTree *DT)
1276 BatchAAResults *BAA, DominatorTree *DT)
1307 DominatorTree *DT;
2270 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
2314 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Analysis/MemorySSAUpdater.cpp 748 DominatorTree &DT) {
762 DominatorTree &DT) {
770 ArrayRef<std::unique_ptr<ValueToValueMapTy>> VMaps, DominatorTree &DT) {
783 DominatorTree &DT) {
800 DominatorTree NewDT(DT, RevDeleteUpdates);
814 DominatorTree &DT) {
820 DominatorTree &DT,
lib/Analysis/ModuleSummaryAnalysis.cpp 166 DominatorTree &DT) {
243 ProfileSummaryInfo *PSI, DominatorTree &DT,
736 DominatorTree DT(const_cast<Function &>(F));
lib/Analysis/MustExecute.cpp 115 const DominatorTree *DT,
189 const DominatorTree *DT) const {
247 const DominatorTree *DT,
266 const DominatorTree *DT,
369 static bool isMustExecuteIn(const Instruction &I, Loop *L, DominatorTree *DT) {
387 DominatorTree &DT, LoopInfo &LI) {
399 DominatorTree &DT, LoopInfo &LI) {
438 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Analysis/OptimizationRemarkEmitter.cpp 30 DominatorTree DT;
lib/Analysis/PHITransAddr.cpp 145 const DominatorTree *DT) {
313 const DominatorTree *DT,
342 const DominatorTree &DT,
366 BasicBlock *PredBB, const DominatorTree &DT,
lib/Analysis/RegionInfo.cpp 65 DominatorTree *DT, Region *Parent) :
97 void RegionInfo::recalculate(Function &F, DominatorTree *DT_,
191 auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
lib/Analysis/ScalarEvolution.cpp 655 DominatorTree &DT, unsigned Depth = 0) {
803 LoopInfo *LI, DominatorTree &DT) {
4498 static Optional<BinaryOp> MatchBinaryOp(Value *V, DominatorTree &DT) {
5162 static bool IsAvailableOnEntry(const Loop *L, DominatorTree &DT, const SCEV *S,
5170 DominatorTree &DT;
5172 CheckAvailable(const Loop *L, BasicBlock *BB, DominatorTree &DT)
5238 static bool BrPHIToSelect(DominatorTree &DT, BranchInst *BI, PHINode *Merge,
11401 AssumptionCache &AC, DominatorTree &DT,
lib/Analysis/ScalarEvolutionExpander.cpp 606 DominatorTree &DT) {
657 DominatorTree &DT;
659 explicit LoopCompare(DominatorTree &dt) : DT(dt) {}
1080 void SCEVExpander::hoistBeforePos(DominatorTree *DT, Instruction *InstToHoist,
1949 SCEVExpander::replaceCongruentIVs(Loop *L, const DominatorTree *DT,
lib/Analysis/SyncDependenceAnalysis.cpp 120 SyncDependenceAnalysis::SyncDependenceAnalysis(const DominatorTree &DT,
132 const DominatorTree &DT;
152 DivergencePropagator(const FunctionRPOT &FuncRPOT, const DominatorTree &DT,
lib/Analysis/TargetTransformInfo.cpp 57 LoopInfo &LI, DominatorTree &DT,
278 DominatorTree *DT, AssumptionCache *AC,
lib/Analysis/TypeMetadataUtils.cpp 26 const CallInst *CI, DominatorTree &DT) {
53 int64_t Offset, const CallInst *CI, DominatorTree &DT) {
76 DominatorTree &DT) {
101 const CallInst *CI, DominatorTree &DT) {
lib/Analysis/ValueTracking.cpp 104 const DominatorTree *DT;
126 const DominatorTree *DT, bool UseInstrInfo,
170 const DominatorTree *DT,
182 const DominatorTree *DT,
191 const Instruction *CxtI, const DominatorTree *DT,
231 const DominatorTree *DT, bool UseInstrInfo) {
240 const DominatorTree *DT, bool UseInstrInfo) {
247 const Instruction *CxtI, const DominatorTree *DT,
256 const DominatorTree *DT, bool UseInstrInfo) {
268 const DominatorTree *DT, bool UseInstrInfo) {
278 const Instruction *CxtI, const DominatorTree *DT,
291 const DominatorTree *DT, bool UseInstrInfo) {
302 const DominatorTree *DT, bool UseInstrInfo) {
527 const DominatorTree *DT) {
1904 const DominatorTree *DT) {
3896 const DominatorTree *DT) {
4000 AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT,
4013 AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT,
4028 const DominatorTree *DT, bool UseInstrInfo) {
4069 AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT,
4086 const DominatorTree *DT) {
4148 const DominatorTree *DT) {
4161 const DominatorTree *DT) {
4176 const DominatorTree &DT) {
4230 const DominatorTree *DT) {
4240 const DominatorTree *DT) {
lib/CodeGen/CodeGenPrepare.cpp 304 std::unique_ptr<DominatorTree> DT;
345 DominatorTree &getDT(Function &F) {
347 DT = std::make_unique<DominatorTree>(F);
lib/CodeGen/DwarfEHPrepare.cpp 50 DominatorTree *DT = nullptr;
lib/CodeGen/HardwareLoops.cpp 114 DominatorTree *DT = nullptr;
lib/CodeGen/InterleavedAccessPass.cpp 100 DominatorTree *DT = nullptr;
lib/CodeGen/InterleavedLoadCombinePass.cpp 65 InterleavedLoadCombineImpl(Function &F, DominatorTree &DT, MemorySSA &MSSA,
80 DominatorTree &DT;
lib/CodeGen/SafeStack.cpp 883 DominatorTree DT(F);
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 354 static void SplitCriticalSideEffectEdges(Function &Fn, DominatorTree *DT,
442 DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr;
lib/IR/Dominators.cpp 323 DominatorTree DominatorTreeAnalysis::run(Function &F,
325 DominatorTree DT;
344 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/IR/SafepointIRVerifier.cpp 70 const DominatorTree *DT = nullptr;
125 void processFunction(const Function &F, const DominatorTree &DT) {
197 static void Verify(const Function &F, const DominatorTree &DT,
203 const auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
220 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
456 GCPtrTracker(const Function &F, const DominatorTree &DT,
504 const DominatorTree &DT);
536 GCPtrTracker::GCPtrTracker(const Function &F, const DominatorTree &DT,
735 const DominatorTree &DT) {
883 static void Verify(const Function &F, const DominatorTree &DT,
lib/IR/Verifier.cpp 255 DominatorTree DT;
lib/Target/AArch64/AArch64PromoteConstant.cpp 369 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(
395 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(
489 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
lib/Target/AArch64/AArch64StackTagging.cpp 301 const DominatorTree *DT);
436 const DominatorTree *DT) {
587 std::unique_ptr<DominatorTree> DeleteDT;
588 DominatorTree *DT = nullptr;
594 DeleteDT = std::make_unique<DominatorTree>(*F);
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp 45 DominatorTree *DT;
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 74 const DominatorTree *DT;
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp 74 DominatorTree *DT;
lib/Target/ARM/ARMParallelDSP.cpp 215 DominatorTree *DT;
lib/Target/Hexagon/HexagonCommonGEP.cpp 156 DominatorTree *DT;
669 static BasicBlock *nearest_common_dominator(DominatorTree *DT, T &Blocks) {
698 static BasicBlock *nearest_common_dominatee(DominatorTree *DT, T &Blocks) {
865 static BasicBlock *preheader(DominatorTree *DT, Loop *L) {
lib/Target/Hexagon/HexagonGenExtract.cpp 81 DominatorTree *DT;
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 155 DominatorTree *DT;
559 const DominatorTree &dt, const TargetLibraryInfo &tli,
616 const DominatorTree &DT;
lib/Target/PowerPC/PPCLoopPreIncPrep.cpp 109 DominatorTree *DT;
lib/Target/PowerPC/PPCTargetTransformInfo.cpp 942 LoopInfo *LI, DominatorTree *DT,
lib/Target/PowerPC/PPCTargetTransformInfo.h 61 DominatorTree *DT, AssumptionCache *AC,
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp 601 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
lib/Target/WebAssembly/WebAssemblyOptimizeReturned.cpp 39 DominatorTree *DT = nullptr;
lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp 322 static bool foldUnusualPatterns(Function &F, DominatorTree &DT) {
351 static bool runImpl(Function &F, TargetLibraryInfo &TLI, DominatorTree &DT) {
373 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
380 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h 55 const DominatorTree &DT;
80 const DominatorTree &DT)
lib/Transforms/Coroutines/CoroElide.cpp 38 bool shouldElide(Function *F, DominatorTree &DT) const;
39 bool processCoroId(CoroIdInst *, AAResults &AA, DominatorTree &DT);
144 bool Lowerer::shouldElide(Function *F, DominatorTree &DT) const {
191 DominatorTree &DT) {
317 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Coroutines/CoroFrame.cpp 495 AllocaUseVisitor(const DataLayout &DL, const DominatorTree &DT,
520 const DominatorTree &DT;
524 static bool mightWriteIntoAllocaPtr(AllocaInst &A, const DominatorTree &DT,
594 DominatorTree DT(*CB->getFunction());
1320 DominatorTree DT(F);
lib/Transforms/IPO/GlobalOpt.cpp 1787 function_ref<DominatorTree &(Function &)> LookupDomTree) {
1831 auto &DT = LookupDomTree(*const_cast<Function *>(F));
1925 function_ref<DominatorTree &(Function &)> LookupDomTree) {
2067 function_ref<DominatorTree &(Function &)> LookupDomTree) {
2250 function_ref<DominatorTree &(Function &)> LookupDomTree,
2289 auto &DT = LookupDomTree(*F);
2353 function_ref<DominatorTree &(Function &)> LookupDomTree,
2916 function_ref<DominatorTree &(Function &)> LookupDomTree) {
lib/Transforms/IPO/HotColdSplitting.cpp 391 const DominatorTree &DT,
545 std::unique_ptr<DominatorTree> DT;
576 DT = std::make_unique<DominatorTree>(F);
lib/Transforms/IPO/LoopExtractor.cpp 97 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/IPO/PartialInlining.cpp 396 DominatorTree DT(*F);
936 DominatorTree DT(*Caller);
1117 DominatorTree DT;
1192 DominatorTree DT;
lib/Transforms/IPO/SCCP.cpp 17 DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F);
56 DominatorTree &DT =
lib/Transforms/IPO/SampleProfile.cpp 359 std::unique_ptr<DominatorTree> DT;
1544 DT.reset(new DominatorTree);
lib/Transforms/IPO/WholeProgramDevirt.cpp 445 function_ref<DominatorTree &(Function &)> LookupDomTree;
473 function_ref<DominatorTree &(Function &)> LookupDomTree,
578 function_ref<DominatorTree &(Function &)> LookupDomTree);
741 function_ref<DominatorTree &(Function &)> LookupDomTree) {
1569 auto &DT = LookupDomTree(*CI->getFunction());
1618 auto &DT = LookupDomTree(*CI->getFunction());
lib/Transforms/InstCombine/InstCombineInternal.h 324 DominatorTree &DT;
340 AssumptionCache &AC, TargetLibraryInfo &TLI, DominatorTree &DT,
356 DominatorTree &getDominatorTree() const { return DT; }
lib/Transforms/InstCombine/InstructionCombining.cpp 3508 AssumptionCache &AC, TargetLibraryInfo &TLI, DominatorTree &DT,
3554 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
3605 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 322 CHR(Function &Fin, BlockFrequencyInfo &BFIin, DominatorTree &DTin,
404 DominatorTree &DT;
504 static bool isHoistable(Instruction *I, DominatorTree &DT) {
516 Value *V, DominatorTree &DT,
555 checkHoistValue(Value *V, Instruction *InsertPoint, DominatorTree &DT,
1062 DominatorTree &DT,
1453 DominatorTree &DT) {
1499 DominatorTree &DT) {
2077 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
2096 auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 387 DominatorTree DT;
lib/Transforms/Instrumentation/InstrProfiling.cpp 444 DominatorTree DT(*F);
lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp 138 OptimizationRemarkEmitter &ORE, DominatorTree *DT)
175 DominatorTree *DT;
368 std::vector<DominatorTree::UpdateType> Updates;
387 Updates.push_back({DominatorTree::Insert, CaseBB, MergeBB});
388 Updates.push_back({DominatorTree::Insert, BB, CaseBB});
416 DominatorTree *DT) {
432 DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr;
443 auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F);
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 180 using DomTreeCallback = function_ref<const DominatorTree *(Function &F)>;
480 static bool isFullDominator(const BasicBlock *BB, const DominatorTree *DT) {
507 const DominatorTree *DT,
542 const DominatorTree *DT) {
556 static bool IsInterestingCmp(ICmpInst *CMP, const DominatorTree *DT,
600 const DominatorTree *DT = DTCallback(F);
lib/Transforms/ObjCARC/ObjCARCContract.cpp 64 DominatorTree *DT;
lib/Transforms/Scalar/ADCE.cpp 119 DominatorTree *DT;
194 AggressiveDeadCodeElimination(Function &F, DominatorTree *DT,
610 SmallVector<DominatorTree::UpdateType, 4> DeletedEdges;
618 DeletedEdges.push_back({DominatorTree::Delete, BB, Succ});
681 auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F);
710 auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
lib/Transforms/Scalar/AlignmentFromAssumptions.cpp 379 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
386 DominatorTree *DT_) {
403 DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/CallSiteSplitting.cpp 372 DTU.applyUpdatesPermissive({{DominatorTree::Delete, Splits[i], TailBB}});
509 TargetTransformInfo &TTI, DominatorTree &DT) {
567 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
589 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/ConstantHoisting.cpp 205 static void findBestInsertionSet(DominatorTree &DT, BlockFrequencyInfo &BFI,
926 DominatorTree &DT, BlockFrequencyInfo *BFI,
966 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp 160 DominatorTree *DT) {
211 static bool processPHI(PHINode *P, LazyValueInfo *LVI, DominatorTree *DT,
337 DominatorTree *DT) {
407 DTU.applyUpdatesPermissive({{DominatorTree::Delete, BB, Succ}});
829 static bool runImpl(Function &F, LazyValueInfo *LVI, DominatorTree *DT,
920 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
928 DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/DeadStoreElimination.cpp 641 BasicBlock *BB, DominatorTree *DT) {
657 MemoryDependenceResults *MD, DominatorTree *DT,
1074 MemoryDependenceResults *MD, DominatorTree *DT,
1314 MemoryDependenceResults *MD, DominatorTree *DT,
1331 DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F);
1360 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/DivRemPairs.cpp 180 const DominatorTree &DT) {
342 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
363 DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/EarlyCSE.cpp 446 DominatorTree &DT;
527 const TargetTransformInfo &TTI, DominatorTree &DT,
1320 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
1365 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/Float2Int.cpp 63 const DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
121 void Float2IntPass::findRoots(Function &F, const DominatorTree &DT,
516 bool Float2IntPass::runImpl(Function &F, const DominatorTree &DT) {
541 const DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/GVN.cpp 617 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
828 DominatorTree *DT,
1735 DominatorTree *DT) {
2079 bool GVN::runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
lib/Transforms/Scalar/GVNHoist.cpp 257 GVNHoist(DominatorTree *DT, PostDominatorTree *PDT, AliasAnalysis *AA,
330 DominatorTree *DT;
1152 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1177 DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/GuardWidening.cpp 126 DominatorTree &DT;
289 explicit GuardWideningImpl(DominatorTree &DT, PostDominatorTree *PDT,
805 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
856 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
888 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/IndVarSimplify.cpp 138 DominatorTree *DT;
169 IndVarSimplify(LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT,
238 DominatorTree *DT, LoopInfo *LI) {
974 DominatorTree *DT;
1028 DominatorTree *DTree, SmallVectorImpl<WeakTrackingVH> &DI,
1344 static void truncateIVUse(NarrowIVDefUse DU, DominatorTree *DT, LoopInfo *LI) {
1946 const DominatorTree *DTree)
2127 DominatorTree *DT) {
2249 ScalarEvolution *SE, DominatorTree *DT) {
2657 DominatorTree &DT, Loop *L) {
3169 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 232 DominatorTree &DT;
237 BranchProbabilityInfo *BPI, DominatorTree &DT,
604 DominatorTree &DT;
629 DominatorTree &DT, InductiveRangeCheck::Range R)
1775 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/InstSimplifyPass.cpp 100 const DominatorTree *DT =
132 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/JumpThreading.cpp 329 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
382 DominatorTree &DT = DTU->getDomTree();
1095 std::vector<DominatorTree::UpdateType> Updates;
1104 Updates.push_back({DominatorTree::Delete, BB, Succ});
1182 {{DominatorTree::Delete, BB, ToRemoveSucc}});
1271 DTU->applyUpdatesPermissive({{DominatorTree::Delete, BB, RemoveSucc}});
1681 std::vector <DominatorTree::UpdateType> Updates;
1688 Updates.push_back({DominatorTree::Delete, BB, SuccBB});
2044 DTU->applyUpdatesPermissive({{DominatorTree::Insert, NewBB, SuccBB},
2045 {DominatorTree::Insert, PredBB, NewBB},
2046 {DominatorTree::Delete, PredBB, BB}});
2125 std::vector<DominatorTree::UpdateType> Updates;
2129 Updates.push_back({DominatorTree::Insert, NewBB, BB});
2131 Updates.push_back({DominatorTree::Delete, Pred, BB});
2132 Updates.push_back({DominatorTree::Insert, Pred, NewBB});
2285 std::vector<DominatorTree::UpdateType> Updates;
2294 Updates.push_back({DominatorTree::Delete, PredBB, BB});
2310 Updates.push_back({DominatorTree::Insert, OldPredBB, PredBB});
2311 Updates.push_back({DominatorTree::Insert, PredBB, BB});
2312 Updates.push_back({DominatorTree::Delete, OldPredBB, BB});
2357 Updates.push_back({DominatorTree::Insert, PredBB, SuccBB});
2449 DTU->applyUpdatesPermissive({{DominatorTree::Insert, NewBB, BB},
2450 {DominatorTree::Insert, Pred, NewBB}});
2617 std::vector<DominatorTree::UpdateType> Updates;
2619 Updates.push_back({DominatorTree::Insert, BB, SplitBB});
2620 Updates.push_back({DominatorTree::Insert, BB, NewBB});
2621 Updates.push_back({DominatorTree::Insert, NewBB, SplitBB});
2624 Updates.push_back({DominatorTree::Delete, BB, Succ});
2625 Updates.push_back({DominatorTree::Insert, SplitBB, Succ});
lib/Transforms/Scalar/LICM.cpp 138 static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
141 static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT,
145 const DominatorTree *DT,
170 bool runOnLoop(Loop *L, AliasAnalysis *AA, LoopInfo *LI, DominatorTree *DT,
327 Loop *L, AliasAnalysis *AA, LoopInfo *LI, DominatorTree *DT,
495 DominatorTree *DT, TargetLibraryInfo *TLI,
573 DominatorTree *DT;
586 ControlFlowHoister(LoopInfo *LI, DominatorTree *DT, Loop *CurLoop,
796 DominatorTree *DT, TargetLibraryInfo *TLI, Loop *CurLoop,
981 static bool isLoadInvariantInLoop(LoadInst *LI, DominatorTree *DT,
1080 bool llvm::canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT,
1490 static void splitPredecessorsOfLoopExit(PHINode *PN, DominatorTree *DT,
1562 static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT,
1663 static void hoist(Instruction &I, const DominatorTree *DT, const Loop *CurLoop,
1707 const DominatorTree *DT,
lib/Transforms/Scalar/LoopDeletion.cpp 135 static LoopDeletionResult deleteLoopIfDead(Loop *L, DominatorTree &DT,
254 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/LoopDistribute.cpp 186 DominatorTree *DT) {
282 InstPartitionContainer(Loop *L, LoopInfo *LI, DominatorTree *DT)
575 DominatorTree *DT;
658 LoopDistributeForLoop(Loop *L, Function *F, LoopInfo *LI, DominatorTree *DT,
958 DominatorTree *DT;
974 static bool runImpl(Function &F, LoopInfo *LI, DominatorTree *DT,
1021 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1047 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/LoopFuse.cpp 157 const DominatorTree *DT;
162 FusionCandidate(Loop *L, const DominatorTree *DT,
354 const DominatorTree *DT = LHS.DT;
507 DominatorTree &DT;
514 LoopFuser(LoopInfo &LI, DominatorTree &DT, DependenceInfo &DI,
1181 SmallVector<DominatorTree::UpdateType, 8> TreeUpdates;
1203 DominatorTree::Delete, FC0.ExitingBlock, FC1.Preheader));
1205 DominatorTree::Insert, FC0.ExitingBlock, FC1.Header));
1212 DominatorTree::Delete, FC1.Preheader, FC1.Header));
1253 DominatorTree::Insert, FC0.Latch, FC1.Header));
1255 TreeUpdates.emplace_back(DominatorTree::UpdateType(DominatorTree::Delete,
1257 TreeUpdates.emplace_back(DominatorTree::UpdateType(DominatorTree::Insert,
1259 TreeUpdates.emplace_back(DominatorTree::UpdateType(DominatorTree::Delete,
1360 SmallVector<DominatorTree::UpdateType, 8> TreeUpdates;
1379 DominatorTree::Delete, FC1GuardBlock, FC1.Preheader));
1381 DominatorTree::Delete, FC1GuardBlock, FC1NonLoopBlock));
1383 DominatorTree::Delete, FC0GuardBlock, FC1GuardBlock));
1385 DominatorTree::Insert, FC0GuardBlock, FC1NonLoopBlock));
1432 DominatorTree::Delete, FC0.ExitingBlock, FC0.ExitBlock));
1434 DominatorTree::Insert, FC0.ExitingBlock, FC1.Header));
1454 DominatorTree::Delete, FC1.Preheader, FC1.Header));
1497 DominatorTree::Insert, FC0.Latch, FC1.Header));
1499 TreeUpdates.emplace_back(DominatorTree::UpdateType(DominatorTree::Delete,
1501 TreeUpdates.emplace_back(DominatorTree::UpdateType(DominatorTree::Insert,
1503 TreeUpdates.emplace_back(DominatorTree::UpdateType(DominatorTree::Delete,
1588 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1603 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 143 DominatorTree *DT;
154 explicit LoopIdiomRecognize(AliasAnalysis *AA, DominatorTree *DT,
272 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
2229 SmallVector<DominatorTree::UpdateType, 8> DTUpdates;
2268 DTUpdates.push_back({DominatorTree::Delete, PreheaderBB, HeaderBB});
2276 DTUpdates.push_back({DominatorTree::Insert, PhonyPreheaderBB, HeaderBB});
2356 DTUpdates.push_back({DominatorTree::Insert, NewBB, SuccessorBB});
2366 DTUpdates.push_back({DominatorTree::Delete, OldLoopBB, SuccessorBB});
2367 DTUpdates.push_back({DominatorTree::Insert, OldLoopBB, PhonySuccessorBB});
2436 DTUpdates.push_back({DominatorTree::Insert, PhonyPreheaderBB, HeaderBB});
2449 {DominatorTree::Insert, PhonySuccessorBB, ComparedEqualBB});
2451 {DominatorTree::Insert, PhonySuccessorBB, ComparedUnequalBB});
2560 DTUpdates.push_back({DominatorTree::Delete, BB, SuccessorBB});
2561 DTUpdates.push_back({DominatorTree::Insert, BB, SuccessorBB});
2562 DTUpdates.push_back({DominatorTree::Insert, BB, DispatchBB});
lib/Transforms/Scalar/LoopInstSimplify.cpp 50 static bool simplifyLoopInst(Loop &L, DominatorTree &DT, LoopInfo &LI,
189 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/LoopInterchange.cpp 399 LoopInfo *LI, DominatorTree *DT,
424 DominatorTree *DT;
436 DominatorTree *DT = nullptr;
1322 std::vector<DominatorTree::UpdateType> &DTUpdates) {
1331 {DominatorTree::UpdateKind::Insert, BI->getParent(), NewBB});
1333 {DominatorTree::UpdateKind::Delete, BI->getParent(), OldBB});
1428 std::vector<DominatorTree::UpdateType> DTUpdates;
lib/Transforms/Scalar/LoopLoadElimination.cpp 147 DominatorTree *DT) {
166 DominatorTree *DT, BlockFrequencyInfo *BFI,
590 DominatorTree *DT;
599 eliminateLoadsAcrossLoops(Function &F, LoopInfo &LI, DominatorTree &DT,
643 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
694 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/LoopRerollPass.cpp 183 DominatorTree *DT;
380 TargetLibraryInfo *TLI, DominatorTree *DT, LoopInfo *LI,
436 DominatorTree *DT;
lib/Transforms/Scalar/LoopRotation.cpp 97 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/LoopSimplifyCFG.cpp 119 DominatorTree &DT;
124 SmallVector<DominatorTree::UpdateType, 16> DTUpdates;
376 DTUpdates.push_back({DominatorTree::Insert, Preheader, BB});
517 DTUpdates.push_back({DominatorTree::Delete, BB, DeadSucc});
524 ConstantTerminatorFoldingImpl(Loop &L, LoopInfo &LI, DominatorTree &DT,
623 static bool constantFoldTerminators(Loop &L, DominatorTree &DT, LoopInfo &LI,
641 static bool mergeBlocksIntoPredecessors(Loop &L, DominatorTree &DT,
669 static bool simplifyLoopCFG(Loop &L, DominatorTree &DT, LoopInfo &LI,
722 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/LoopSink.cpp 177 LoopInfo &LI, DominatorTree &DT,
252 DominatorTree &DT,
320 DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/LoopStrengthReduce.cpp 1912 DominatorTree &DT;
2053 LSRInstance(Loop *L, IVUsers &IU, ScalarEvolution &SE, DominatorTree &DT,
5496 DominatorTree &DT, LoopInfo &LI,
5707 DominatorTree &DT, LoopInfo &LI,
5742 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp 154 Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT,
277 tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI,
446 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/LoopUnrollPass.cpp 334 const Loop *L, unsigned TripCount, DominatorTree &DT, ScalarEvolution &SE,
737 Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI,
1012 Loop *L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution &SE,
1225 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1414 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/LoopUnswitch.cpp 184 DominatorTree *DT = nullptr;
970 SmallVector<DominatorTree::UpdateType, 3> Updates;
972 Updates.push_back({DominatorTree::Insert, OldBranchParent, TrueDest});
974 Updates.push_back({DominatorTree::Insert, OldBranchParent, FalseDest});
978 Updates.push_back({DominatorTree::Delete, OldBranchParent, OldBranchSucc});
lib/Transforms/Scalar/LoopVersioningLICM.cpp 605 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/MemCpyOptimizer.cpp 853 DominatorTree &DT = LookupDomTree();
1291 DominatorTree &DT = LookupDomTree();
1336 DominatorTree &DT = LookupDomTree();
1409 std::function<DominatorTree &()> LookupDomTree_) {
lib/Transforms/Scalar/MergeICmps.cpp 666 DTU.applyUpdates({{DominatorTree::Insert, BB, PhiBB}});
671 DTU.applyUpdates({{DominatorTree::Insert, BB, NextCmpBlock},
672 {DominatorTree::Insert, BB, PhiBB}});
729 DTU.applyUpdates({{DominatorTree::Delete, Pred, EntryBlock_},
730 {DominatorTree::Insert, Pred, NextCmpBlock}});
742 DTU.applyUpdates({{DominatorTree::Delete, NextCmpBlock, EntryBlock_}});
864 DominatorTree *DT) {
937 auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/NaryReassociate.cpp 171 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
182 auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
197 DominatorTree *DT_, ScalarEvolution *SE_,
lib/Transforms/Scalar/NewGVN.cpp 492 DominatorTree *DT;
657 NewGVN(Function &F, DominatorTree *DT, AssumptionCache *AC,
4230 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/PlaceSafepoints.cpp 113 DominatorTree *DT = nullptr;
200 DominatorTree &DT,
384 DominatorTree &DT) {
495 DominatorTree DT;
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 141 auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
189 auto &DT = getAnalysis<DominatorTreeWrapperPass>(F).getDomTree();
301 static void computeLiveInValues(DominatorTree &DT, Function &F,
372 DominatorTree &DT, GCPtrLivenessData &OriginalLivenessData, CallBase *Call,
1161 DominatorTree *DT, DefiningValueMapTy &DVCache) {
1175 static void findBasePointers(DominatorTree &DT, DefiningValueMapTy &DVCache,
1202 Function &F, DominatorTree &DT, ArrayRef<CallBase *> toUpdate,
1222 DominatorTree &DT) {
1601 makeStatepointExplicit(DominatorTree &DT, CallBase *Call,
1687 Function &F, DominatorTree &DT, ArrayRef<Value *> Live,
1916 Function &F, DominatorTree &DT, ArrayRef<CallBase *> toUpdate,
2171 static bool insertParsePoints(Function &F, DominatorTree &DT,
2516 bool RewriteStatepointsForGC::runOnFunction(Function &F, DominatorTree &DT,
2698 static void checkBasicSSA(DominatorTree &DT, SetVector<Value *> &Live,
2716 static void checkBasicSSA(DominatorTree &DT, GCPtrLivenessData &Data,
2724 static void computeLiveInValues(DominatorTree &DT, Function &F,
lib/Transforms/Scalar/SROA.cpp 4557 PreservedAnalyses SROA::runImpl(Function &F, DominatorTree &RunDT,
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 237 User *&UserChainTail, const DominatorTree *DT);
243 const DominatorTree *DT);
246 ConstantOffsetExtractor(Instruction *InsertionPt, const DominatorTree *DT)
338 const DominatorTree *DT;
448 DominatorTree *DT = nullptr;
737 const DominatorTree *DT) {
754 const DominatorTree *DT) {
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 265 DominatorTree &DT, LoopInfo &LI,
349 static bool unswitchTrivialBranch(Loop &L, BranchInst &BI, DominatorTree &DT,
572 static bool unswitchTrivialSwitch(Loop &L, SwitchInst &SI, DominatorTree &DT,
807 SmallVector<DominatorTree::UpdateType, 4> DTUpdates;
851 static bool unswitchAllTrivialConditions(Loop &L, DominatorTree &DT,
975 SmallVectorImpl<DominatorTree::UpdateType> &DTUpdates, AssumptionCache &AC,
976 DominatorTree &DT, LoopInfo &LI, MemorySSAUpdater *MSSAU) {
1128 DTUpdates.push_back({DominatorTree::Insert, ClonedBB, SuccBB});
1481 DominatorTree &DT, LoopInfo &LI,
1878 void visitDomSubTree(DominatorTree &DT, BasicBlock *BB, CallableT Callable) {
1903 SmallVectorImpl<BasicBlock *> &ExitBlocks, DominatorTree &DT, LoopInfo &LI,
2021 SmallVector<DominatorTree::UpdateType, 4> DTUpdates;
2052 DTUpdates.push_back({DominatorTree::Insert, SplitBB, ClonedPH});
2071 {DominatorTree::Insert, SplitBB, ClonedPHs.find(SuccBB)->second});
2105 DTUpdates.push_back({DominatorTree::Delete, ParentBB, UnswitchedSuccBB});
2125 DTUpdates.push_back({DominatorTree::Delete, ParentBB, SuccBB});
2143 DTUpdates.push_back({DominatorTree::Insert, SplitBB, ClonedPH});
2377 DominatorTree &DT, LoopInfo &LI, MemorySSAUpdater *MSSAU) {
2378 SmallVector<DominatorTree::UpdateType, 4> DTUpdates;
2390 DTUpdates.push_back({DominatorTree::Delete, CheckBB, Succ});
2415 DTUpdates.push_back({DominatorTree::Insert, CheckBB, Succ});
2420 DTUpdates.push_back({DominatorTree::Insert, GuardedBlock, Succ});
2452 Instruction &TI, Loop &L, LoopInfo &LI, DominatorTree &DT,
2524 unswitchBestCondition(Loop &L, DominatorTree &DT, LoopInfo &LI,
2801 static bool unswitchLoop(Loop &L, DominatorTree &DT, LoopInfo &LI,
2931 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/Sink.cpp 37 DominatorTree &DT) {
95 DominatorTree &DT, LoopInfo &LI) {
140 DominatorTree &DT, LoopInfo &LI, AAResults &AA) {
198 static bool ProcessBlock(BasicBlock &BB, DominatorTree &DT, LoopInfo &LI,
238 static bool iterativelySinkInstructions(Function &F, DominatorTree &DT,
256 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
277 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp 49 isSafeToSpeculatePHIUsers(PHINode &PN, DominatorTree &DT,
205 SmallPtrSetImpl<Instruction *> &UnsafeSet, DominatorTree &DT,
562 DominatorTree &DT) {
734 DominatorTree &DT, TargetTransformInfo &TTI) {
806 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp 232 DominatorTree *DT = nullptr;
lib/Transforms/Scalar/StructurizeCFG.cpp 95 DominatorTree *DT;
116 explicit NearestCommonDominator(DominatorTree *DomTree) : DT(DomTree) {}
192 DominatorTree *DT;
lib/Transforms/Scalar/TailRecursionElimination.cpp 681 DTU.applyUpdates({{DominatorTree::Insert, BB, OldEntry}});
832 auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
867 auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
lib/Transforms/Utils/BasicBlockUtils.cpp 56 SmallVectorImpl<DominatorTree::UpdateType> *Updates,
65 Updates->push_back({DominatorTree::Delete, BB, Succ});
104 SmallVector<DominatorTree::UpdateType, 4> Updates;
228 std::vector<DominatorTree::UpdateType> Updates;
240 Updates.push_back({DominatorTree::Insert, PredBB, *I});
242 Updates.push_back({DominatorTree::Delete, BB, *I});
243 Updates.push_back({DominatorTree::Delete, PredBB, BB});
360 BasicBlock *llvm::SplitEdge(BasicBlock *BB, BasicBlock *Succ, DominatorTree *DT,
403 DominatorTree *DT, LoopInfo *LI,
439 DominatorTree *DT, LoopInfo *LI,
596 const char *Suffix, DominatorTree *DT,
667 DominatorTree *DT, LoopInfo *LI,
805 DTU->applyUpdates({{DominatorTree::Delete, Pred, BB}});
814 DominatorTree *DT, LoopInfo *LI,
lib/Transforms/Utils/BreakCriticalEdges.cpp 51 auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
86 auto *DT = AM.getCachedResult<DominatorTreeAnalysis>(F);
212 auto *DT = Options.DT;
233 SmallVector<DominatorTree::UpdateType, 3> Updates;
234 Updates.push_back({DominatorTree::Insert, TIBB, NewBB});
235 Updates.push_back({DominatorTree::Insert, NewBB, DestBB});
237 Updates.push_back({DominatorTree::Delete, TIBB, DestBB});
lib/Transforms/Utils/CloneFunction.cpp 755 DominatorTree *DT,
854 DTU.applyUpdates({{DominatorTree::Delete, PredBB, BB},
855 {DominatorTree::Insert, PredBB, NewBB},
856 {DominatorTree::Insert, NewBB, BB}});
lib/Transforms/Utils/CodeExtractor.cpp 196 buildExtractionBlockSet(ArrayRef<BasicBlock *> BBs, DominatorTree *DT,
244 CodeExtractor::CodeExtractor(ArrayRef<BasicBlock *> BBs, DominatorTree *DT,
254 CodeExtractor::CodeExtractor(DominatorTree &DT, Loop &L, bool AggregateArgs,
lib/Transforms/Utils/InlineFunction.cpp 936 DominatorTree DT;
1150 DominatorTree DT;
lib/Transforms/Utils/LCSSA.cpp 77 DominatorTree &DT, LoopInfo &LI) {
276 Loop &L, DominatorTree &DT, SmallVector<BasicBlock *, 8> &ExitBlocks,
320 bool llvm::formLCSSA(Loop &L, DominatorTree &DT, LoopInfo *LI,
385 bool llvm::formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI,
398 static bool formLCSSAOnAllLoops(LoopInfo *LI, DominatorTree &DT,
414 DominatorTree *DT;
481 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Utils/LibCallsShrinkWrap.cpp 75 LibCallsShrinkWrap(const TargetLibraryInfo &TLI, DominatorTree *DT)
129 DominatorTree *DT;
523 DominatorTree *DT) {
538 auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
553 auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F);
lib/Transforms/Utils/Local.cpp 135 DTU->applyUpdatesPermissive({{DominatorTree::Delete, BB, OldDest}});
212 {{DominatorTree::Delete, ParentBB, DefaultDest}});
238 std::vector <DominatorTree::UpdateType> Updates;
250 Updates.push_back({DominatorTree::Delete, BB, Succ});
306 std::vector <DominatorTree::UpdateType> Updates;
321 Updates.push_back({DominatorTree::Delete, ParentBB, DestBB});
667 DTU->applyUpdatesPermissive({{DominatorTree::Delete, Pred, BB}});
691 SmallVector<DominatorTree::UpdateType, 32> Updates;
694 Updates.push_back({DominatorTree::Delete, PredBB, DestBB});
696 Updates.push_back({DominatorTree::Delete, *I, PredBB});
699 Updates.push_back({DominatorTree::Insert, *I, DestBB});
1003 SmallVector<DominatorTree::UpdateType, 32> Updates;
1005 Updates.push_back({DominatorTree::Delete, BB, Succ});
1008 Updates.push_back({DominatorTree::Delete, *I, BB});
1011 Updates.push_back({DominatorTree::Insert, *I, Succ});
1185 const DominatorTree *DT) {
1733 Instruction &From, Value &To, Instruction &DomPoint, DominatorTree &DT,
1822 Instruction &DomPoint, DominatorTree &DT) {
1902 std::vector <DominatorTree::UpdateType> Updates;
1914 Updates.push_back({DominatorTree::Delete, BB, Successor});
1971 DTU->applyUpdatesPermissive({{DominatorTree::Delete, BB, UnwindDestBB}});
2119 {{DominatorTree::Delete, BB, UnwindDestBB}});
2208 DTU->applyUpdatesPermissive({{DominatorTree::Delete, BB, UnwindDest}});
2239 std::vector<DominatorTree::UpdateType> Updates;
2245 Updates.push_back({DominatorTree::Delete, BB, Successor});
2497 DominatorTree &DT,
2506 DominatorTree &DT,
lib/Transforms/Utils/LoopRotationUtils.cpp 56 DominatorTree *DT;
66 DominatorTree *DT, ScalarEvolution *SE, MemorySSAUpdater *MSSAU,
424 SmallVector<DominatorTree::UpdateType, 3> Updates;
425 Updates.push_back({DominatorTree::Insert, OrigPreheader, Exit});
426 Updates.push_back({DominatorTree::Insert, OrigPreheader, NewHeader});
427 Updates.push_back({DominatorTree::Delete, OrigPreheader, OrigHeader});
656 AssumptionCache *AC, DominatorTree *DT,
lib/Transforms/Utils/LoopSimplify.cpp 122 BasicBlock *llvm::InsertPreheaderForLoop(Loop *L, DominatorTree *DT,
182 static PHINode *findPHIToPartitionLoops(Loop *L, DominatorTree *DT,
225 DominatorTree *DT, LoopInfo *LI,
349 DominatorTree *DT, LoopInfo *LI,
472 DominatorTree *DT, LoopInfo *LI,
709 bool llvm::simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI,
800 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
835 DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Utils/LoopUnroll.cpp 200 ScalarEvolution *SE, DominatorTree *DT,
277 ScalarEvolution *SE, DominatorTree *DT,
lib/Transforms/Utils/LoopUnrollAndJam.cpp 55 DominatorTree *DT) {
175 bool UnrollRemainder, LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT,
524 SmallVector<DominatorTree::UpdateType, 4> DTUpdates;
525 DTUpdates.emplace_back(DominatorTree::UpdateKind::Delete, ForeBlocksLast[0],
527 DTUpdates.emplace_back(DominatorTree::UpdateKind::Delete,
530 DTUpdates.emplace_back(DominatorTree::UpdateKind::Insert,
532 DTUpdates.emplace_back(DominatorTree::UpdateKind::Insert,
687 bool llvm::isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
lib/Transforms/Utils/LoopUnrollPeel.cpp 472 ValueToValueMapTy &VMap, ValueToValueMapTy &LVMap, DominatorTree *DT,
579 ScalarEvolution *SE, DominatorTree *DT,
lib/Transforms/Utils/LoopUnrollRuntime.cpp 70 ValueToValueMapTy &VMap, DominatorTree *DT,
185 ValueToValueMapTy &VMap, DominatorTree *DT,
304 ValueToValueMapTy &VMap, DominatorTree *DT, LoopInfo *LI) {
550 DominatorTree *DT, AssumptionCache *AC,
lib/Transforms/Utils/LoopUtils.cpp 51 bool llvm::formDedicatedExitBlocks(Loop *L, DominatorTree *DT, LoopInfo *LI,
506 void llvm::deleteDeadLoop(Loop *L, DominatorTree *DT = nullptr,
595 DTU.applyUpdates({{DominatorTree::Insert, Preheader, ExitBlock},
596 {DominatorTree::Delete, Preheader, L->getHeader()}});
lib/Transforms/Utils/LoopVersioning.cpp 33 DominatorTree *DT, ScalarEvolution *SE,
265 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Utils/Mem2Reg.cpp 34 static bool promoteMemoryToRegister(Function &F, DominatorTree &DT,
61 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
87 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
lib/Transforms/Utils/PredicateInfo.cpp 128 DominatorTree &DT;
130 ValueDFS_Compare(DominatorTree &DT, OrderedInstructions &OI)
743 PredicateInfo::PredicateInfo(Function &F, DominatorTree &DT,
799 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
812 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
872 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Utils/PromoteMemoryToRegister.cpp 229 DominatorTree &DT;
268 PromoteMem2Reg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
349 DominatorTree &DT, AssumptionCache *AC) {
447 DominatorTree &DT,
1000 void llvm::PromoteMemToReg(ArrayRef<AllocaInst *> Allocas, DominatorTree &DT,
lib/Transforms/Utils/SSAUpdaterBulk.cpp 77 DominatorTree *DT) {
128 void SSAUpdaterBulk::RewriteAllUses(DominatorTree *DT,
lib/Transforms/Utils/SimplifyIndVar.cpp 56 DominatorTree *DT;
63 SimplifyIndvar(Loop *Loop, ScalarEvolution *SE, DominatorTree *DT,
933 bool simplifyUsersOfIV(PHINode *CurrIV, ScalarEvolution *SE, DominatorTree *DT,
944 bool simplifyLoopIVs(Loop *L, ScalarEvolution *SE, DominatorTree *DT,
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp 114 DominatorTree &DT;
121 Vectorizer(Function &F, AliasAnalysis &AA, DominatorTree &DT,
255 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
270 DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Vectorize/LoopVectorizationPlanner.h 242 void executePlan(InnerLoopVectorizer &LB, DominatorTree *DT);
lib/Transforms/Vectorize/LoopVectorize.cpp 401 LoopInfo *LI, DominatorTree *DT,
673 DominatorTree *DT;
773 LoopInfo *LI, DominatorTree *DT,
1603 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
6493 DominatorTree *DT) {
7460 Loop *L, PredicatedScalarEvolution &PSE, LoopInfo *LI, DominatorTree *DT,
7803 DominatorTree &DT_, BlockFrequencyInfo &BFI_, TargetLibraryInfo *TLI_,
7872 auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
lib/Transforms/Vectorize/SLPVectorizer.cpp 504 DominatorTree *Dt, AssumptionCache *AC, DemandedBits *DB,
1958 DominatorTree *DT;
5214 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
5248 auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
5267 LoopInfo *LI_, DominatorTree *DT_,
6678 static Value *getReductionValue(const DominatorTree *DT, PHINode *P,
lib/Transforms/Vectorize/VPlan.cpp 453 void VPlan::updateDominatorTree(DominatorTree *DT, BasicBlock *LoopPreHeaderBB,
lib/Transforms/Vectorize/VPlan.h 234 VPTransformState(unsigned VF, unsigned UF, LoopInfo *LI, DominatorTree *DT,
309 DominatorTree *DT;
1255 static void updateDominatorTree(DominatorTree *DT,
tools/clang/lib/CodeGen/CodeGenFunction.cpp 425 llvm::DominatorTree DT(*CurFn);
tools/polly/include/polly/CodeGen/BlockGenerators.h 68 DominatorTree &DT, AllocaMapTy &ScalarMap,
138 DominatorTree &DT;
tools/polly/include/polly/CodeGen/IslExprBuilder.h 124 llvm::ScalarEvolution &SE, llvm::DominatorTree &DT,
206 llvm::DominatorTree &DT;
tools/polly/include/polly/CodeGen/IslNodeBuilder.h 70 DominatorTree &DT, Scop &S, BasicBlock *StartBlock)
156 DominatorTree &DT;
tools/polly/include/polly/CodeGen/LoopGenerators.h 66 PollyIRBuilder &Builder, LoopInfo &LI, DominatorTree &DT,
115 DominatorTree &DT, const DataLayout &DL)
152 DominatorTree &DT;
tools/polly/include/polly/CodeGen/LoopGeneratorsGOMP.h 30 DominatorTree &DT, const DataLayout &DL)
tools/polly/include/polly/CodeGen/LoopGeneratorsKMP.h 30 DominatorTree &DT, const DataLayout &DL)
tools/polly/include/polly/CodeGen/Utils.h 69 executeScopConditionally(Scop &S, llvm::Value *RTC, llvm::DominatorTree &DT,
tools/polly/include/polly/ScopBuilder.h 41 DominatorTree &DT;
815 const DataLayout &DL, DominatorTree &DT, LoopInfo &LI,
tools/polly/include/polly/ScopDetection.h 193 const DominatorTree &DT;
517 ScopDetection(Function &F, const DominatorTree &DT, ScalarEvolution &SE,
tools/polly/include/polly/ScopInfo.h 1731 DominatorTree *DT;
1946 Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI, DominatorTree &DT,
1952 void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
2105 DominatorTree *getDT() const { return DT; }
2223 bool isDominatedBy(const DominatorTree &DT, BasicBlock *BB) const;
2812 DominatorTree &DT;
2818 LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,
tools/polly/include/polly/ScopPass.h 173 DominatorTree &DT;
tools/polly/include/polly/Support/SCEVValidator.h 98 const llvm::DominatorTree &DT);
107 const llvm::DominatorTree &DT);
tools/polly/include/polly/Support/ScopHelper.h 307 void simplifyRegion(llvm::Region *R, llvm::DominatorTree *DT,
325 llvm::DominatorTree *DT, llvm::LoopInfo *LI,
372 llvm::LoopInfo &LI, const llvm::DominatorTree &DT);
415 llvm::ScalarEvolution &SE, const llvm::DominatorTree &DT,
tools/polly/lib/Analysis/ScopBuilder.cpp 178 const DominatorTree &DT) {
3549 static void verifyUses(Scop *S, LoopInfo &LI, DominatorTree &DT) {
3751 const DataLayout &DL, DominatorTree &DT, LoopInfo &LI,
tools/polly/lib/Analysis/ScopDetection.cpp 329 ScopDetection::ScopDetection(Function &F, const DominatorTree &DT,
1856 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1903 auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
tools/polly/lib/Analysis/ScopInfo.cpp 1544 bool Scop::isDominatedBy(const DominatorTree &DT, BasicBlock *BB) const {
1699 DominatorTree &DT, ScopDetection::DetectionContext &DC,
2675 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
2720 LoopInfo &LI, AliasAnalysis &AA, DominatorTree &DT,
2772 auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
2811 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
tools/polly/lib/CodeGen/BlockGenerators.cpp 57 PollyIRBuilder &B, LoopInfo &LI, ScalarEvolution &SE, DominatorTree &DT,
1420 static bool isDominatingSubregionExit(const DominatorTree &DT, Region *R,
1436 static BasicBlock *findExitDominator(DominatorTree &DT, Region *R) {
tools/polly/lib/CodeGen/CodeGeneration.cpp 168 static bool CodeGen(Scop &S, IslAstInfo &AI, LoopInfo &LI, DominatorTree &DT,
316 DominatorTree *DT;
tools/polly/lib/CodeGen/IslExprBuilder.cpp 42 DominatorTree &DT, LoopInfo &LI,
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 603 static void removeSubFuncFromDomTree(Function *F, DominatorTree &DT) {
tools/polly/lib/CodeGen/LoopGenerators.cpp 84 DominatorTree &DT, BasicBlock *&ExitBB,
tools/polly/lib/CodeGen/Utils.cpp 32 const char *Suffix, DominatorTree *DT,
78 polly::executeScopConditionally(Scop &S, Value *RTC, DominatorTree &DT,
tools/polly/lib/Support/SCEVValidator.cpp 774 const DominatorTree &DT) {
799 const DominatorTree &DT) {
tools/polly/lib/Support/ScopHelper.cpp 44 static void simplifyRegionEntry(Region *R, DominatorTree *DT, LoopInfo *LI,
108 static void simplifyRegionExit(Region *R, DominatorTree *DT, LoopInfo *LI,
156 void polly::simplifyRegion(Region *R, DominatorTree *DT, LoopInfo *LI,
172 DominatorTree *DT, llvm::LoopInfo *LI,
200 void polly::splitEntryBlockForAlloca(BasicBlock *EntryBlock, DominatorTree *DT,
214 auto *DT = DTWP ? &DTWP->getDomTree() : nullptr;
403 const DominatorTree &DT) {
550 ScalarEvolution &SE, const DominatorTree &DT,
tools/polly/lib/Transform/CodePreparation.cpp 68 auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
unittests/Analysis/BasicAliasAnalysisTest.cpp 44 DominatorTree DT;
unittests/Analysis/BlockFrequencyInfoTest.cpp 30 std::unique_ptr<DominatorTree> DT;
35 DT.reset(new DominatorTree(F));
unittests/Analysis/BranchProbabilityInfoTest.cpp 29 std::unique_ptr<DominatorTree> DT;
34 DT.reset(new DominatorTree(F));
unittests/Analysis/CFGTest.cpp 100 DominatorTree *DT =
unittests/Analysis/CaptureTrackingTest.cpp 64 DominatorTree DT(*F);
unittests/Analysis/DivergenceAnalysisTest.cpp 50 std::unique_ptr<DominatorTree> DT;
58 DT.reset(new DominatorTree(F));
unittests/Analysis/DomTreeUpdaterTest.cpp 54 DominatorTree DT(*F);
75 {{DominatorTree::Insert, BB0, BB0}, {DominatorTree::Delete, BB0, BB0}});
75 {{DominatorTree::Insert, BB0, BB0}, {DominatorTree::Delete, BB0, BB0}});
80 std::vector<DominatorTree::UpdateType> Updates;
82 Updates.push_back({DominatorTree::Delete, BB0, BB3});
83 Updates.push_back({DominatorTree::Delete, BB0, BB3});
86 Updates.push_back({DominatorTree::Insert, BB1, BB2});
88 Updates.push_back({DominatorTree::Delete, BB0, BB1});
111 {{DominatorTree::Insert, BB1, BB2}, {DominatorTree::Delete, BB0, BB1}});
111 {{DominatorTree::Insert, BB1, BB2}, {DominatorTree::Delete, BB0, BB1}});
165 DominatorTree DT(*F);
186 DTU.applyUpdates({{DominatorTree::Insert, NewEntry, BB0}});
201 DTU.applyUpdates({{DominatorTree::Delete, NewEntry, BB0},
202 {DominatorTree::Insert, NewEntry, BB1}});
239 DominatorTree DT(*F);
255 DTU.applyUpdatesPermissive({{DominatorTree::Insert, BB0, BB0}});
260 std::vector<DominatorTree::UpdateType> Updates;
262 Updates.push_back({DominatorTree::Delete, BB0, BB3});
263 Updates.push_back({DominatorTree::Delete, BB0, BB3});
266 Updates.push_back({DominatorTree::Insert, BB1, BB2});
268 Updates.push_back({DominatorTree::Delete, BB0, BB1});
328 DominatorTree DT(*F);
396 std::vector<DominatorTree::UpdateType> Updates;
398 Updates.push_back({DominatorTree::Delete, BB0, BB2});
399 Updates.push_back({DominatorTree::Delete, BB2, BB3});
421 Updates.push_back({DominatorTree::Delete, BB0, BB1});
422 Updates.push_back({DominatorTree::Delete, BB1, BB3});
457 DominatorTree DT(*F);
473 DTU.applyUpdates({{DominatorTree::Delete, BB0, BB0}});
477 std::vector<DominatorTree::UpdateType> Updates;
479 Updates.push_back({DominatorTree::Delete, BB0, BB3});
480 Updates.push_back({DominatorTree::Delete, BB0, BB3});
483 Updates.push_back({DominatorTree::Insert, BB1, BB2});
485 Updates.push_back({DominatorTree::Delete, BB0, BB1});
540 DominatorTree DT(*F);
564 DTU.applyUpdates({{DominatorTree::Insert, NewEntry, BB0}});
579 DTU.applyUpdates({{DominatorTree::Delete, NewEntry, BB0},
580 {DominatorTree::Insert, NewEntry, BB1}});
629 DominatorTree DT(*F);
650 std::vector<DominatorTree::UpdateType> Updates;
652 Updates.push_back({DominatorTree::Delete, BB0, BB3});
689 Updates.push_back({DominatorTree::Delete, BB0, BB2});
748 DominatorTree DT(*F);
764 DTU.applyUpdatesPermissive({{DominatorTree::Delete, BB0, BB1},
765 {DominatorTree::Delete, BB0, BB1},
766 {DominatorTree::Insert, BB0, BB1},
767 {DominatorTree::Insert, BB0, BB1},
768 {DominatorTree::Insert, BB0, BB1}});
774 DTU.applyUpdatesPermissive({{DominatorTree::Delete, BB0, BB1}});
782 DTU.applyUpdatesPermissive({{DominatorTree::Delete, BB0, BB1},
783 {DominatorTree::Insert, BB0, BB1},
784 {DominatorTree::Delete, BB0, BB1},
785 {DominatorTree::Insert, BB0, BB1},
786 {DominatorTree::Insert, BB0, BB1}});
792 DTU.applyUpdates({{DominatorTree::Insert, BB0, BB2}});
unittests/Analysis/IVDescriptorsTest.cpp 31 DominatorTree DT(*F);
unittests/Analysis/LoopInfoTest.cpp 27 DominatorTree DT(*F);
42 DominatorTree DT(*F);
186 DominatorTree DT(F);
unittests/Analysis/MemorySSATest.cpp 41 DominatorTree DT;
unittests/Analysis/OrderedInstructionsTest.cpp 55 std::unique_ptr<DominatorTree> DT(new DominatorTree(*F));
55 std::unique_ptr<DominatorTree> DT(new DominatorTree(*F));
unittests/Analysis/ProfileSummaryInfoTest.cpp 34 std::unique_ptr<DominatorTree> DT;
41 DT.reset(new DominatorTree(F));
unittests/Analysis/ScalarEvolutionTest.cpp 40 std::unique_ptr<DominatorTree> DT;
47 DT.reset(new DominatorTree(F));
unittests/IR/DominatorTreeBatchUpdatesTest.cpp 25 using DomUpdate = DominatorTree::UpdateType;
31 const auto Insert = DominatorTree::Insert;
32 const auto Delete = DominatorTree::Delete;
97 DominatorTree DT(*Holder.F);
119 DominatorTree DT(*Holder.F);
145 DominatorTree DT(*Holder.F);
178 DominatorTree DT(*Holder.F);
209 DominatorTree DT(*Holder.F);
242 DominatorTree DT(*Holder.F);
275 DominatorTree DT(*Holder.F);
308 DominatorTree DT(*Holder.F);
338 DominatorTree DT(*Holder.F);
unittests/IR/DominatorTreeTest.cpp 28 function_ref<void(Function &F, DominatorTree *DT, PostDominatorTree *PDT)>
33 DominatorTree DT(*F);
404 DominatorTree NDT(F);
496 DominatorTree NDT(F);
591 DominatorTree NDT(F);
689 DominatorTree DT(*Holder.F);
715 DominatorTree DT(*Holder.F);
743 DominatorTree DT(*Holder.F);
794 DominatorTree DT(*Holder.F);
824 DominatorTree DT(*Holder.F);
851 DominatorTree DT(*Holder.F);
877 DominatorTree DT(*Holder.F);
907 DominatorTree DT(*Holder.F);
945 DominatorTree DT(*Holder.F);
981 DominatorTree DT(*Holder.F);
unittests/Transforms/Utils/BasicBlockUtilsTest.cpp 48 DominatorTree DT(*F);
76 DominatorTree DT(*F);
104 DominatorTree DT(*F);
131 DominatorTree DT(*F);
unittests/Transforms/Utils/CloningTest.cpp 362 function_ref<void(Function &F, LoopInfo &LI, DominatorTree &DT)> Test) {
366 DominatorTree DT(*F);
unittests/Transforms/Utils/LocalTest.cpp 169 function_ref<void(Function &F, DominatorTree *DT)> Test) {
173 DominatorTree DT(*F);
710 DominatorTree DT{F};
unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp 87 DominatorTree DT(*F);
179 DominatorTree DT(*F);
unittests/Transforms/Utils/SizeOptsTest.cpp 34 std::unique_ptr<DominatorTree> DT;
39 DT.reset(new DominatorTree(F));
unittests/Transforms/Utils/UnrollLoopTest.cpp 62 DominatorTree DT(*F);
unittests/Transforms/Vectorize/VPlanTestBase.h 32 std::unique_ptr<DominatorTree> DT;
44 DT.reset(new DominatorTree(F));
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
usr/include/c++/7.4.0/bits/unique_ptr.h 68 default_delete(const default_delete<_Up>&) noexcept { }
72 operator()(_Tp* __ptr) const
74 static_assert(!is_void<_Tp>::value,
76 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
297 __safe_conversion_up<_Up, _Ep>,
301 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
811 { typedef unique_ptr<_Tp> __single_object; };
823 inline typename _MakeUniq<_Tp>::__single_object
824 make_unique(_Args&&... __args)
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
825 { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
2253 inline typename add_rvalue_reference<_Tp>::type