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

Declarations

include/llvm/Analysis/LoopInfo.h

  310   BlockT *getLoopLatch() const;

References

include/llvm/Analysis/LoopInfoImpl.h

  124   const BlockT *Latch = getLoopLatch();

lib/Analysis/IVDescriptors.cpp

  683   auto *Latch = TheLoop->getLoopLatch();
  946   BasicBlock *Latch = L->getLoopLatch();
 1058   BasicBlock *Latch = AR->getLoop()->getLoopLatch();

lib/Analysis/IVUsers.cpp

  134   BasicBlock *LatchBlock = L->getLoopLatch();

lib/Analysis/LoopAccessAnalysis.cpp

 1769   if (TheLoop->getExitingBlock() != TheLoop->getLoopLatch()) {
 2083   BasicBlock* Latch = TheLoop->getLoopLatch();

lib/Analysis/LoopInfo.cpp

  171   if (BasicBlock *Latch = L.getLoopLatch())
  229   BasicBlock *Latch = L.getLoopLatch();
  367   BasicBlock *Latch = getLoopLatch();
  467   return getLoopPreheader() && getLoopLatch() && hasDedicatedExits();

lib/Analysis/ScalarEvolution.cpp

 4328     if (BasicBlock *Latch = L->getLoopLatch()) {
 6066   auto *LatchBB = L->getLoopLatch();
 6899   const BasicBlock *Latch = L->getLoopLatch();
 7068   BasicBlock *Latch = L->getLoopLatch(); // may be NULL.
 7135   const BasicBlock *Latch = L->getLoopLatch();
 7572   const BasicBlock *Latch = L->getLoopLatch();
 7891   BasicBlock *Latch = L->getLoopLatch();
 7971   BasicBlock *Latch = L->getLoopLatch();
 9467   BasicBlock *Latch = L->getLoopLatch();
10092     auto *Latch = RLoop->getLoopLatch();

lib/Analysis/ScalarEvolutionExpander.cpp

 1168   BasicBlock *LatchBlock = L->getLoopLatch();
 1403     BasicBlock *LatchBlock = L->getLoopLatch();
 2017     if (BasicBlock *LatchBlock = L->getLoopLatch()) {

lib/CodeGen/MachineLoopInfo.cpp

   85   if (MachineBasicBlock *Latch = getLoopLatch()) {
  119   MachineBasicBlock *HB = L->getHeader(), *LB = L->getLoopLatch();

lib/Target/AMDGPU/AMDILCFGStructurizer.cpp

 1578   MachineBasicBlock *LoopLatch = LoopRep->getLoopLatch();

lib/Target/ARM/MVETailPredication.cpp

  273   Value *InLoop = Phi->getIncomingValueForBlock(L->getLoopLatch());
  501     Processed->addIncoming(Remaining, L->getLoopLatch());

lib/Target/Hexagon/HexagonCommonGEP.cpp

  856   BasicBlock *LB = L->getLoopLatch();

lib/Target/Hexagon/HexagonHardwareLoops.cpp

  408   MachineBasicBlock *Latch = L->getLoopLatch();
  605   MachineBasicBlock *Latch = L->getLoopLatch();
 1222   if (ExitingBlock !=  L->getLoopLatch()) {
 1608   MachineBasicBlock *Latch = L->getLoopLatch();
 1856   MachineBasicBlock *Latch = L->getLoopLatch();

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 1772   if (LoopB != CurLoop->getLoopLatch())

lib/Target/Hexagon/HexagonSplitDouble.cpp

  479   const MachineBasicBlock *LB = L->getLoopLatch();

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

  498   BasicBlock *LatchBB = L->getLoopLatch();

lib/Transforms/Scalar/IndVarSimplify.cpp

  770         if (!L->getLoopLatch() ||
  771             !DT->dominates(IncomingBB, L->getLoopLatch()))
 1776   if (BasicBlock *LatchBlock = L->getLoopLatch()) {
 2072   assert(L->getLoopLatch() && "Must be in simplified form");
 2109   int Idx = Phi->getBasicBlockIndex(L->getLoopLatch());
 2222   assert(L->getLoopLatch());
 2235   int LatchIdx = Phi->getBasicBlockIndex(L->getLoopLatch());
 2257   BasicBlock *LatchBlock = L->getLoopLatch();
 2425   assert(L->getLoopLatch() && "Loop no longer in simplified form?");
 2428     cast<Instruction>(IndVar->getIncomingValueForBlock(L->getLoopLatch()));
 2437   if (ExitingBB == L->getLoopLatch()) {
 2671       assert(DT.dominates(ExitingBB, L->getLoopLatch()) &&
 2909         return DT->dominates(ExitingBB, L->getLoopLatch());

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

  394   if (BI->isUnconditional() || BI->getParent() == L->getLoopLatch())
  744   BasicBlock *Latch = L.getLoopLatch();
 1145       cast<BasicBlock>(GetClonedValue(OriginalLoop.getLoopLatch()));

lib/Transforms/Scalar/LoopFuse.cpp

  166         Latch(L->getLoopLatch()), L(L), Valid(true), GuardBranch(nullptr),
  229     assert(Latch == L->getLoopLatch() && "Latch is out of sync");

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1918       !match(CurLoop->getLoopLatch()->getTerminator(),
 1961   BasicBlock *LoopLatchBB = CurLoop->getLoopLatch();
 2091       SE->getExitCount(CurLoop, CurLoop->getLoopLatch());
 2233   BasicBlock *LoopLatchBB = CurLoop->getLoopLatch();
 2330     if (OldBB == CurLoop->getLoopLatch()) // "all elements compared equal".

lib/Transforms/Scalar/LoopInterchange.cpp

  299   if (L->getLoopLatch() == nullptr || L->getLoopPredecessor() == nullptr)
  597   BasicBlock *OuterLoopLatch = OuterLoop->getLoopLatch();
  680   if (!L->getLoopLatch() || !L->getLoopPredecessor())
  701         Value *V = followLCSSA(PHI.getIncomingValueForBlock(L->getLoopLatch()));
  739   BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
  744       OuterLoop->getExitingBlock() != OuterLoop->getLoopLatch() ||
  746       !isa<BranchInst>(OuterLoop->getLoopLatch()->getTerminator())) {
  940      if (!IncomingI || IncomingI->getParent() != OuterLoop->getLoopLatch())
  953      if (OuterLoop->getLoopLatch()->getUniquePredecessor() == nullptr)
 1199   BasicBlock *OuterLatch = NewOuter->getLoopLatch();
 1248         SplitBlock(InnerLoop->getLoopLatch(),
 1249                    InnerLoop->getLoopLatch()->getTerminator(), DT, LI);
 1285         cast<BranchInst>(InnerLoop->getLoopLatch()->getTerminator())
 1451   BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
 1452   BasicBlock *OuterLoopLatch = OuterLoop->getLoopLatch();

lib/Transforms/Scalar/LoopLoadElimination.cpp

  444     PHI->addIncoming(Cand.Store->getOperand(0), L->getLoopLatch());

lib/Transforms/Scalar/LoopPredication.cpp

  837   BasicBlock *LoopLatch = L->getLoopLatch();
  918   auto *LatchBlock = L->getLoopLatch();

lib/Transforms/Scalar/LoopSimplifyCFG.cpp

  280     DeleteCurrentLoop = !IsEdgeLive(L.getLoopLatch(), L.getHeader());
  289     BlocksInLoopAfterFolding.insert(L.getLoopLatch());
  530     assert(L.getLoopLatch() && "Should be single latch!");
  632   if (!L.getLoopLatch())

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2373   BasicBlock *LatchBlock = L->getLoopLatch();
 2504   IVIncInsertPos = L->getLoopLatch()->getTerminator();
 3043   for (DomTreeNode *Rung = DT.getNode(L->getLoopLatch());
 3085         dyn_cast<Instruction>(PN.getIncomingValueForBlock(L->getLoopLatch()));
 3179       InsertPt = L->getLoopLatch()->getTerminator();
 3223           Phi.getIncomingValueForBlock(L->getLoopLatch()));
 3230         IRBuilder<> Builder(L->getLoopLatch()->getTerminator());
 5079       Inputs.push_back(L->getLoopLatch()->getTerminator());

lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp

  288   BasicBlock *Latch = L->getLoopLatch();
  290   BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();

lib/Transforms/Scalar/LoopUnrollPass.cpp

  421                     PhiI->getIncomingValueForBlock(L->getLoopLatch())))
  490           Iteration == 0 ? L->getLoopPreheader() : L->getLoopLatch());
 1084   BasicBlock *ExitingBlock = L->getLoopLatch();

lib/Transforms/Scalar/LoopUnswitch.cpp

 1531     BasicBlock *Latch = L->getLoopLatch();

lib/Transforms/Scalar/LoopVersioningLICM.cpp

  238   if (CurLoop->getExitingBlock() != CurLoop->getLoopLatch()) {
  537   Instruction *I = VerLoop->getLoopLatch()->getTerminator();

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

 2460   BasicBlock *Latch = L.getLoopLatch();

lib/Transforms/Utils/LoopRotationUtils.cpp

  210   BasicBlock *OrigLatch = L->getLoopLatch();
  472       SplitLatchEdge |= L->getLoopLatch() == ExitPred;
  497   assert(L->getLoopLatch() && "Invalid loop latch after loop rotation");
  596   BasicBlock *Latch = L->getLoopLatch();
  642   assert((!MadeChange || L->isLoopExiting(L->getLoopLatch())) &&

lib/Transforms/Utils/LoopSimplify.cpp

  555   BasicBlock *LoopLatch = L->getLoopLatch();

lib/Transforms/Utils/LoopUnroll.cpp

  288   BasicBlock *LatchBlock = L->getLoopLatch();
  407       BasicBlock *ExitingBlock = L->getLoopLatch();

lib/Transforms/Utils/LoopUnrollAndJam.cpp

   56   BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();
  249   BasicBlock *LatchBlock = L->getLoopLatch();
  256       SubLoop->getLoopLatch()->getTerminator()->getSuccessor(0));
  733   BasicBlock *Latch = L->getLoopLatch();
  736   BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();

lib/Transforms/Utils/LoopUnrollPeel.cpp

   89       const BasicBlock *Latch = L->getLoopLatch();
  106   if (L->getLoopLatch() != L->getExitingBlock())
  130   assert(BackEdge == L->getLoopLatch() && "Wrong latch?");
  183     if (L.getLoopLatch() == BB)
  309     BasicBlock *BackEdge = L->getLoopLatch();
  475   BasicBlock *Latch = L->getLoopLatch();
  589   BasicBlock *Latch = L->getLoopLatch();

lib/Transforms/Utils/LoopUnrollRuntime.cpp

   83   BasicBlock *Latch = L->getLoopLatch();
  187   BasicBlock *Latch = L->getLoopLatch();
  307   BasicBlock *Latch = L->getLoopLatch();
  564   BasicBlock *Latch = L->getLoopLatch();

lib/Transforms/Utils/LoopUtils.cpp

  684   BasicBlock *Latch = L->getLoopLatch();
  727   BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();

lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

  299   assert(Lp->getLoopLatch() && "Expected loop with a single latch.");
  314   BasicBlock *Latch = Lp->getLoopLatch();
  537     AllowedExit.insert(Phi->getIncomingValueForBlock(TheLoop->getLoopLatch()));
 1052   if (Lp->getExitingBlock() != Lp->getLoopLatch()) {

lib/Transforms/Vectorize/LoopVectorize.cpp

 1741   auto *LoopVectorLatch = LI->getLoopFor(LoopVectorBody)->getLoopLatch();
 2526   BasicBlock *Latch = L->getLoopLatch();
 3042   assert(isa<BranchInst>(OrigLoop->getLoopLatch()->getTerminator()) &&
 3045       cast<BranchInst>(OrigLoop->getLoopLatch()->getTerminator());
 3120   Value *PostInc = OrigPhi->getIncomingValueForBlock(OrigLoop->getLoopLatch());
 3525   auto *Latch = OrigLoop->getLoopLatch();
 3592   VecPhi->addIncoming(Incoming, LI->getLoopFor(LoopVectorBody)->getLoopLatch());
 3701   BasicBlock *Latch = OrigLoop->getLoopLatch();
 3711       ->addIncoming(Val, LI->getLoopFor(LoopVectorBody)->getLoopLatch());
 3748         LI->getLoopFor(LoopVectorBody)->getLoopLatch()->getTerminator());
 3835     Phi->getBasicBlockIndex(OrigLoop->getLoopLatch());
 4352                   LI->getLoopFor(LoopVectorBody)->getLoopLatch());
 4459   auto *Latch = TheLoop->getLoopLatch();
 4669   BasicBlock *Latch = TheLoop->getLoopLatch();
 6126     } else if (I->getParent() == TheLoop->getLoopLatch() || VF == 1)
 6524   BasicBlock *Latch = OrigLoop->getLoopLatch();
 7052   auto *Latch = OrigLoop->getLoopLatch();

lib/Transforms/Vectorize/SLPVectorizer.cpp

 6704   BasicBlock *BBLatch = BBL->getLoopLatch();

unittests/Analysis/LoopInfoTest.cpp

 1352         EXPECT_EQ(L->getLoopLatch(), Latch);

unittests/Transforms/Vectorize/VPlanLoopInfoTest.cpp

   81   EXPECT_EQ(Latch, VPLp->getLoopLatch());