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

References

include/llvm/Analysis/SparsePropagation.h

  431     if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent(), true))

include/llvm/IR/Instructions.h

 2673     return getIncomingBlock(unsigned(&U - op_begin()));
 2692       if (getIncomingBlock(Op) == Old)
 2744       if (getIncomingBlock(Op) == BB) {

lib/Analysis/BasicAliasAnalysis.cpp

 1620                        PN2->getIncomingValueForBlock(PN->getIncomingBlock(i)),

lib/Analysis/IVDescriptors.cpp

  842   if (TheLoop->contains(Phi->getIncomingBlock(0))) {
  846     assert(TheLoop->contains(Phi->getIncomingBlock(1)) &&

lib/Analysis/IVUsers.cpp

  156         !DT->dominates(LatchBlock, PN->getIncomingBlock(i)))
  222       UseBB = PHI->getIncomingBlock(ValNo);

lib/Analysis/InlineCost.cpp

  484     BasicBlock *Pred = I.getIncomingBlock(i);

lib/Analysis/LazyValueInfo.cpp

  788     BasicBlock *PhiBB = PN->getIncomingBlock(i);
 1909           BasicBlock *PredBB = PHI->getIncomingBlock(i);

lib/Analysis/MemoryBuiltins.cpp

  999     Builder.SetInsertPoint(&*PHI.getIncomingBlock(i)->getFirstInsertionPt());
 1011     SizePHI->addIncoming(EdgeData.first, PHI.getIncomingBlock(i));
 1012     OffsetPHI->addIncoming(EdgeData.second, PHI.getIncomingBlock(i));

lib/Analysis/ScalarEvolution.cpp

 4700     if (L->contains(PN->getIncomingBlock(i))) {
 5014     if (L->contains(PN->getIncomingBlock(i))) {
 5276       if (LI.getLoopFor(PN->getIncomingBlock(i)) != L)
 7853     if (PN->getIncomingBlock(i) == BB)
 8168               if (!LI->contains(PN->getIncomingBlock(i))) {
 8185             unsigned InLoopPred = LI->contains(PN->getIncomingBlock(0)) ? 0 : 1;

lib/Bitcode/Writer/BitcodeWriter.cpp

 2881       Vals64.push_back(VE.getValueID(PN.getIncomingBlock(i)));

lib/CodeGen/CodeGenPrepare.cpp

  772                 Insn->getParent() != UPN->getIncomingBlock(I))
  790       BBPreds.insert(BBPN->getIncomingBlock(i));
  797     BasicBlock *Pred = DestBBPN->getIncomingBlock(i);
  854                        InValPhi->getIncomingBlock(i));
  860           PN.addIncoming(InVal, BBPN->getIncomingBlock(i));
 2020       BasicBlock *PredBB = PN->getIncomingBlock(I);

lib/CodeGen/GlobalISel/IRTranslator.cpp

 2064       auto IRPred = PI->getIncomingBlock(i);

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

  374         BasicBlock *Pred = PN->getIncomingBlock(i);

lib/CodeGen/SjLjEHPrepare.cpp

  301               MarkBlocksLiveIn(PN->getIncomingBlock(i), LiveBBs);

lib/CodeGen/WinEHPrepare.cpp

  826         BasicBlock *IncomingBlock = PN->getIncomingBlock(PredIdx);
 1135         insertPHIStore(PN->getIncomingBlock(i), PredVal, SpillSlot, Worklist);

lib/IR/AsmWriter.cpp

 3764       writeOperand(PN->getIncomingBlock(op), false); Out << " ]";

lib/IR/BasicBlock.cpp

  333     BasicBlock *Other = APN->getIncomingBlock(APN->getIncomingBlock(0) == Pred);
  333     BasicBlock *Other = APN->getIncomingBlock(APN->getIncomingBlock(0) == Pred);

lib/IR/Core.cpp

 2953   return wrap(unwrap<PHINode>(PhiNode)->getIncomingBlock(Index));

lib/IR/SafepointIRVerifier.cpp

  664           const BasicBlock *InBB = PN->getIncomingBlock(i);
  797         const BasicBlock *InBB = PN->getIncomingBlock(i);

lib/IR/Verifier.cpp

 2403             std::make_pair(PN.getIncomingBlock(i), PN.getIncomingValue(i)));

lib/Target/AArch64/AArch64PromoteConstant.cpp

  361     return PhiInst->getIncomingBlock(OpNo)->getTerminator();

lib/Target/AMDGPU/SIAnnotateControlFlow.cpp

  187     if (Phi->getIncomingBlock(i) == IDom) {

lib/Target/Hexagon/HexagonISelLowering.cpp

 1728     BasicBlock *Blk = PN->getIncomingBlock(i);

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 1014       BasicBlock *InB = P->getIncomingBlock(i);
 1068     assert(P.getIncomingBlock(0) == LoopB);

lib/Target/PowerPC/PPCBoolRetToInt.cpp

  105         Q->addIncoming(Zero, P->getIncomingBlock(i));

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

  525       if ((CurrentPHINode->getIncomingBlock(0) == LatchBB &&
  526            CurrentPHINode->getIncomingBlock(1) == PredBB) ||
  527           (CurrentPHINode->getIncomingBlock(1) == LatchBB &&
  528            CurrentPHINode->getIncomingBlock(0) == PredBB)) {

lib/Target/XCore/XCoreLowerThreadLocal.cpp

  138               BasicBlock *PredBB = PN->getIncomingBlock(I);

lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp

  121   BasicBlock *GuardBB = Phi.getIncomingBlock(RotSrc == P1);
  122   BasicBlock *RotBB = Phi.getIncomingBlock(RotSrc != P1);

lib/Transforms/Coroutines/CoroFrame.cpp

  826     if (PN->getIncomingBlock(BBIdx) != OldPred)

lib/Transforms/IPO/Attributor.cpp

  220         const BasicBlock *IncomingBB = PHI->getIncomingBlock(u);

lib/Transforms/IPO/GlobalOpt.cpp

 1436       FieldPN->addIncoming(InVal, PN->getIncomingBlock(i));

lib/Transforms/InstCombine/InstCombineCasts.cpp

  218       NPN->addIncoming(V, OPN->getIncomingBlock(i));
 2246       NewPN->addIncoming(NewV, OldPN->getIncomingBlock(j));

lib/Transforms/InstCombine/InstCombineCompares.cpp

  725         NewPhi->addIncoming(NewIncoming, PHI->getIncomingBlock(I));

lib/Transforms/InstCombine/InstCombinePHI.cpp

  144           (DT.dominates(cast<Instruction>(U), PN.getIncomingBlock(i)) ||
  145            cast<Instruction>(U)->getParent() == PN.getIncomingBlock(i))) {
  194           PtrPHI->getIncomingValueForBlock(PN.getIncomingBlock(i))) {
  235     auto *IncomingBB = PN.getIncomingBlock(i);
  328     NewLHS->addIncoming(InLHS, PN.getIncomingBlock(0));
  336     NewRHS->addIncoming(InRHS, PN.getIncomingBlock(0));
  347         NewLHS->addIncoming(NewInLHS, PN.getIncomingBlock(i));
  351         NewRHS->addIncoming(NewInRHS, PN.getIncomingBlock(i));
  457     NewPN->addIncoming(FirstOp, PN.getIncomingBlock(0));
  468       BasicBlock *InBB = PN.getIncomingBlock(i);
  550   if (FirstLI->getParent() != PN.getIncomingBlock(0) ||
  570         LI->getParent() != PN.getIncomingBlock(i) ||
  597   NewPN->addIncoming(InVal, PN.getIncomingBlock(0));
  624     NewPN->addIncoming(NewInVal, PN.getIncomingBlock(i));
  715     NewPhi->addIncoming(NewIncoming[i], Phi.getIncomingBlock(i));
  784   NewPN->addIncoming(InVal, PN.getIncomingBlock(0));
  791     NewPN->addIncoming(NewInVal, PN.getIncomingBlock(i));
  976       if (II->getParent() != PN->getIncomingBlock(i))
 1056         BasicBlock *Pred = PN->getIncomingBlock(i);
 1186         Instruction *CtxI = PN.getIncomingBlock(i)->getTerminator();
 1239       BasicBlock *BBA = PN.getIncomingBlock(i);
 1240       BasicBlock *BBB = FirstPN->getIncomingBlock(i);

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  121     BasicBlock *inBB = PN->getIncomingBlock(i);

lib/Transforms/InstCombine/InstructionCombining.cpp

  961     NonConstBB = PN->getIncomingBlock(i);
 1003       BasicBlock *ThisBB = PN->getIncomingBlock(i);
 1043       NewPN->addIncoming(InV, PN->getIncomingBlock(i));
 1049       NewPN->addIncoming(InV, PN->getIncomingBlock(i));
 1061       NewPN->addIncoming(InV, PN->getIncomingBlock(i));

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

 1802         BasicBlock *Pred = PN.getIncomingBlock(I);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1297         PNS->addIncoming(getShadow(PN, v), PN->getIncomingBlock(v));
 1298         if (PNO) PNO->addIncoming(getOrigin(PN, v), PN->getIncomingBlock(v));

lib/Transforms/Instrumentation/PoisonChecking.cpp

  268                             OldPHI->getIncomingBlock(i));

lib/Transforms/ObjCARC/ObjCARC.h

   93       auto *BB = PN.getIncomingBlock(I);

lib/Transforms/ObjCARC/ObjCARCContract.cpp

  653           BasicBlock *IncomingBB = PHI->getIncomingBlock(ValNo);
  673             if (PHI->getIncomingBlock(i) == IncomingBB) {

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

  957         else if (PN->getIncomingBlock(i)->getTerminator()->getNumSuccessors() !=
 1012               Instruction *InsertPos = &PN->getIncomingBlock(i)->back();

lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp

   66                     PNB->getIncomingValueForBlock(A->getIncomingBlock(i)), DL))

lib/Transforms/Scalar/CallSiteSplitting.cpp

  431           if (PN->getIncomingBlock(0) == PN->getIncomingBlock(1))
  431           if (PN->getIncomingBlock(0) == PN->getIncomingBlock(1))

lib/Transforms/Scalar/ConstantHoisting.cpp

  188     return cast<PHINode>(Inst)->getIncomingBlock(Idx)->getTerminator();
  712     BasicBlock *IncomingBB = PHI->getIncomingBlock(Idx);
  714       if (PHI->getIncomingBlock(i) == IncomingBB) {

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  191     BasicBlock *IncomingBB = P->getIncomingBlock(IncomingConstant.second);
  220     Value *V = LVI->getConstantOnEdge(Incoming, P->getIncomingBlock(i), BB, P);
  233                 Condition, P->getIncomingBlock(i), BB, P)) {
  253               P->getIncomingBlock(i), BB, P) !=

lib/Transforms/Scalar/GVN.cpp

 1645       if (PN->getParent() == PhiBlock && PN->getIncomingBlock(i) == Pred)

lib/Transforms/Scalar/GVNSink.cpp

  240       Ops.push_back({PN->getIncomingBlock(I), PN->getIncomingValue(I)});

lib/Transforms/Scalar/IndVarSimplify.cpp

  248     BasicBlock *InsertBB = PHI->getIncomingBlock(i);
  308   unsigned IncomingEdge = L->contains(PN->getIncomingBlock(0));
  460                       PN->getIncomingBlock(IncomingEdge));
  465   NewPHI->addIncoming(NewAdd, PN->getIncomingBlock(BackEdge));
  629         if (LI->getLoopFor(PN->getIncomingBlock(i)) != L)
  651           const SCEV *ExitCount = SE->getExitCount(L, PN->getIncomingBlock(i));
  763         auto *IncomingBB = PN.getIncomingBlock(IncomingValIdx);
 1565         WidePhi->addIncoming(DU.WideDef, UsePhi->getIncomingBlock(0));
 2615         UseBB = P->getIncomingBlock(i);

lib/Transforms/Scalar/InferAddressSpaces.cpp

  479                           PHI->getIncomingBlock(Index));

lib/Transforms/Scalar/JumpThreading.cpp

  259     auto PredOutEdge = GetPredOutEdge(PN->getIncomingBlock(i), BB);
  655         Result.push_back(std::make_pair(KC, PN->getIncomingBlock(i)));
  658                                               PN->getIncomingBlock(i),
  661           Result.push_back(std::make_pair(KC, PN->getIncomingBlock(i)));
  787         BasicBlock *PredBB = PN->getIncomingBlock(i);
 1780     BasicBlock *PredBB = PN->getIncomingBlock(i);
 2466     BasicBlock *Pred = CondPHI->getIncomingBlock(I);
 2507     BasicBlock *Pred = CondLHS->getIncomingBlock(I);

lib/Transforms/Scalar/LICM.cpp

  916                 i, CFH.getOrCreateHoistedBlock(PN->getIncomingBlock(i)));
 1426             OpPN->addIncoming(OInst, PN.getIncomingBlock(i));

