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

References

lib/Analysis/BasicAliasAnalysis.cpp

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

lib/Analysis/BranchProbabilityInfo.cpp

  535       Value *V = P->getIncomingValueForBlock(B);

lib/Analysis/IVDescriptors.cpp

  205   Value *RdxStart = Phi->getIncomingValueForBlock(TheLoop->getLoopPreheader());
  694   auto *Previous = dyn_cast<Instruction>(Phi->getIncomingValueForBlock(Latch));
  949   Value *Val = PN->getIncomingValueForBlock(Latch);
 1056       Phi->getIncomingValueForBlock(AR->getLoop()->getLoopPreheader());
 1062       dyn_cast<BinaryOperator>(Phi->getIncomingValueForBlock(Latch));

lib/Analysis/LoopInfo.cpp

  157             dyn_cast<ConstantInt>(PN->getIncomingValueForBlock(Incoming)))
  160                 dyn_cast<Instruction>(PN->getIncomingValueForBlock(Backedge)))

lib/Analysis/MustExecute.cpp

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

lib/Analysis/PHITransAddr.cpp

  169       return AddAsInput(PN->getIncomingValueForBlock(PredBB));

lib/Analysis/ScalarEvolution.cpp

 7635     Value *BEValue = PNOut->getIncomingValueForBlock(Latch);
 7673     Value *FirstValue = PN->getIncomingValueForBlock(Predecessor);
 7902   Value *BEValue = PN->getIncomingValueForBlock(Latch);
 7941         Value *BEValue = PHI->getIncomingValueForBlock(Latch);
 8014       Value *BEValue = PHI->getIncomingValueForBlock(Latch);
10073       const SCEV *L = getSCEV(LPhi->getIncomingValueForBlock(IncBB));
10074       const SCEV *R = getSCEV(RPhi->getIncomingValueForBlock(IncBB));
10089     const SCEV *L1 = getSCEV(LPhi->getIncomingValueForBlock(Predecessor));
10094     const SCEV *L2 = getSCEV(LPhi->getIncomingValueForBlock(Latch));
10106       const SCEV *L = getSCEV(LPhi->getIncomingValueForBlock(IncBB));

lib/Analysis/ScalarEvolutionExpander.cpp

 1198           dyn_cast<Instruction>(PN.getIncomingValueForBlock(LatchBlock));
 1405     Result = PN->getIncomingValueForBlock(LatchBlock);
 1576         CanonicalIV->addIncoming(CanonicalIV->getIncomingValueForBlock(HP), HP);
 2019           OrigPhiRef->getIncomingValueForBlock(LatchBlock));
 2021           dyn_cast<Instruction>(Phi->getIncomingValueForBlock(LatchBlock));

lib/CodeGen/CodeGenPrepare.cpp

  727           return DestPN.getIncomingValueForBlock(BB) ==
  728                  DestPN.getIncomingValueForBlock(DestBBPred);
  800         const Value *V1 = PN.getIncomingValueForBlock(Pred);
  801         const Value *V2 = PN.getIncomingValueForBlock(BB);
  806             V2 = V2PN->getIncomingValueForBlock(Pred);
 3299         Value *FirstValue = Item.first->getIncomingValueForBlock(B);
 3300         Value *SecondValue = Item.second->getIncomingValueForBlock(B);
 3402           Value *PV = cast<PHINode>(Current)->getIncomingValueForBlock(B);
 7262       auto *Val = PN.getIncomingValueForBlock(&BB);

lib/CodeGen/SelectionDAG/FastISel.cpp

 2295       const Value *PHIOp = PN.getIncomingValueForBlock(LLVMBB);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 9959       const Value *PHIOp = PN.getIncomingValueForBlock(LLVMBB);

lib/IR/Value.cpp

  739     return PN->getIncomingValueForBlock(PredBB);

lib/Target/ARM/MVETailPredication.cpp

  269   Value *OnEntry = Phi->getIncomingValueForBlock(L->getLoopPreheader());
  273   Value *InLoop = Phi->getIncomingValueForBlock(L->getLoopLatch());

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

  631     Value *InitV = PN->getIncomingValueForBlock(PB);
  634     Value *IterV = PN->getIncomingValueForBlock(BB);
  906     if (SelI != RPhi->getIncomingValueForBlock(LoopB))
  941       Value *EntryP = RPhi->getIncomingValueForBlock(PrehB);
 1453     Value *U = PN->getIncomingValueForBlock(LoopB);

lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp

  596   Value *ValueInBlock = PN->getIncomingValueForBlock(BB);
  700     Value *BEVal = PN->getIncomingValueForBlock(BB);
  707       PN->getIncomingValueForBlock(CurLoop->getLoopPreheader());

lib/Transforms/Coroutines/CoroSplit.cpp

  894     auto V = PN.getIncomingValueForBlock(PrevBB);

lib/Transforms/IPO/LowerTypeTests.cpp

  791           Phi.addIncoming(Phi.getIncomingValueForBlock(Then), InitialBB);

lib/Transforms/IPO/PartialInlining.cpp

 1080       RetPhi->addIncoming(OldPhi->getIncomingValueForBlock(E), E);

lib/Transforms/InstCombine/InstCombinePHI.cpp

  194           PtrPHI->getIncomingValueForBlock(PN.getIncomingBlock(i))) {

lib/Transforms/ObjCARC/ObjCARC.h

   95       auto *POpnd = P.getIncomingValueForBlock(BB)->stripPointerCasts();

lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp

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

lib/Transforms/Scalar/CallSiteSplitting.cpp

  345           NewCS.setArgument(ArgNo, PN.getIncomingValueForBlock(SplitBlock));

lib/Transforms/Scalar/IndVarSimplify.cpp

  839     Value *Incoming = P->getIncomingValueForBlock(ExitingBlocks[0]);
 1778       cast<Instruction>(WidePhi->getIncomingValueForBlock(LatchBlock));
 1783       cast<Instruction>(OrigPhi->getIncomingValueForBlock(LatchBlock));
 2285       Value *IncPhi = Phi->getIncomingValueForBlock(LatchBlock);
 2428     cast<Instruction>(IndVar->getIncomingValueForBlock(L->getLoopLatch()));

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

 1171         Value *OldIncoming = PN.getIncomingValueForBlock(OriginalBB);
 1315     NewPHI->addIncoming(PN.getIncomingValueForBlock(Preheader), Preheader);
 1316     NewPHI->addIncoming(PN.getIncomingValueForBlock(LS.Latch),

lib/Transforms/Scalar/JumpThreading.cpp

 1910     Value *IV = PN.getIncomingValueForBlock(OldPred);
 2003     NewPN->addIncoming(PN->getIncomingValueForBlock(PredBB), PredBB);
 2322     ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
 2456       Phi->addIncoming(Phi->getIncomingValueForBlock(Pred), NewBB);

lib/Transforms/Scalar/LoopDeletion.cpp

   54     Value *incoming = P.getIncomingValueForBlock(ExitingBlocks[0]);
   62           return incoming == P.getIncomingValueForBlock(BB);

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1453   InitX = PhiX->getIncomingValueForBlock(CurLoop->getLoopPreheader());
 1737   Value *CntInitVal = CntPhi->getIncomingValueForBlock(Preheader);
 1809     Value *CntInitVal = CntPhi->getIncomingValueForBlock(PreHead);
 2003             dyn_cast<Instruction>(PHI.getIncomingValueForBlock(LoopBB));

lib/Transforms/Scalar/LoopInterchange.cpp

  701         Value *V = followLCSSA(PHI.getIncomingValueForBlock(L->getLoopLatch()));
 1356     auto IncI = cast<Instruction>(P.getIncomingValueForBlock(InnerLatch));

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 3085         dyn_cast<Instruction>(PN.getIncomingValueForBlock(L->getLoopLatch()));
 3223           Phi.getIncomingValueForBlock(L->getLoopLatch()));

lib/Transforms/Scalar/LoopUnrollPass.cpp

  421                     PhiI->getIncomingValueForBlock(L->getLoopLatch())))
  489       Value *V = PHI->getIncomingValueForBlock(
  625       Value *Op = PN->getIncomingValueForBlock(ExitingBB);

lib/Transforms/Scalar/LoopUnswitch.cpp

 1321       Value *V = PN.getIncomingValueForBlock(ExitBlocks[i]);

lib/Transforms/Scalar/MergeICmps.cpp

  445     BCECmpBlock Comparison = visitCmpBlock(Phi.getIncomingValueForBlock(Block),

lib/Transforms/Scalar/NewGVN.cpp

 2775             Op = ValuePHI->getIncomingValueForBlock(PredBB);

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 2678       Value *V = PN->getIncomingValueForBlock(BB);

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  169     if (!L.isLoopInvariant(PN->getIncomingValueForBlock(&ExitingBB)))

lib/Transforms/Utils/BasicBlockUtils.cpp

  540       InVal = PN->getIncomingValueForBlock(Preds[0]);
  792           NewBC->setOperand(0, PN->getIncomingValueForBlock(Pred));
  794           *i = PN->getIncomingValueForBlock(Pred);

lib/Transforms/Utils/BreakCriticalEdges.cpp

  455       NewIndPHI->addIncoming(IndPHI->getIncomingValueForBlock(IBRPred),

lib/Transforms/Utils/CloneFunction.cpp

  846     ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);

lib/Transforms/Utils/Evaluator.cpp

  726       setVal(PN, getVal(PN->getIncomingValueForBlock(CurBB)));

lib/Transforms/Utils/InlineFunction.cpp

  122         UnwindDestPHIValues.push_back(PHI->getIncomingValueForBlock(InvokeBB));
  658     UnwindDestPHIValues.push_back(PHI->getIncomingValueForBlock(InvokeBB));

lib/Transforms/Utils/Local.cpp

  779     PHINode *BBPN = dyn_cast<PHINode>(PN->getIncomingValueForBlock(BB));
  784             !CanMergeValues(BBPN->getIncomingValueForBlock(IBB),
  795       Value* Val = PN->getIncomingValueForBlock(BB);

lib/Transforms/Utils/LoopRotationUtils.cpp

  303     ValueMap[PN] = PN->getIncomingValueForBlock(OrigPreheader);
  389       PN->addIncoming(PN->getIncomingValueForBlock(OrigHeader), OrigPreheader);

lib/Transforms/Utils/LoopUnroll.cpp

  190     if (isa<ConstantInt>(PN.getIncomingValueForBlock(PreHeader)))
  623           Value *InVal = NewPHI->getIncomingValueForBlock(LatchBlock);
  642           Value *Incoming = PHI.getIncomingValueForBlock(*BB);
  697       PN->replaceAllUsesWith(PN->getIncomingValueForBlock(Preheader));

lib/Transforms/Utils/LoopUnrollAndJam.cpp

   96     Value *V = Phi.getIncomingValueForBlock(Latch);
  393       Value *OldValue = Phi.getIncomingValueForBlock(AftBlocksLast[It]);
  454       Phi->replaceAllUsesWith(Phi->getIncomingValueForBlock(Preheader));

lib/Transforms/Utils/LoopUnrollPeel.cpp

  137   Value *Input = Phi->getIncomingValueForBlock(BackEdge);
  538       VMap[&*I] = NewPHI->getIncomingValueForBlock(PreHeader);
  540       Value *LatchVal = NewPHI->getIncomingValueForBlock(Latch);
  556       Value *LatchVal = PHI.getIncomingValueForBlock(Edge.first);
  734     Value *NewVal = PHI->getIncomingValueForBlock(Latch);

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  107         NewPN->addIncoming(PN.getIncomingValueForBlock(NewPreHeader),
  114       Value *V = PN.getIncomingValueForBlock(Latch);
  225     Value *V = PN.getIncomingValueForBlock(Latch);
  259       NewPN->addIncoming(PN.getIncomingValueForBlock(NewPreHeader), PreHeader);
  261       NewPN->addIncoming(PN.getIncomingValueForBlock(Latch), Latch);
  383         VMap[&*I] = NewPHI->getIncomingValueForBlock(Preheader);

lib/Transforms/Utils/SimplifyCFG.cpp

  246         if (PN->getIncomingValueForBlock(SI1BB) !=
  247             PN->getIncomingValueForBlock(SI2BB)) {
  289         if (PN->getIncomingValueForBlock(SI1BB) != Cond ||
  290             !isa<ConstantInt>(PN->getIncomingValueForBlock(SI2BB)))
  305     PN.addIncoming(PN.getIncomingValueForBlock(ExistPred), NewPred);
 1222       Value *BB1V = PN.getIncomingValueForBlock(BB1);
 1223       Value *BB2V = PN.getIncomingValueForBlock(BB2);
 1357       Value *BB1V = PN.getIncomingValueForBlock(BB1);
 1358       Value *BB2V = PN.getIncomingValueForBlock(BB2);
 1398       Value *BB1V = PN.getIncomingValueForBlock(BB1);
 1399       Value *BB2V = PN.getIncomingValueForBlock(BB2);
 1488                   PNUse->getIncomingValueForBlock(I->getParent()) == I) ||
 2045     Value *OrigV = PN.getIncomingValueForBlock(BB);
 2046     Value *ThenV = PN.getIncomingValueForBlock(ThenBB);
 2238         TranslateMap[PN] = PN->getIncomingValueForBlock(PredBB);
 2481       TrueValue = TVPN->getIncomingValueForBlock(BI->getParent());
 2484       FalseValue = FVPN->getIncomingValueForBlock(BI->getParent());
 2816             PHIs[i]->getIncomingValueForBlock(PBI->getParent()));
 2916     if (cast<PHINode>(I)->getIncomingValueForBlock(BB) == V) {
 2924       if (PHI->getIncomingValueForBlock(OtherPredBB) == AlternativeV)
 3327     Value *BIV = PN->getIncomingValueForBlock(BB);
 3416     Value *BIV = PN.getIncomingValueForBlock(BB);
 3795     Value *InVal = PN->getIncomingValueForBlock(BB);

lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

  331   Value *IVUpdate = IV->getIncomingValueForBlock(Latch);
  537     AllowedExit.insert(Phi->getIncomingValueForBlock(TheLoop->getLoopLatch()));

lib/Transforms/Vectorize/LoopVectorize.cpp

 3120   Value *PostInc = OrigPhi->getIncomingValueForBlock(OrigLoop->getLoopLatch());
 3528   auto *ScalarInit = Phi->getIncomingValueForBlock(Preheader);
 3529   auto *Previous = Phi->getIncomingValueForBlock(Latch);
 3702   Value *LoopVal = Phi->getIncomingValueForBlock(Latch);
 3955           OrigPhi->getIncomingValueForBlock(ScalarBBPredecessors[i]);
 4462     auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));
 4505     auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));
 4787     auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));
 6538     auto *IndUpdate = cast<Instruction>(Ind->getIncomingValueForBlock(Latch));

