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

Declarations

include/llvm/Support/GenericDomTree.h

  378   bool properlyDominates(const NodeT *A, const NodeT *B) const;

References

include/llvm/Analysis/RegionInfoImpl.h

  612     if (DT->properlyDominates(entry, Succ) && Succ != exit)

include/llvm/CodeGen/MachineDominators.h

  154     return DT->properlyDominates(A, B);

include/llvm/CodeGen/MachinePostDominators.h

   68     return PDT->properlyDominates(A, B);

lib/Analysis/LegacyDivergenceAnalysis.cpp

  242   assert(PDT.properlyDominates(End, Start) &&

lib/Analysis/ScalarEvolution.cpp

 9145          return DT.properlyDominates(L1->getHeader(), L2->getHeader());
11824       if (DT.properlyDominates(I->getParent(), BB))

lib/Analysis/ScalarEvolutionExpander.cpp

 1179         SE.DT.properlyDominates(LatchBlock, IVIncInsertLoop->getHeader());
 1271          SE.DT.properlyDominates(cast<Instruction>(StartV)->getParent(),

lib/Target/Hexagon/HexagonCommonGEP.cpp

  844   return DT->properlyDominates(DefB, HdrB);

lib/Transforms/Scalar/GVN.cpp

  440       if (NonLocalDepCall && DT->properlyDominates(I->getBB(), C->getParent())){
  736       gvn.getDominatorTree().properlyDominates(ValuesPerBlock[0].BB,

lib/Transforms/Scalar/GVNHoist.cpp

  530     if (DT->properlyDominates(NewBB, DBB))
  548       if (DT->properlyDominates(DBB, NewBB))
  650               DT->properlyDominates(Pred, si->second.back()->getParent())) {
  797           if (DT->properlyDominates(IDFB, V[i]->getParent())) {

lib/Transforms/Scalar/IndVarSimplify.cpp

 2727                if (DT->properlyDominates(A, B)) return true;
 2728                if (DT->properlyDominates(B, A)) return false;
 2882               if (DT->properlyDominates(A, B)) return true;
 2883               if (DT->properlyDominates(B, A)) return false;

lib/Transforms/Scalar/LICM.cpp

 1022         DT->properlyDominates(II->getParent(), CurLoop->getHeader()))

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2425             !DT.properlyDominates(UI->getUser()->getParent(), ExitingBlock)) {

lib/Transforms/Scalar/NewGVN.cpp

 2595   if (DT->properlyDominates(getBlockForValue(V), PHIBlock)) {

lib/Transforms/Utils/Local.cpp

 2510     return DT.properlyDominates(BB, I);

lib/Transforms/Vectorize/LoopVectorize.cpp

 4348   assert(DT->properlyDominates(LoopBypassBlocks.front(), LoopExitBlock) &&

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

  144     return DT.properlyDominates(A, B);

unittests/IR/DominatorTreeTest.cpp

  136         EXPECT_FALSE(DT->properlyDominates(BB0, BB0));
  137         EXPECT_TRUE(DT->properlyDominates(BB0, BB1));
  138         EXPECT_TRUE(DT->properlyDominates(BB0, BB2));
  139         EXPECT_TRUE(DT->properlyDominates(BB0, BB3));
  141         EXPECT_FALSE(DT->properlyDominates(BB1, BB0));
  142         EXPECT_FALSE(DT->properlyDominates(BB1, BB1));
  143         EXPECT_FALSE(DT->properlyDominates(BB1, BB2));
  144         EXPECT_TRUE(DT->properlyDominates(BB1, BB3));
  146         EXPECT_FALSE(DT->properlyDominates(BB2, BB0));
  147         EXPECT_FALSE(DT->properlyDominates(BB2, BB1));
  148         EXPECT_FALSE(DT->properlyDominates(BB2, BB2));
  149         EXPECT_TRUE(DT->properlyDominates(BB2, BB3));
  151         EXPECT_FALSE(DT->properlyDominates(BB3, BB0));
  152         EXPECT_FALSE(DT->properlyDominates(BB3, BB1));
  153         EXPECT_FALSE(DT->properlyDominates(BB3, BB2));
  154         EXPECT_FALSE(DT->properlyDominates(BB3, BB3));

unittests/Transforms/Vectorize/VPlanDominatorTreeTest.cpp

  109   EXPECT_FALSE(VPDT.properlyDominates(PH, PH));
  110   EXPECT_TRUE(VPDT.properlyDominates(PH, H));
  111   EXPECT_TRUE(VPDT.properlyDominates(PH, IfThen));
  112   EXPECT_TRUE(VPDT.properlyDominates(PH, IfElse));
  113   EXPECT_TRUE(VPDT.properlyDominates(PH, Latch));
  114   EXPECT_TRUE(VPDT.properlyDominates(PH, Exit));
  116   EXPECT_FALSE(VPDT.properlyDominates(H, PH));
  117   EXPECT_FALSE(VPDT.properlyDominates(H, H));
  118   EXPECT_TRUE(VPDT.properlyDominates(H, IfThen));
  119   EXPECT_TRUE(VPDT.properlyDominates(H, IfElse));
  120   EXPECT_TRUE(VPDT.properlyDominates(H, Latch));
  121   EXPECT_TRUE(VPDT.properlyDominates(H, Exit));
  123   EXPECT_FALSE(VPDT.properlyDominates(IfThen, PH));
  124   EXPECT_FALSE(VPDT.properlyDominates(IfThen, H));
  125   EXPECT_FALSE(VPDT.properlyDominates(IfThen, IfThen));
  126   EXPECT_FALSE(VPDT.properlyDominates(IfThen, IfElse));
  127   EXPECT_FALSE(VPDT.properlyDominates(IfThen, Latch));
  128   EXPECT_FALSE(VPDT.properlyDominates(IfThen, Exit));
  130   EXPECT_FALSE(VPDT.properlyDominates(IfElse, PH));
  131   EXPECT_FALSE(VPDT.properlyDominates(IfElse, H));
  132   EXPECT_FALSE(VPDT.properlyDominates(IfElse, IfThen));
  133   EXPECT_FALSE(VPDT.properlyDominates(IfElse, IfElse));
  134   EXPECT_FALSE(VPDT.properlyDominates(IfElse, Latch));
  135   EXPECT_FALSE(VPDT.properlyDominates(IfElse, Exit));
  137   EXPECT_FALSE(VPDT.properlyDominates(Latch, PH));
  138   EXPECT_FALSE(VPDT.properlyDominates(Latch, H));
  139   EXPECT_FALSE(VPDT.properlyDominates(Latch, IfThen));
  140   EXPECT_FALSE(VPDT.properlyDominates(Latch, IfElse));
  141   EXPECT_FALSE(VPDT.properlyDominates(Latch, Latch));
  142   EXPECT_TRUE(VPDT.properlyDominates(Latch, Exit));
  144   EXPECT_FALSE(VPDT.properlyDominates(Exit, PH));
  145   EXPECT_FALSE(VPDT.properlyDominates(Exit, H));
  146   EXPECT_FALSE(VPDT.properlyDominates(Exit, IfThen));
  147   EXPECT_FALSE(VPDT.properlyDominates(Exit, IfElse));
  148   EXPECT_FALSE(VPDT.properlyDominates(Exit, Latch));
  149   EXPECT_FALSE(VPDT.properlyDominates(Exit, Exit));