/freebsd-11-stable/contrib/llvm-project/llvm/include/llvm/Analysis/ |
H A D | MemorySSAUpdater.h | 131 DominatorTree &DT); 134 ArrayRef<std::unique_ptr<ValueToValueMapTy>> VMaps, DominatorTree &DT); 136 /// Apply CFG updates, analogous with the DT edge updates. 137 void applyUpdates(ArrayRef<CFGUpdate> Updates, DominatorTree &DT); 138 /// Apply CFG insert updates, analogous with the DT edge updates. 139 void applyInsertUpdates(ArrayRef<CFGUpdate> Updates, DominatorTree &DT); 303 DominatorTree &DT); 304 void applyInsertUpdates(ArrayRef<CFGUpdate>, DominatorTree &DT,
|
H A D | LazyValueInfo.h | 36 DominatorTree *DT = nullptr; member in class:llvm::LazyValueInfo 45 : AC(AC_), DL(DL_), TLI(TLI_), DT(DT_) {} 47 : AC(Arg.AC), DL(Arg.DL), TLI(Arg.TLI), DT(Arg.DT), PImpl(Arg.PImpl) { 55 DT = Arg.DT; 111 /// we can solve/print for, in the LVIPrinter. The DT is optional 119 /// instance was initialized without a DT pointer.
|
H A D | MustExecute.h | 85 const DominatorTree *DT) const; 97 const DominatorTree *DT, 122 const DominatorTree *DT, 151 const DominatorTree *DT, 174 ICFLoopSafetyInfo(DominatorTree *DT) : LoopSafetyInfo(), ICF(DT), MW(DT) {}; argument
|
/freebsd-11-stable/contrib/llvm-project/clang/include/clang/Lex/ |
H A D | DirectoryLookup.h | 69 DirectoryLookup(DirectoryEntryRef Dir, SrcMgr::CharacteristicKind DT, argument 71 : u(Dir), DirCharacteristic(DT), 76 DirectoryLookup(const HeaderMap *Map, SrcMgr::CharacteristicKind DT, argument 78 : u(Map), DirCharacteristic(DT), LookupType(LT_HeaderMap),
|
/freebsd-11-stable/contrib/llvm-project/llvm/include/llvm/Transforms/Utils/ |
H A D | BasicBlockUtils.h | 44 /// instruction. If \p Updates is specified, collect all necessary DT updates 122 DominatorTree *DT; member in struct:llvm::CriticalEdgeSplittingOptions 131 CriticalEdgeSplittingOptions(DominatorTree *DT = nullptr, 135 : DT(DT), PDT(PDT), LI(LI), MSSAU(MSSAU) {} 226 DominatorTree *DT = nullptr, LoopInfo *LI = nullptr, 234 DominatorTree *DT = nullptr, LoopInfo *LI = nullptr, 254 DominatorTree *DT = nullptr, 273 DominatorTree *DT = nullptr, LoopInfo *LI = nullptr, 304 /// Updates DT an [all...] |
H A D | LoopVersioning.h | 42 DominatorTree *DT, ScalarEvolution *SE, 146 DominatorTree *DT; member in class:llvm::LoopVersioning
|
H A D | SSAUpdaterBulk.h | 53 Value *computeValueAt(BasicBlock *BB, RewriteInfo &R, DominatorTree *DT); 81 /// The function requires dominator tree DT, which is used for computing 85 void RewriteAllUses(DominatorTree *DT,
|
H A D | 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, 91 bool formLCSSA(Loop &L, DominatorTree &DT, LoopInfo *LI, ScalarEvolution *SE); 102 bool formLCSSARecursively(Loop &L, DominatorTree &DT, LoopInfo *LI, 146 /// This also updates the relevant analysis information in \p DT, \p SE, and \p 150 void deleteDeadLoop(Loop *L, DominatorTree *DT, ScalarEvolution *SE, 290 bool canSinkOrHoistInst(Instruction &I, AAResults *AA, DominatorTree *DT,
|
/freebsd-11-stable/contrib/llvm-project/llvm/lib/Transforms/Utils/ |
H A D | LoopUnrollRuntime.cpp | 71 ValueToValueMapTy &VMap, DominatorTree *DT, 143 SplitBlockPredecessors(PrologExit, PrologExitPreds, ".unr-lcssa", DT, LI, 162 SplitBlockPredecessors(OriginalLoopLatchExit, Preds, ".unr-lcssa", DT, LI, 167 if (DT) 168 DT->changeImmediateDominator(OriginalLoopLatchExit, PrologExit); 186 ValueToValueMapTy &VMap, DominatorTree *DT, 277 SplitBlockPredecessors(Exit, Preds, ".epilog-lcssa", DT, LI, nullptr, 282 if (DT) 283 DT->changeImmediateDominator(Exit, NewExit); 287 SplitBlockPredecessors(NewExit, NewExitPreds, ".loopexit", DT, L 67 ConnectProlog(Loop *L, Value *BECount, unsigned Count, BasicBlock *PrologExit, BasicBlock *OriginalLoopLatchExit, BasicBlock *PreHeader, BasicBlock *NewPreHeader, ValueToValueMapTy &VMap, DominatorTree *DT, LoopInfo *LI, bool PreserveLCSSA) argument 183 ConnectEpilog(Loop *L, Value *ModVal, BasicBlock *NewExit, BasicBlock *Exit, BasicBlock *PreHeader, BasicBlock *EpilogPreHeader, BasicBlock *NewPreHeader, ValueToValueMapTy &VMap, DominatorTree *DT, LoopInfo *LI, bool PreserveLCSSA) argument 300 CloneLoopBlocks(Loop *L, Value *NewIter, const bool CreateRemainderLoop, const bool UseEpilogRemainder, const bool UnrollRemainder, BasicBlock *InsertTop, BasicBlock *InsertBot, BasicBlock *Preheader, std::vector<BasicBlock *> &NewBlocks, LoopBlocksDFS &LoopBlocks, ValueToValueMapTy &VMap, DominatorTree *DT, LoopInfo *LI) argument 546 UnrollRuntimeLoopRemainder(Loop *L, unsigned Count, bool AllowExpensiveTripCount, bool UseEpilogRemainder, bool UnrollRemainder, bool ForgetAllSCEV, LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT, AssumptionCache *AC, bool PreserveLCSSA, Loop **ResultLoop) argument [all...] |
H A D | LoopUnrollPeel.cpp | 494 ValueToValueMapTy &VMap, ValueToValueMapTy &LVMap, DominatorTree *DT, 517 if (DT) { 519 DT->addNewBlock(NewBB, InsertTop); 521 DomTreeNode *IDom = DT->getNode(*BB)->getIDom(); 523 DT->addNewBlock(NewBB, cast<BasicBlock>(VMap[IDom->getBlock()])); 546 if (DT) 547 DT->changeImmediateDominator(InsertBot, NewLatch); 601 ScalarEvolution *SE, DominatorTree *DT, 616 if (DT) { 639 BasicBlock *BB = DT [all...] |
H A D | SSAUpdaterBulk.cpp | 77 DominatorTree *DT) { 79 if (DT->isReachableFromEntry(BB) && PredCache.get(BB).size()) { 80 BasicBlock *IDom = DT->getNode(BB)->getIDom()->getBlock(); 81 Value *V = computeValueAt(IDom, R, DT); 128 void SSAUpdaterBulk::RewriteAllUses(DominatorTree *DT, 136 ForwardIDFCalculator IDF(*DT); 171 PN->addIncoming(computeValueAt(Pred, R, DT), Pred); 179 Value *V = computeValueAt(getUserBB(U), R, DT);
|
H A D | LoopSimplify.cpp | 123 BasicBlock *llvm::InsertPreheaderForLoop(Loop *L, DominatorTree *DT, argument 147 PreheaderBB = SplitBlockPredecessors(Header, OutsideBlocks, ".preheader", DT, 183 static PHINode *findPHIToPartitionLoops(Loop *L, DominatorTree *DT, argument 189 if (Value *V = SimplifyInstruction(PN, {DL, nullptr, DT, AC})) { 226 DominatorTree *DT, LoopInfo *LI, 237 PHINode *PN = findPHIToPartitionLoops(L, DT, AC); 262 DT, LI, MSSAU, PreserveLCSSA); 293 if (DT->dominates(Header, P)) 325 formDedicatedExitBlocks(L, DT, LI, MSSAU, PreserveLCSSA); 334 formLCSSA(*L, *DT, L 225 separateNestedLoop(Loop *L, BasicBlock *Preheader, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, bool PreserveLCSSA, AssumptionCache *AC, MemorySSAUpdater *MSSAU) argument 349 insertUniqueBackedgeBlock(Loop *L, BasicBlock *Preheader, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU) argument 472 simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, AssumptionCache *AC, MemorySSAUpdater *MSSAU, bool PreserveLCSSA) argument 710 simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, ScalarEvolution *SE, AssumptionCache *AC, MemorySSAUpdater *MSSAU, bool PreserveLCSSA) argument 801 DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); local 836 DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F); local [all...] |
H A D | LibCallsShrinkWrap.cpp | 76 LibCallsShrinkWrap(const TargetLibraryInfo &TLI, DominatorTree *DT) argument 77 : TLI(TLI), DT(DT){}; 130 DominatorTree *DT; member in class:__anon2778::LibCallsShrinkWrap 491 SplitBlockAndInsertIfThen(Cond, CI, false, BranchWeights, DT); 524 DominatorTree *DT) { 527 LibCallsShrinkWrap CCDCE(TLI, DT); 532 assert(!DT || DT->verify(DominatorTree::VerificationLevel::Fast)); 539 auto *DT local 523 runImpl(Function &F, const TargetLibraryInfo &TLI, DominatorTree *DT) argument 554 auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F); local [all...] |
H A D | BasicBlockUtils.cpp | 235 // making the blocks reachable again. Such DT updates lead to high compile 474 BasicBlock *llvm::SplitEdge(BasicBlock *BB, BasicBlock *Succ, DominatorTree *DT, argument 482 CriticalEdgeSplittingOptions(DT, LI, MSSAU).setPreserveLCSSA())) 492 return SplitBlock(Succ, &Succ->front(), DT, LI, MSSAU); 499 return SplitBlock(BB, BB->getTerminator(), DT, LI, MSSAU); 518 DominatorTree *DT, LoopInfo *LI, 533 if (DT) 535 if (DomTreeNode *OldNode = DT->getNode(Old)) { 538 DomTreeNode *NewNode = DT->addNewBlock(New, Old); 540 DT 517 SplitBlock(BasicBlock *Old, Instruction *SplitPt, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, const Twine &BBName) argument 552 UpdateAnalysisInformation(BasicBlock *OldBB, BasicBlock *NewBB, ArrayRef<BasicBlock *> Preds, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, bool PreserveLCSSA, bool &HasLoopExit) argument 709 SplitBlockPredecessors(BasicBlock *BB, ArrayRef<BasicBlock *> Preds, const char *Suffix, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, bool PreserveLCSSA) argument 778 SplitLandingPadPredecessors(BasicBlock *OrigBB, ArrayRef<BasicBlock *> Preds, const char *Suffix1, const char *Suffix2, SmallVectorImpl<BasicBlock *> &NewBBs, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, bool PreserveLCSSA) argument 925 SplitBlockAndInsertIfThen(Value *Cond, Instruction *SplitBefore, bool Unreachable, MDNode *BranchWeights, DominatorTree *DT, LoopInfo *LI, BasicBlock *ThenBlock) argument [all...] |
/freebsd-11-stable/contrib/llvm-project/llvm/lib/Transforms/Scalar/ |
H A D | LoopSimplifyCFG.cpp | 121 DominatorTree &DT; member in class:__anon2708::ConstantTerminatorFoldingImpl 358 Preheader, Preheader->getTerminator(), &DT, &LI, MSSAU); 410 // We need all DT updates to be done before forming LCSSA. 413 MSSAU->applyUpdates(DTUpdates, DT); 415 formLCSSARecursively(*FixLCSSALoop, DT, &LI, &SE); 422 MSSAU->applyUpdates(DTUpdates, DT); 430 /// relevant updates to DT and LI. 526 ConstantTerminatorFoldingImpl(Loop &L, LoopInfo &LI, DominatorTree &DT, argument 529 : L(L), LI(LI), DT(DT), S 625 constantFoldTerminators(Loop &L, DominatorTree &DT, LoopInfo &LI, ScalarEvolution &SE, MemorySSAUpdater *MSSAU, bool &IsLoopDeleted) argument 643 mergeBlocksIntoPredecessors(Loop &L, DominatorTree &DT, LoopInfo &LI, MemorySSAUpdater *MSSAU) argument 674 simplifyLoopCFG(Loop &L, DominatorTree &DT, LoopInfo &LI, ScalarEvolution &SE, MemorySSAUpdater *MSSAU, bool &isLoopDeleted) argument [all...] |
H A D | LoopUnrollAndJamPass.cpp | 155 Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT, 169 L, TTI, DT, LI, SE, EphValues, ORE, OuterTripCount, MaxTripCount, 278 tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI, argument 326 if (!isSafeToUnrollAndJam(L, SE, DT, DI)) { 380 L, SubLoop, TTI, DT, LI, SE, EphValues, &ORE, OuterTripCount, 391 &SE, &DT, &AC, &ORE, &EpilogueOuterLoop); 430 static bool tryToUnrollAndJamLoop(Function &F, DominatorTree &DT, LoopInfo &LI, argument 445 simplifyLoop(L, &DT, &LI, &SE, &AC, nullptr, false /* PreserveLCSSA */); 446 DidSomething |= formLCSSARecursively(*L, DT, &LI, &SE); 453 formLCSSA(*L, DT, 154 computeUnrollAndJamCount( Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI, ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues, OptimizationRemarkEmitter *ORE, unsigned OuterTripCount, unsigned OuterTripMultiple, unsigned OuterLoopSize, unsigned InnerTripCount, unsigned InnerLoopSize, TargetTransformInfo::UnrollingPreferences &UP) argument 529 DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F); local [all...] |
H A D | LoopSink.cpp | 123 DominatorTree &DT, BlockFrequencyInfo &BFI) { 142 if (DT.dominates(ColdestBB, SinkedBB)) 178 LoopInfo &LI, DominatorTree &DT, 201 findBBsToSinkInto(L, BBs, ColdLoopBBs, DT, BFI); 238 replaceDominatedUsesWith(&I, IC, DT, N); 253 DominatorTree &DT, 303 if (!canSinkOrHoistInst(*I, &AA, &DT, &L, &CurAST, nullptr, false)) 305 if (sinkInstruction(L, *I, ColdLoopBBs, LoopBlockNumber, LI, DT, BFI)) 321 DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F); local 338 Changed |= sinkLoopInvariantInstructions(L, AA, LI, DT, BF 121 findBBsToSinkInto(const Loop &L, const SmallPtrSetImpl<BasicBlock *> &UseBBs, const SmallVectorImpl<BasicBlock *> &ColdLoopBBs, DominatorTree &DT, BlockFrequencyInfo &BFI) argument 175 sinkInstruction(Loop &L, Instruction &I, const SmallVectorImpl<BasicBlock *> &ColdLoopBBs, const SmallDenseMap<BasicBlock *, int, 16> &LoopBlockNumber, LoopInfo &LI, DominatorTree &DT, BlockFrequencyInfo &BFI) argument 252 sinkLoopInvariantInstructions(Loop &L, AAResults &AA, LoopInfo &LI, DominatorTree &DT, BlockFrequencyInfo &BFI, ScalarEvolution *SE) argument [all...] |
H A D | PlaceSafepoints.cpp | 114 DominatorTree *DT = nullptr; member in struct:__anon2743::PlaceBackedgeSafepointsImpl 133 DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); 201 DominatorTree &DT, 213 assert(DT.dominates(Header, Pred) && "loop latch not dominated by header?"); 231 Current = DT.getNode(Current)->getIDom()->getBlock(); 329 containsUnconditionalCallSafepoint(L, Header, Pred, *DT, *TLI)) { 385 DominatorTree &DT) { 496 DominatorTree DT; local 497 DT.recalculate(F); 515 DT 199 containsUnconditionalCallSafepoint(Loop *L, BasicBlock *Header, BasicBlock *Pred, DominatorTree &DT, const TargetLibraryInfo &TLI) argument 384 findLocationForEntrySafepoint(Function &F, DominatorTree &DT) argument [all...] |
H A D | SimpleLoopUnswitch.cpp | 267 DominatorTree &DT, LoopInfo &LI, 322 formLCSSA(*OldContainingL, DT, &LI, SE); 329 formDedicatedExitBlocks(OldContainingL, &DT, &LI, MSSAU, 365 static bool unswitchTrivialBranch(Loop &L, BranchInst &BI, DominatorTree &DT, argument 449 BasicBlock *NewPH = SplitEdge(OldPH, L.getHeader(), &DT, &LI, MSSAU); 462 SplitBlock(LoopExitBB, &LoopExitBB->front(), &DT, &LI, MSSAU); 505 DT.insertEdge(OldPH, UnswitchedBB); 512 MSSAU->applyInsertUpdates(Updates, DT); 524 DT.deleteEdge(ParentBB, LoopExitBB); 552 hoistLoopToNewParent(L, *NewPH, DT, L 266 hoistLoopToNewParent(Loop &L, BasicBlock &Preheader, DominatorTree &DT, LoopInfo &LI, MemorySSAUpdater *MSSAU, ScalarEvolution *SE) argument 589 unswitchTrivialSwitch(Loop &L, SwitchInst &SI, DominatorTree &DT, LoopInfo &LI, ScalarEvolution *SE, MemorySSAUpdater *MSSAU) argument 868 unswitchAllTrivialConditions(Loop &L, DominatorTree &DT, LoopInfo &LI, ScalarEvolution *SE, MemorySSAUpdater *MSSAU) argument 986 buildClonedLoopBlocks( Loop &L, BasicBlock *LoopPH, BasicBlock *SplitBB, ArrayRef<BasicBlock *> ExitBlocks, BasicBlock *ParentBB, BasicBlock *UnswitchedSuccBB, BasicBlock *ContinueSuccBB, const SmallDenseMap<BasicBlock *, BasicBlock *, 16> &DominatingSucc, ValueToValueMapTy &VMap, SmallVectorImpl<DominatorTree::UpdateType> &DTUpdates, AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI, MemorySSAUpdater *MSSAU) argument 1467 deleteDeadClonedBlocks(Loop &L, ArrayRef<BasicBlock *> ExitBlocks, ArrayRef<std::unique_ptr<ValueToValueMapTy>> VMaps, DominatorTree &DT, MemorySSAUpdater *MSSAU) argument 1496 deleteDeadBlocksFromLoop(Loop &L, SmallVectorImpl<BasicBlock *> &ExitBlocks, DominatorTree &DT, LoopInfo &LI, MemorySSAUpdater *MSSAU) argument 1895 visitDomSubTree(DominatorTree &DT, BasicBlock *BB, CallableT Callable) argument 1918 unswitchNontrivialInvariants( Loop &L, Instruction &TI, ArrayRef<Value *> Invariants, SmallVectorImpl<BasicBlock *> &ExitBlocks, DominatorTree &DT, LoopInfo &LI, AssumptionCache &AC, function_ref<void(bool, ArrayRef<Loop *>)> UnswitchCB, ScalarEvolution *SE, MemorySSAUpdater *MSSAU) argument 2392 turnGuardIntoBranch(IntrinsicInst *GI, Loop &L, SmallVectorImpl<BasicBlock *> &ExitBlocks, DominatorTree &DT, LoopInfo &LI, MemorySSAUpdater *MSSAU) argument 2468 calculateUnswitchCostMultiplier( Instruction &TI, Loop &L, LoopInfo &LI, DominatorTree &DT, ArrayRef<std::pair<Instruction *, TinyPtrVector<Value *>>> UnswitchCandidates) argument 2541 unswitchBestCondition(Loop &L, DominatorTree &DT, LoopInfo &LI, AssumptionCache &AC, TargetTransformInfo &TTI, function_ref<void(bool, ArrayRef<Loop *>)> UnswitchCB, ScalarEvolution *SE, MemorySSAUpdater *MSSAU) argument 2818 unswitchLoop(Loop &L, DominatorTree &DT, LoopInfo &LI, AssumptionCache &AC, TargetTransformInfo &TTI, bool NonTrivial, function_ref<void(bool, ArrayRef<Loop *>)> UnswitchCB, ScalarEvolution *SE, MemorySSAUpdater *MSSAU) argument 2948 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); local [all...] |
H A D | DivRemPairs.cpp | 181 const DominatorTree &DT) { 233 bool DivDominates = DT.dominates(DivInst, RemInst); 234 if (!DivDominates && !DT.dominates(RemInst, DivInst)) { 343 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); variable 344 return optimizeDivRem(F, TTI, DT); 364 DominatorTree &DT = FAM.getResult<DominatorTreeAnalysis>(F); local 365 if (!optimizeDivRem(F, TTI, DT)) 180 optimizeDivRem(Function &F, const TargetTransformInfo &TTI, const DominatorTree &DT) argument
|
/freebsd-11-stable/contrib/llvm-project/clang/lib/Lex/ |
H A D | PPExpressions.cpp | 100 static bool EvaluateDefined(PPValue &Result, Token &PeekTok, DefinedTracker &DT, argument 132 DT.IncludedUndefinedIds = !Macro; 214 DT.State = DefinedTracker::DefinedMacro; 215 DT.TheMacro = II; 222 /// expression in DT. See above for information on what DT means. 227 static bool EvaluateValue(PPValue &Result, Token &PeekTok, DefinedTracker &DT, argument 229 DT.State = DefinedTracker::Unknown; 248 return EvaluateDefined(Result, PeekTok, DT, ValueLive, PP); 260 DT 583 DefinedTracker DT; local 778 DefinedTracker DT; local 843 DefinedTracker DT; local [all...] |
/freebsd-11-stable/contrib/llvm-project/llvm/lib/Transforms/Instrumentation/ |
H A D | PGOMemOPSizeOpt.cpp | 139 OptimizationRemarkEmitter &ORE, DominatorTree *DT) 140 : Func(Func), BFI(BFI), ORE(ORE), DT(DT), Changed(false) { 176 DominatorTree *DT; member in class:__anon2641::MemOPSizeOpt 343 BasicBlock *DefaultBB = SplitBlock(BB, MI, DT); 347 BasicBlock *MergeBB = SplitBlock(DefaultBB, &(*It), DT); 352 DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Eager); 370 if (DT) 387 if (DT) { 417 DominatorTree *DT) { 138 MemOPSizeOpt(Function &Func, BlockFrequencyInfo &BFI, OptimizationRemarkEmitter &ORE, DominatorTree *DT) argument 415 PGOMemOPSizeOptImpl(Function &F, BlockFrequencyInfo &BFI, OptimizationRemarkEmitter &ORE, DominatorTree *DT) argument 433 DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr; local 444 auto *DT = FAM.getCachedResult<DominatorTreeAnalysis>(F); local [all...] |
/freebsd-11-stable/contrib/llvm-project/llvm/lib/IR/ |
H A D | SafepointIRVerifier.cpp | 71 const DominatorTree *DT = nullptr; member in class:__anon1905::CFGDeadness 126 void processFunction(const Function &F, const DominatorTree &DT) { argument 127 this->DT = &DT; 131 if (!DT.isReachableFromEntry(&BB)) 171 DT->getDescendants(const_cast<BasicBlock*>(D), Dom); 198 static void Verify(const Function &F, const DominatorTree &DT, 204 const auto &DT = AM.getResult<DominatorTreeAnalysis>(F); local 206 CD.processFunction(F, DT); 207 Verify(F, DT, C 221 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); variable 537 GCPtrTracker(const Function &F, const DominatorTree &DT, const CFGDeadness &CD) argument 734 gatherDominatingDefs(const BasicBlock *BB, AvailableValueSet &Result, const DominatorTree &DT) argument 884 Verify(const Function &F, const DominatorTree &DT, const CFGDeadness &CD) argument [all...] |
/freebsd-11-stable/contrib/llvm-project/llvm/lib/Analysis/ |
H A D | MustExecute.cpp | 117 const DominatorTree *DT, 146 DT, /*AC*/ nullptr, BI}); 191 const DominatorTree *DT) const { 217 if (DT->dominates(BB, Pred)) 238 !CanProveNotTakenFirstIteration(Succ, DT, CurLoop)) 249 const DominatorTree *DT, 264 return allLoopPathsLeadToBlock(CurLoop, Inst.getParent(), DT); 268 const DominatorTree *DT, 271 allLoopPathsLeadToBlock(CurLoop, Inst.getParent(), DT); 365 DominatorTree *DT 116 CanProveNotTakenFirstIteration(const BasicBlock *ExitBlock, const DominatorTree *DT, const Loop *CurLoop) argument 248 isGuaranteedToExecute(const Instruction &Inst, const DominatorTree *DT, const Loop *CurLoop) const argument 267 isGuaranteedToExecute(const Instruction &Inst, const DominatorTree *DT, const Loop *CurLoop) const argument 392 isMustExecuteIn(const Instruction &I, Loop *L, DominatorTree *DT) argument 409 MustExecuteAnnotatedWriter(const Function &F, DominatorTree &DT, LoopInfo &LI) argument 421 MustExecuteAnnotatedWriter(const Module &M, DominatorTree &DT, LoopInfo &LI) argument 461 auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); local [all...] |
H A D | IVUsers.cpp | 42 return IVUsers(&L, &AR.AC, &AR.LI, &AR.DT, &AR.SE); 95 static bool isSimplifiedLoopNest(BasicBlock *BB, const DominatorTree *DT, argument 99 for (DomTreeNode *Rung = DT->getNode(BB); 130 const Loop *L, DominatorTree *DT) { 141 if (DT->dominates(LatchBlock, User->getParent())) 157 !DT->dominates(LatchBlock, PN->getIncomingBlock(i))) 225 if (!isSimplifiedLoopNest(UseBB, DT, LI, SimpleLoopNests)) 258 bool Result = IVUseShouldUsePostIncValue(User, I, L, DT); 305 IVUsers::IVUsers(Loop *L, AssumptionCache *AC, LoopInfo *LI, DominatorTree *DT, argument 307 : L(L), AC(AC), LI(LI), DT(D 129 IVUseShouldUsePostIncValue(Instruction *User, Value *Operand, const Loop *L, DominatorTree *DT) argument 370 auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); local [all...] |