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

Declarations

include/llvm/Analysis/LoopInfo.h

  300   BlockT *getLoopPreheader() const;

References

lib/Analysis/IVDescriptors.cpp

  205   Value *RdxStart = Phi->getIncomingValueForBlock(TheLoop->getLoopPreheader());
  682   auto *Preheader = TheLoop->getLoopPreheader();
 1056       Phi->getIncomingValueForBlock(AR->getLoop()->getLoopPreheader());

lib/Analysis/LoopInfo.cpp

   93     BasicBlock *Preheader = getLoopPreheader();
  366   BasicBlock *Preheader = getLoopPreheader();
  467   return getLoopPreheader() && getLoopLatch() && hasDedicatedExits();
  634   if (BasicBlock *PHeadBB = getLoopPreheader())
  951   auto *PreHeader = L.getLoopPreheader();

lib/Analysis/MustExecute.cpp

  140   auto *IVStart = LHS->getIncomingValueForBlock(CurLoop->getLoopPreheader());

lib/Analysis/ScalarEvolutionExpander.cpp

  219       BasicBlock *Preheader = L->getLoopPreheader();
  548       BasicBlock *Preheader = L->getLoopPreheader();
  575       BasicBlock *Preheader = L->getLoopPreheader();
 1041       (IVOper = getIVIncOperand(IVOper, L->getLoopPreheader()->getTerminator(),
 1263   assert(L->getLoopPreheader() &&
 1266                                 L->getLoopPreheader()->getTerminator());
 1840         if (BasicBlock *Preheader = L->getLoopPreheader())

lib/CodeGen/CodeGenPrepare.cpp

  636     if (BasicBlock *Preheader = L->getLoopPreheader())

lib/CodeGen/HardwareLoops.cpp

  244   BasicBlock *Preheader = L->getLoopPreheader();
  282   BasicBlock *Preheader = L->getLoopPreheader();
  340   BasicBlock *BB = L->getLoopPreheader();
  362   BeginBB = UseLoopGuard ? BB : L->getLoopPreheader();
  385     if (LoopGuard->getSuccessor(0) != L->getLoopPreheader())
  430   BasicBlock *Preheader = L->getLoopPreheader();

lib/CodeGen/MachineLICM.cpp

 1512     CurPreheader = CurLoop->getLoopPreheader();

lib/CodeGen/MachineLoopInfo.cpp

   96   if (MachineBasicBlock *PHeadMBB = getLoopPreheader())
  113   if (MachineBasicBlock *PB = L->getLoopPreheader())

lib/CodeGen/MachinePipeliner.cpp

  336   if (!L.getLoopPreheader()) {

lib/CodeGen/ModuloSchedule.cpp

 1281     : S(S), BB(L.getTopBlock()), PreheaderBB(L.getLoopPreheader()),
 1819   Preheader = Schedule.getLoop()->getLoopPreheader();
 1829   Preheader = Schedule.getLoop()->getLoopPreheader();

lib/Target/AMDGPU/SIISelLowering.cpp

10796   MachineBasicBlock *Pre = ML->getLoopPreheader();

lib/Target/ARM/ARMLowOverheadLoops.cpp

  245   if (auto *Preheader = ML->getLoopPreheader()) {

lib/Target/ARM/MVETailPredication.cpp

  130   BasicBlock *Preheader = L->getLoopPreheader();
  269   Value *OnEntry = Phi->getIncomingValueForBlock(L->getLoopPreheader());
  384   Instruction *InsertPt = L->getLoopPreheader()->getTerminator();
  478     Processed->addIncoming(NumElements, L->getLoopPreheader());

lib/Target/Hexagon/HexagonCommonGEP.cpp

  866   if (BasicBlock *PH = L->getLoopPreheader())

lib/Target/Hexagon/HexagonHardwareLoops.cpp

  773   if (loopCountMayWrapOrUnderFlow(Start, End, Loop->getLoopPreheader(), Loop,

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 1777   BasicBlock *EntryB = CurLoop->getLoopPreheader();
 2029   BasicBlock *Preheader = CurLoop->getLoopPreheader();
 2417   if (!L->getLoopPreheader())

lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp

  320   if (!L->getLoopPreheader())
  607   BasicBlock *LoopPH = CurLoop->getLoopPreheader();
  707       PN->getIncomingValueForBlock(CurLoop->getLoopPreheader());

lib/Transforms/Instrumentation/InstrProfiling.cpp

  277         auto PreheaderCount = BFI->getBlockProfileCount(L.getLoopPreheader());
  286                                         L.getLoopPreheader(), ExitBlocks,
  328     BasicBlock *PH = LP->getLoopPreheader();

lib/Transforms/Scalar/IndVarSimplify.cpp

  799         auto *LoopPreheader = L->getLoopPreheader();
  820   BasicBlock *Preheader = L->getLoopPreheader();
 1076        L && L->getLoopPreheader() && L->isLoopInvariant(NarrowOper);
 1078     Builder.SetInsertPoint(L->getLoopPreheader()->getTerminator());
 2570   BasicBlock *Preheader = L->getLoopPreheader();
 2936   Rewriter.setInsertPoint(L->getLoopPreheader()->getTerminator());
 2937   IRBuilder<> B(L->getLoopPreheader()->getTerminator());
 3083       if (!AR || AR->getLoop()->getLoopPreheader())

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

  758   BasicBlock *Preheader = L.getLoopPreheader();
 1389   Preheader = OriginalLoop.getLoopPreheader();
 1791   BasicBlock *Preheader = L->getLoopPreheader();

lib/Transforms/Scalar/LICM.cpp

  370   BasicBlock *Preheader = L->getLoopPreheader();
  686       return CurLoop->getLoopPreheader();
  701     BasicBlock *InitialPreheader = CurLoop->getLoopPreheader();
  783     assert(CurLoop->getLoopPreheader() &&
  856               CurLoop->getLoopPreheader()->getTerminator())) {
 1881   BasicBlock *Preheader = CurLoop->getLoopPreheader();

lib/Transforms/Scalar/LoopDeletion.cpp

   96   auto *Preheader = L->getLoopPreheader();
  142   BasicBlock *Preheader = L->getLoopPreheader();

lib/Transforms/Scalar/LoopDistribute.cpp

  442     BasicBlock *OrigPH = L->getLoopPreheader();
  467          I != E; ++I, --Index, TopPH = NewLoop->getLoopPreheader()) {
  489           Next->getDistributedLoop()->getLoopPreheader(),
  678     BasicBlock *PH = L->getLoopPreheader();

lib/Transforms/Scalar/LoopFuse.cpp

  164       : Preheader(L->getLoopPreheader()), Header(L->getHeader()),
  224     assert(Preheader == L->getLoopPreheader() && "Preheader is out of sync");

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

  356   if (!L->getLoopPreheader())
  958   BasicBlock *Preheader = CurLoop->getLoopPreheader();
 1078   BasicBlock *Preheader = CurLoop->getLoopPreheader();
 1380     Value *T = matchCondition(PreCondBr, CurLoop->getLoopPreheader());
 1453   InitX = PhiX->getIncomingValueForBlock(CurLoop->getLoopPreheader());
 1535   BasicBlock *PH = CurLoop->getLoopPreheader();
 1608   BasicBlock *PH = CurLoop->getLoopPreheader();
 1786   BasicBlock *PreHead = CurLoop->getLoopPreheader();
 2231   BasicBlock *PreheaderBB = CurLoop->getLoopPreheader();
 2597   IRBuilder<> Builder(CurLoop->getLoopPreheader()->getTerminator());

lib/Transforms/Scalar/LoopInterchange.cpp

  596   BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
  629   BasicBlock *InnerLoopPreheader = InnerLoop->getLoopPreheader();
  738   BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
 1226     BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
 1430   BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader();
 1431   BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
 1566   BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader();
 1567   BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();

lib/Transforms/Scalar/LoopLoadElimination.cpp

  433     auto *PH = L->getLoopPreheader();

lib/Transforms/Scalar/LoopPredication.cpp

  977   Preheader = L->getLoopPreheader();

lib/Transforms/Scalar/LoopSimplifyCFG.cpp

  354     BasicBlock *Preheader = L.getLoopPreheader();
  380     assert(L.getLoopPreheader() == NewPreheader && "Malformed CFG?");

lib/Transforms/Scalar/LoopSink.cpp

  165       BFI.getBlockFreq(L.getLoopPreheader()))
  255   BasicBlock *Preheader = L.getLoopPreheader();
  286     if (BFI.getBlockFreq(B) < BFI.getBlockFreq(L.getLoopPreheader())) {

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2128     if (PH->getIncomingBlock(0) == L->getLoopPreheader()) {
 5539   for (DomTreeNode *Rung = DT.getNode(L->getLoopPreheader());
 5544       assert(DomLoop->getLoopPreheader() && "LSR needs a simplified loop nest");

lib/Transforms/Scalar/LoopUnrollPass.cpp

  490           Iteration == 0 ? L->getLoopPreheader() : L->getLoopLatch());

lib/Transforms/Scalar/LoopUnswitch.cpp

  237       loopPreheader = currentLoop->getLoopPreheader();

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  431   BasicBlock *OldPH = L.getLoopPreheader();
  671   BasicBlock *OldPH = L.getLoopPreheader();
 1205   auto *OrigPH = OrigL.getLoopPreheader();
 1567   auto *PH = L.getLoopPreheader();
 1616         auto *InnerPH = InnerL->getLoopPreheader();
 1677   auto *PH = L.getLoopPreheader();
 1852     if (auto *NewParentL = LI.getLoopFor(HoistedL->getLoopPreheader()))
 2017   BasicBlock *SplitBB = L.getLoopPreheader();

lib/Transforms/Utils/CloneFunction.cpp

  768   BasicBlock *OrigPH = OrigLoop->getLoopPreheader();

lib/Transforms/Utils/LoopRotationUtils.cpp

  259   BasicBlock *OrigPreheader = L->getLoopPreheader();
  496   assert(L->getLoopPreheader() && "Invalid loop preheader after loop rotation");

lib/Transforms/Utils/LoopSimplify.cpp

  536   BasicBlock *Preheader = L->getLoopPreheader();

lib/Transforms/Utils/LoopUnroll.cpp

  186   BasicBlock *PreHeader = L->getLoopPreheader();
  282   BasicBlock *Preheader = L->getLoopPreheader();
  410       Preheader = L->getLoopPreheader();

lib/Transforms/Utils/LoopUnrollAndJam.cpp

   70   BasicBlock *SubLoopPreHeader = SubLoop->getLoopPreheader();
  248   BasicBlock *Preheader = L->getLoopPreheader();
  276   ForeBlocksLast.push_back(SubLoop->getLoopPreheader());
  286       Header, LatchBlock, SubLoop->getLoopPreheader()->getTerminator(),

lib/Transforms/Utils/LoopUnrollPeel.cpp

  476   BasicBlock *PreHeader = L->getLoopPreheader();
  588   BasicBlock *PreHeader = L->getLoopPreheader();

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  634   BasicBlock *PreHeader = L->getLoopPreheader();

lib/Transforms/Utils/LoopUtils.cpp

  510   auto *Preheader = L->getLoopPreheader();

lib/Transforms/Utils/LoopVersioning.cpp

   62   BasicBlock *RuntimeCheckBB = VersionedLoop->getLoopPreheader();
  110   BranchInst::Create(NonVersionedLoop->getLoopPreheader(),
  111                      VersionedLoop->getLoopPreheader(), RuntimeCheck, OrigTerm);

lib/Transforms/Utils/SimplifyIndVar.cpp

  652   if (auto *BB = L->getLoopPreheader())

lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

 1017   if (!Lp->getLoopPreheader()) {

lib/Transforms/Vectorize/LoopVectorize.cpp

 2542   Induction->addIncoming(Start, L->getLoopPreheader());
 2559   IRBuilder<> Builder(L->getLoopPreheader()->getTerminator());
 2591                                 L->getLoopPreheader()->getTerminator());
 2596                                     L->getLoopPreheader()->getTerminator());
 2606   IRBuilder<> Builder(L->getLoopPreheader()->getTerminator());
 2680   BasicBlock *BB = L->getLoopPreheader();
 2711   BasicBlock *BB = L->getLoopPreheader();
 2748   BasicBlock *BB = L->getLoopPreheader();
 2917   BasicBlock *VectorPH = OrigLoop->getLoopPreheader();
 3016       IRBuilder<> B(Lp->getLoopPreheader()->getTerminator());
 3072   LoopVectorPreHeader = Lp->getLoopPreheader();
 3524   auto *Preheader = OrigLoop->getLoopPreheader();

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4405     BasicBlock *PreHeader = L->getLoopPreheader();

lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp

  141   BasicBlock *PH = TheLoop->getLoopPreheader();
  252   BasicBlock *PreheaderBB = TheLoop->getLoopPreheader();

unittests/Transforms/Utils/CloningTest.cpp

  428         EXPECT_EQ(Preheader, L->getLoopPreheader());

unittests/Transforms/Vectorize/VPlanLoopInfoTest.cpp

   79   EXPECT_EQ(PH, VPLp->getLoopPreheader());