lib/Transforms/Scalar/LoopInterchange.cpp

  641     if (InnerInduction->getIncomingBlock(IncomBlockIndx) ==
  859   if (InnerInductionVar->getIncomingBlock(0) == InnerLoopPreHeader)
 1234     if (InductionPHI->getIncomingBlock(0) == InnerLoopPreHeader)

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 1475           L->contains(PN->getIncomingBlock(i)))
 2128     if (PH->getIncomingBlock(0) == L->getLoopPreheader()) {
 2174     NewPH->addIncoming(NewInit, PH->getIncomingBlock(Entry));
 2175     NewPH->addIncoming(NewIncr, PH->getIncomingBlock(Latch));
 3427           cast<PHINode>(UserInst)->getIncomingBlock(
 5312       BasicBlock *BB = PN->getIncomingBlock(i);

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

  169     BasicBlock *BB = PhiDef->getIncomingBlock(i);
  212     auto *OpndIncomingBB = PhiDef->getIncomingBlock(i);

lib/Transforms/Scalar/MergeICmps.cpp

  826             Phi.getIncomingBlock(I)) {
  837     LastBlock = Phi.getIncomingBlock(I);

lib/Transforms/Scalar/NewGVN.cpp

 1977         Ops.push_back({PN->getIncomingValue(i), PN->getIncomingBlock(i)});
 2752     auto *PredBB = OpPHI->getIncomingBlock(PredNum);

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 1041         BasicBlock *InBB = PN->getIncomingBlock(i);
 1831                              Phi->getIncomingBlock(i)->getTerminator());
 1999         OrigRootPhi.getIncomingBlock(i);
 2009     if (CurrentIncomingBB != AlternateRootPhi.getIncomingBlock(i))

lib/Transforms/Scalar/SCCP.cpp

  805     if (!isEdgeFeasible(PN.getIncomingBlock(i), PN.getParent()))

lib/Transforms/Scalar/SROA.cpp

 1236     Instruction *TI = PN.getIncomingBlock(Idx)->getTerminator();
 1287     BasicBlock *Pred = PN.getIncomingBlock(Idx);

lib/Transforms/Scalar/Scalarizer.cpp

  758     BasicBlock *IncomingBlock = PHI.getIncomingBlock(I);

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  205       assert(PN.getIncomingBlock(i) == &OldExitingBB &&
  241       if (PN.getIncomingBlock(i) != &OldExitingBB)
 1113       if (PN.getIncomingBlock(i) != ClonedParentBB)

lib/Transforms/Scalar/Sink.cpp

   50       UseBlock = PN->getIncomingBlock(Num);

lib/Transforms/Scalar/SpeculateAroundPHIs.cpp

  224     if (!IncomingConstantBlocks.insert(PN.getIncomingBlock(i)).second)
  645         IncomingValueMap[OpPN->getIncomingBlock(i)] = OpPN->getIncomingValue(i);

lib/Transforms/Utils/BasicBlockUtils.cpp

  542         if (!PredSet.count(PN->getIncomingBlock(i)))
  563         if (PredSet.count(PN->getIncomingBlock(i)))
  583       BasicBlock *IncomingBB = PN->getIncomingBlock(i);
  891     Pred1 = SomePHI->getIncomingBlock(0);
  892     Pred2 = SomePHI->getIncomingBlock(1);

lib/Transforms/Utils/BreakCriticalEdges.cpp

  190       if (PN->getIncomingBlock(BBIdx) != TIBB)
  336     BasicBlock *PredBB = PN->getIncomingBlock(Pred);

lib/Transforms/Utils/CloneFunction.cpp

  534         Value *V = VMap.lookup(PN->getIncomingBlock(pred));
  567         ++PredCount[PN->getIncomingBlock(i)];

lib/Transforms/Utils/CodeExtractor.cpp

  634       if (Blocks.count(PN->getIncomingBlock(i)))
  664       if (Blocks.count(PN->getIncomingBlock(i))) {
  665         Instruction *TI = PN->getIncomingBlock(i)->getTerminator();
  684         if (Blocks.count(PN->getIncomingBlock(i))) {
  685           NewPN->addIncoming(PN->getIncomingValue(i), PN->getIncomingBlock(i));
  707         if (Blocks.count(PN.getIncomingBlock(i)))
  736         NewPN->addIncoming(PN.getIncomingValue(i), PN.getIncomingBlock(i));
 1548       if (!Blocks.count(PN->getIncomingBlock(i)))
 1557         if (!Blocks.count(PN.getIncomingBlock(i)))

lib/Transforms/Utils/DemoteRegToStack.cpp

   72           Value *&V = Loads[PN->getIncomingBlock(i)];
   77                              PN->getIncomingBlock(i)->getTerminator());
  133       assert(II->getParent() != P->getIncomingBlock(i) &&
  137                   P->getIncomingBlock(i)->getTerminator());

lib/Transforms/Utils/FlattenCFG.cpp

  460         if (Phi.getIncomingBlock(i) == SecondEntryBlock)

lib/Transforms/Utils/FunctionComparator.cpp

  653               cmpValues(PNL->getIncomingBlock(i), PNR->getIncomingBlock(i)))
  653               cmpValues(PNL->getIncomingBlock(i), PNR->getIncomingBlock(i)))

lib/Transforms/Utils/Local.cpp

  782         BasicBlock *IBB = PN->getIncomingBlock(PI);
  800         BasicBlock *IBB = PN->getIncomingBlock(PI);
  859     BasicBlock *BB = PN->getIncomingBlock(i);
  879     BasicBlock *BB = PN->getIncomingBlock(i);
  923       BasicBlock *PredBB = OldValPN->getIncomingBlock(i);

lib/Transforms/Utils/LoopSimplify.cpp

  198           L->contains(PN->getIncomingBlock(i)))
  245         !L->contains(PN->getIncomingBlock(i))) {
  247       if (PN->getIncomingBlock(i)->getTerminator()->isIndirectTerminator())
  249       OuterLoopPreds.push_back(PN->getIncomingBlock(i));
  402       BasicBlock *IBB = PN->getIncomingBlock(i);
  421       PN->setIncomingBlock(0, PN->getIncomingBlock(PreheaderIdx));

lib/Transforms/Utils/LoopUnroll.cpp

   91       ValueToValueMapTy::iterator It = VMap.find(PN->getIncomingBlock(i));

lib/Transforms/Utils/LoopUnrollAndJam.cpp

  425         if (Phi.getIncomingBlock(b) == OldBB) {

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  824                            cast<BasicBlock>(VMap[Phi->getIncomingBlock(i)]));

lib/Transforms/Utils/LoopUtils.cpp

  581             P.getIncomingBlock(PredIndex) == Preheader) &&

