reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/Analysis/MemorySSA.h

  824     renamePass(DT->getNode(BB), IncomingVal, Visited, true, true);

include/llvm/Analysis/RegionInfoImpl.h

  107   if (!DT->getNode(BB))
  169     if (DT->getNode(Pred) && !contains(Pred)) {
  646   return PDT->getNode(e->second)->getIDom();
  689   DomTreeNodeT *N = PDT->getNode(entry);
  730   DomTreeNodeT *N = DT->getNode(entry);
  924   buildRegionsTree(DT->getNode(BB), TopLevelRegion);

include/llvm/CodeGen/MachineDominators.h

  167     return DT->getNode(BB);
  175     return DT->getNode(BB);

include/llvm/CodeGen/MachinePostDominators.h

   45     return PDT->getNode(BB);
   49     return PDT->getNode(BB);

include/llvm/Support/GenericDomTree.h

  337     return getNode(BB);
  353     const DomTreeNodeBase<NodeT> *RN = getNode(R);
  385     return isReachableFromEntry(getNode(const_cast<NodeT *>(A)));
  458     DomTreeNodeBase<NodeT> *NodeA = getNode(A);
  459     DomTreeNodeBase<NodeT> *NodeB = getNode(B);
  569     assert(getNode(BB) == nullptr && "Block already in dominator tree!");
  570     DomTreeNodeBase<NodeT> *IDomNode = getNode(DomBB);
  583     assert(getNode(BB) == nullptr && "Block already in dominator tree!");
  614     changeImmediateDominator(getNode(BB), getNode(NewBB));
  614     changeImmediateDominator(getNode(BB), getNode(NewBB));
  621     DomTreeNodeBase<NodeT> *Node = getNode(BB);
  821       DomTreeNodeBase<NodeT> *NewBBSuccNode = getNode(NewBBSucc);
  872   return dominates(getNode(const_cast<NodeT *>(A)),
  873                    getNode(const_cast<NodeT *>(B)));
  884   return dominates(getNode(const_cast<NodeT *>(A)),
  885                    getNode(const_cast<NodeT *>(B)));

include/llvm/Support/GenericDomTreeConstruction.h

  177     if (TreeNodePtr Node = DT.getNode(BB)) return Node;
  325         const TreeNodePtr TN = DT.getNode(N);
  622       const TreeNodePtr TN = DT.getNode(N);
  624       const TreeNodePtr NewIDom = DT.getNode(NodeToInfo[N].IDom);
  656     TreeNodePtr FromTN = DT.getNode(From);
  663       TreeNodePtr VirtualRoot = DT.getNode(nullptr);
  673     const TreeNodePtr ToTN = DT.getNode(To);
  754     const TreeNodePtr NCD = DT.getNode(NCDBlock);
  800           const TreeNodePtr SuccTN = DT.getNode(Succ);
  888       InsertReachable(DT, BUI, DT.getNode(Edge.first), Edge.second);
  898     assert(!DT.getNode(Root) && "Root must not be reachable");
  903       const TreeNodePtr ToTN = DT.getNode(To);
  936     const TreeNodePtr FromTN = DT.getNode(From);
  940     const TreeNodePtr ToTN = DT.getNode(To);
  949     const TreeNodePtr NCD = DT.getNode(NCDBlock);
  983     const TreeNodePtr ToIDomTN = DT.getNode(ToIDom);
  997       return DT.getNode(To)->getLevel() > Level;
 1019       if (!DT.getNode(Pred)) continue;
 1052       InsertReachable(DT, BUI, DT.getNode(nullptr), ToTN);
 1062       const TreeNodePtr TN = DT.getNode(To);
 1080       const TreeNodePtr TN = DT.getNode(N);
 1084       const TreeNodePtr NCD = DT.getNode(NCDBlock);
 1104       const TreeNodePtr TN = DT.getNode(N);
 1122       const TreeNodePtr ToTN = DT.getNode(To);
 1324       if (N && !DT.getNode(N)) {
 1376     const TreeNodePtr Root = DT.getNode(RootBB);

include/llvm/Support/GenericIteratedDominanceFrontier.h

  148     if (DomTreeNodeBase<NodeTy> *Node = DT.getNode(BB))
  177         DomTreeNodeBase<NodeTy> *SuccNode = DT.getNode(Succ);

lib/Analysis/DomTreeUpdater.cpp

  207     if (DT->getNode(DelBB))
  211     if (PDT->getNode(DelBB))

lib/Analysis/IVUsers.cpp

   98   for (DomTreeNode *Rung = DT->getNode(BB);

lib/Analysis/LegacyDivergenceAnalysis.cpp

  162   DomTreeNode *ThisNode = PDT.getNode(ThisBB);
  208     DomTreeNode *IDomNode = DT.getNode(InfluencedBB)->getIDom();

lib/Analysis/MemorySSA.cpp

  530     DomTreeNode *Node = DT.getNode(BB);

lib/Analysis/MemorySSAUpdater.cpp

  845         if (!DT.getNode(BB))
  847         if (auto *IDom = DT.getNode(BB)->getIDom())
  857         if (!DT.getNode(BB))
  886                    DT.getNode(NextIDom)->getIDom()->getBlock()) {
 1034     assert(DT.getNode(BB)->getIDom() && "BB does not have valid idom");
 1037     BasicBlock *NewIDom = DT.getNode(BB)->getIDom()->getBlock();
 1110                 auto *IDom = DT.getNode(DominatedBlock)->getIDom();

lib/Analysis/OrderedInstructions.cpp

   47   DomTreeNode *DA = DT->getNode(InstA->getParent());
   48   DomTreeNode *DB = DT->getNode(InstB->getParent());

lib/CodeGen/InlineSpiller.cpp

 1207     MachineDomTreeNode *Node = MDT.getBase().getNode(Block);
 1215       SpillBBToSpill[MDT.getBase().getNode(Block)] = SpillToKeep;
 1217       SpillBBToSpill[MDT.getBase().getNode(Block)] = CurrentSpill;
 1291   Orders.push_back(MDT.getBase().getNode(Root));

lib/CodeGen/MachineDominators.cpp

  103     MachineDomTreeNode *SuccDTNode = DT->getNode(Succ);
  126       if (!DT->dominates(SuccDTNode, DT->getNode(PredBB))) {
  144       DT->changeImmediateDominator(DT->getNode(Edge.ToBB), NewDTNode);

lib/CodeGen/MachinePostDominators.cpp

   59     if (PDT->isVirtualRoot(PDT->getNode(NCD)))

lib/Target/AMDGPU/SIAnnotateControlFlow.cpp

  185   BasicBlock *IDom = DT->getNode(Phi->getParent())->getIDom()->getBlock();

lib/Target/Hexagon/HexagonCommonGEP.cpp

  329   for (auto *DTN : children<DomTreeNode*>(DT->getNode(Root)))
  870   DomTreeNode *DN = DT->getNode(L->getHeader());
 1250     for (auto DTN : children<DomTreeNode*>(DT->getNode(B)))

lib/Target/Hexagon/HexagonGenExtract.cpp

  223   for (auto *DTN : children<DomTreeNode*>(DT->getNode(B)))

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 2241       DomTreeNode *BN = DT->getNode(ExitB);
 2242       DomTreeNode *DN = DT->getNode(ExitD);

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

  564     assert(DT.getNode(I->getParent()) && "DT must contain I's parent block");
  565     assert(DT.getNode(InsertPoint->getParent()) && "DT must contain Destination");
 1473     assert(DT.getNode(I->getParent()) && "DT must contain I's block");
 1474     assert(DT.getNode(HoistPoint->getParent()) &&

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 1254     if (DomTreeNode *OldNode = DT.getNode(Head)) {

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  660               InsertBB = DT->getNode(InsertBB)->getIDom()->getBlock();

lib/Transforms/Scalar/CallSiteSplitting.cpp

  471   auto *CSDTNode = DTU.getDomTree().getNode(CS.getInstruction()->getParent());

lib/Transforms/Scalar/ConstantHoisting.cpp

  193   auto IDom = DT->getNode(Inst->getParent())->getIDom();
  231       assert(DT.getNode(Node)->getIDom() &&
  233       Node = DT.getNode(Node)->getIDom()->getBlock();
  252     for (auto ChildDomNode : DT.getNode(Node)->getChildren()) {
  283     BasicBlock *Parent = DT.getNode(Node)->getIDom()->getBlock();

lib/Transforms/Scalar/GVNHoist.cpp

  671     auto Root = PDT->getNode(nullptr);

lib/Transforms/Scalar/GuardWidening.cpp

  838                          AR.DT.getNode(RootBB),
  902                              DT.getNode(RootBB), BlockFilter).run();

lib/Transforms/Scalar/LICM.cpp

  389     Changed |= sinkRegion(DT->getNode(L->getHeader()), AA, LI, DT, TLI, TTI, L,
  393     Changed |= hoistRegion(DT->getNode(L->getHeader()), AA, LI, DT, TLI, L,
  767       DomTreeNode *PreheaderNode = DT->getNode(HoistCommonSucc);
  768       DomTreeNode *HeaderNode = DT->getNode(CurLoop->getHeader());
  945             DT->getNode(I->getParent())->getIDom()->getBlock();

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 3043   for (DomTreeNode *Rung = DT.getNode(L->getLoopLatch());
 5040     for (DomTreeNode *Rung = DT.getNode(IP->getParent()); ; ) {
 5539   for (DomTreeNode *Rung = DT.getNode(L->getLoopPreheader());

lib/Transforms/Scalar/LoopUnswitch.cpp

  560   auto *Node = DT->getNode(BB)->getIDom();
  565     Node = DT->getNode(DomBB)->getIDom();

lib/Transforms/Scalar/NewGVN.cpp

  894          RPOOrdering.lookup(DT->getNode(From)) >=
  895              RPOOrdering.lookup(DT->getNode(To));
 3428     auto *Node = DT->getNode(B);
 3434     auto *Node = DT->getNode(B);
 3570     DomTreeNode *DomNode = DT->getNode(BB);
 3629         DomTreeNode *DomNode = DT->getNode(IBlock);
 3659     DomTreeNode *DomNode = DT->getNode(BB);

lib/Transforms/Scalar/PlaceSafepoints.cpp

  230     Current = DT.getNode(Current)->getIDom()->getBlock();

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

 1541     assert(!DT.getNode(BB) && "Should already have cleared domtree!");

lib/Transforms/Scalar/Sink.cpp

  167   DomTreeNode *DTN = DT.getNode(Inst->getParent());

lib/Transforms/Utils/BasicBlockUtils.cpp

  420     if (DomTreeNode *OldNode = DT->getNode(Old)) {
  837     if (DomTreeNode *OldNode = DT->getNode(Head)) {

lib/Transforms/Utils/CloneFunction.cpp

  819     BasicBlock *IDomBB = DT->getNode(BB)->getIDom()->getBlock();

lib/Transforms/Utils/CodeExtractor.cpp

  752         DomTreeNode *OldNode = DT->getNode(Block);

lib/Transforms/Utils/LCSSA.cpp

  128     DomTreeNode *DomNode = DT.getNode(DomBB);
  140       if (!DT.dominates(DomNode, DT.getNode(ExitBB)))
  294     BasicBlock *IDomBB = DT.getNode(BB)->getIDom()->getBlock();

lib/Transforms/Utils/LoopSimplify.cpp

  675       DomTreeNode *Node = DT->getNode(ExitingBlock);

lib/Transforms/Utils/LoopUnroll.cpp

  674           auto BBDomNode = DT->getNode(*BB);
  830       auto *BBDomNode = DT->getNode(BB);

lib/Transforms/Utils/LoopUnrollAndJam.cpp

  370         auto BBDomNode = DT->getNode(*BB);

lib/Transforms/Utils/LoopUnrollPeel.cpp

  499         DomTreeNode *IDom = DT->getNode(*BB)->getIDom();
  618           DT->getNode(Edge.second)->getIDom()->getBlock(), Latch);

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  342         BasicBlock *IDomBB = DT->getNode(*BB)->getIDom()->getBlock();
  850       auto *DomNodeBB = DT->getNode(BB);

lib/Transforms/Utils/PredicateInfo.cpp

  179     DomTreeNode *DomASrc = DT.getNode(ASrc);
  180     DomTreeNode *DomBSrc = DT.getNode(BSrc);
  192     DomTreeNode *DomADest = DT.getNode(ADest);
  193     DomTreeNode *DomBDest = DT.getNode(BDest);
  309       DomTreeNode *DomNode = DT.getNode(IBlock);
  620         DomTreeNode *DomNode = DT.getNode(PAssume->AssumeInst->getParent());
  634           auto *DomNode = DT.getNode(BlockEdge.first);
  647           auto *DomNode = DT.getNode(BlockEdge.second);

lib/Transforms/Utils/SSAUpdaterBulk.cpp

   80       BasicBlock *IDom = DT->getNode(BB)->getIDom()->getBlock();

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4427     if (DomTreeNode *N = DT->getNode(BB)) {

tools/clang/include/clang/Analysis/Analyses/Dominators.h

  104       DomTreeNode *IDom = DT.getNode(*I)->getIDom();

tools/polly/lib/CodeGen/BlockGenerators.cpp

 1403   BasicBlock *BBIDom = DT.getNode(BB)->getIDom()->getBlock();

tools/polly/lib/CodeGen/IslNodeBuilder.cpp

  604   DomTreeNode *N = DT.getNode(&F->getEntryBlock());

unittests/IR/DominatorTreeTest.cpp

  224         EXPECT_EQ(DT->getNode(BB0)->getDFSNumIn(), 0UL);
  225         EXPECT_EQ(DT->getNode(BB0)->getDFSNumOut(), 7UL);
  226         EXPECT_EQ(DT->getNode(BB1)->getDFSNumIn(), 1UL);
  227         EXPECT_EQ(DT->getNode(BB1)->getDFSNumOut(), 2UL);
  228         EXPECT_EQ(DT->getNode(BB2)->getDFSNumIn(), 5UL);
  229         EXPECT_EQ(DT->getNode(BB2)->getDFSNumOut(), 6UL);
  230         EXPECT_EQ(DT->getNode(BB4)->getDFSNumIn(), 3UL);
  231         EXPECT_EQ(DT->getNode(BB4)->getDFSNumOut(), 4UL);
  234         EXPECT_EQ(DT->getNode(BB0)->getLevel(), 0U);
  235         EXPECT_EQ(DT->getNode(BB1)->getLevel(), 1U);
  236         EXPECT_EQ(DT->getNode(BB2)->getLevel(), 1U);
  237         EXPECT_EQ(DT->getNode(BB4)->getLevel(), 1U);
  246         EXPECT_EQ(DT->getNode(BB0)->getDFSNumIn(), 0UL);
  247         EXPECT_EQ(DT->getNode(BB0)->getDFSNumOut(), 9UL);
  248         EXPECT_EQ(DT->getNode(BB1)->getDFSNumIn(), 1UL);
  249         EXPECT_EQ(DT->getNode(BB1)->getDFSNumOut(), 4UL);
  250         EXPECT_EQ(DT->getNode(BB2)->getDFSNumIn(), 7UL);
  251         EXPECT_EQ(DT->getNode(BB2)->getDFSNumOut(), 8UL);
  252         EXPECT_EQ(DT->getNode(BB3)->getDFSNumIn(), 2UL);
  253         EXPECT_EQ(DT->getNode(BB3)->getDFSNumOut(), 3UL);
  254         EXPECT_EQ(DT->getNode(BB4)->getDFSNumIn(), 5UL);
  255         EXPECT_EQ(DT->getNode(BB4)->getDFSNumOut(), 6UL);
  258         EXPECT_EQ(DT->getNode(BB0)->getLevel(), 0U);
  259         EXPECT_EQ(DT->getNode(BB1)->getLevel(), 1U);
  260         EXPECT_EQ(DT->getNode(BB2)->getLevel(), 1U);
  261         EXPECT_EQ(DT->getNode(BB3)->getLevel(), 2U);
  262         EXPECT_EQ(DT->getNode(BB4)->getLevel(), 1U);
  388         ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  388         ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  401         EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  401         EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  402         EXPECT_NE(PDT->getNode(C), nullptr);
  482         ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  482         ASSERT_TRUE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  493         EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  493         EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  494         EXPECT_NE(PDT->getNode(C), nullptr);
  581         EXPECT_EQ(DT->getNode(C2), nullptr);
  588         EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  588         EXPECT_FALSE(PDT->dominates(PDT->getNode(D), PDT->getNode(B)));
  589         EXPECT_NE(PDT->getNode(C), nullptr);
  660         EXPECT_EQ(DT->getNode(A)->getDFSNumIn(), 0UL);
  663         EXPECT_TRUE(DT->getNode(IDFBlocks[0])->getDFSNumIn() <
  664                     DT->getNode(IDFBlocks[1])->getDFSNumIn());
  780   EXPECT_NE(PDT.getNode(BB5), nullptr);