lib/Transforms/Vectorize/SLPVectorizer.cpp

 2322               cast<PHINode>(VL[j])->getIncomingValueForBlock(
 2344           Operands.push_back(cast<PHINode>(j)->getIncomingValueForBlock(
 3777           NewPhi->addIncoming(NewPhi->getIncomingValueForBlock(IBB), IBB);

tools/lldb/source/Expression/IRInterpreter.cpp

  992       Value *value = phi_inst->getIncomingValueForBlock(frame.m_prev_bb);

tools/polly/lib/CodeGen/BlockGenerators.cpp

  963     Value *OriginalValue = PHI->getIncomingValueForBlock(MergeBB);
 1759     Value *Op = PHI->getIncomingValueForBlock(IncomingBB);

unittests/Analysis/ScalarEvolutionTest.cpp

 1554       auto *Start = NewCanonicalIV->getIncomingValueForBlock(Incoming);
 1557       auto *Next = NewCanonicalIV->getIncomingValueForBlock(Backedge);

unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp

   93   EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(TrueBB), AddOp1);
   94   EXPECT_EQ(UpdatePhiA->getIncomingValueForBlock(FalseBB), AddOp2);
   99   EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(TrueBB), SubOp1);
  100   EXPECT_EQ(UpdatePhiB->getIncomingValueForBlock(FalseBB), SubOp2);
  192   EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(LoopStartBB), AddOp2);
  193   EXPECT_EQ(UpdatePhi->getIncomingValueForBlock(IfBB), UndefValue::get(I32Ty));