lib/Transforms/Utils/LowerSwitch.cpp

  221       if (PN->getIncomingBlock(Idx) == OrigBB) {
  231       if (PN->getIncomingBlock(Idx) == OrigBB) {

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

  743           Preds, SomePHI->getIncomingBlock(i), CompareBBNumbers);
  744       assert(EntIt != Preds.end() && *EntIt == SomePHI->getIncomingBlock(i) &&

lib/Transforms/Utils/SSAUpdater.cpp

   86     if (ValueMapping[PHI->getIncomingBlock(i)] !=
  115       BasicBlock *PredBB = SomePhi->getIncomingBlock(i);
  247     BasicBlock *getIncomingBlock() { return PHI->getIncomingBlock(idx); }

lib/Transforms/Utils/SimplifyCFG.cpp

 1413         if (PN.getIncomingBlock(i) == BB1 || PN.getIncomingBlock(i) == BB2)
 1413         if (PN.getIncomingBlock(i) == BB1 || PN.getIncomingBlock(i) == BB2)
 2209     BasicBlock *PredBB = PN->getIncomingBlock(i);
 2376   BasicBlock *IfBlock1 = PN->getIncomingBlock(0);
 2377   BasicBlock *IfBlock2 = PN->getIncomingBlock(1);
 2423     Value *TrueVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfFalse);
 2424     Value *FalseVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfTrue);
 3836     auto *IncomingBB = PhiLPInst->getIncomingBlock(Idx);
 4007                               SrcPN->getIncomingBlock(SrcIdx));
 6021         Instruction *T = PHI.getIncomingBlock(i)->getTerminator();
 6024           BB->removePredecessor(PHI.getIncomingBlock(i));

lib/Transforms/Utils/ValueMapper.cpp

  867       Value *V = mapValue(PN->getIncomingBlock(i));

lib/Transforms/Vectorize/LoopVectorize.cpp

 3882       BB = Phi->getIncomingBlock(
 6823       createEdgeMask(Phi->getIncomingBlock(In), Phi->getParent(), Plan);

lib/Transforms/Vectorize/SLPVectorizer.cpp

 2323                   PH->getIncomingBlock(i)));
 2345               PH->getIncomingBlock(i)));
 3774         BasicBlock *IBB = PH->getIncomingBlock(i);
 4324                 PH->getIncomingBlock(i)->getTerminator();
 4329               Builder.SetInsertPoint(PH->getIncomingBlock(i)->getTerminator());
 4333             CSEBlocks.insert(PH->getIncomingBlock(i));
 6691   if (P->getIncomingBlock(0) == ParentBB) {
 6693   } else if (P->getIncomingBlock(1) == ParentBB) {
 6710   if (P->getIncomingBlock(0) == BBLatch) {
 6712   } else if (P->getIncomingBlock(1) == BBLatch) {

tools/polly/lib/Analysis/ScopBuilder.cpp

 1096     BasicBlock *OpBB = PHI->getIncomingBlock(u);

tools/polly/lib/Support/SCEVValidator.cpp

  784       BasicBlock *Incoming = PHI->getIncomingBlock(i);
  802     BasicBlock *BB = PHI->getIncomingBlock(i);

unittests/IR/BasicBlockTest.cpp

   82     EXPECT_EQ(BB.get(), PN.getIncomingBlock(0));
   83     EXPECT_EQ(BB1.get(), PN.getIncomingBlock(1));
   84     EXPECT_EQ(BB2.get(), PN.getIncomingBlock(2));