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

References

include/llvm/Analysis/SparsePropagation.h

  436         getValueState(KeyInfo::getLatticeKeyFromValue(PN.getIncomingValue(i)));

include/llvm/IR/Instructions.h

 2736     return getIncomingValue(Idx);

lib/Analysis/BasicAliasAnalysis.cpp

 1619             aliasCheck(PN->getIncomingValue(i), PNSize, PNAAInfo,

lib/Analysis/DivergenceAnalysis.cpp

  170     const auto *InVal = Phi.getIncomingValue(i);
  171     if (isDivergent(*Phi.getIncomingValue(i)) ||

lib/Analysis/IVDescriptors.cpp

  843     BEValue = Phi->getIncomingValue(0);
  844     StartValue = Phi->getIncomingValue(1);
  848     BEValue = Phi->getIncomingValue(1);
  849     StartValue = Phi->getIncomingValue(0);

lib/Analysis/IVUsers.cpp

  155     if (PN->getIncomingValue(i) == Operand &&

lib/Analysis/InlineCost.cpp

  494     Value *V = I.getIncomingValue(i);

lib/Analysis/LazyValueInfo.cpp

  789     Value *PhiVal = PN->getIncomingValue(i);
 1908           Value *Incoming = PHI->getIncomingValue(i);

lib/Analysis/MemoryBuiltins.cpp

 1000     SizeOffsetEvalType EdgeData = compute_(PHI.getIncomingValue(i));

lib/Analysis/ScalarEvolution.cpp

 4699     Value *V = PN->getIncomingValue(i);
 5013     Value *V = PN->getIncomingValue(i);
 7856     auto *CurrentVal = dyn_cast<Constant>(PN->getIncomingValue(i));
 8170                   InitValue = PN->getIncomingValue(i);
 8171                 else if (InitValue != PN->getIncomingValue(i)) {
 8186             const SCEV *OnBackedge = getSCEV(PN->getIncomingValue(InLoopPred));

lib/Analysis/ValueTracking.cpp

 1354         Value *L = P->getIncomingValue(i);
 1355         Value *R = P->getIncomingValue(!i);
 2220       Value *Start = PN->getIncomingValue(0);
 2221       Value *Induction = PN->getIncomingValue(1);
 2585       Tmp = ComputeNumSignBits(PN->getIncomingValue(0), Depth + 1, Q);
 2589             Tmp, ComputeNumSignBits(PN->getIncomingValue(i), Depth + 1, Q));
 3697   auto *PrevValue = dyn_cast<Instruction>(PN->getIncomingValue(0));
 3699     PrevValue = dyn_cast<Instruction>(PN->getIncomingValue(1));

lib/Bitcode/Writer/BitcodeWriter.cpp

 2880       pushValueSigned(PN.getIncomingValue(i), InstID, Vals64);

lib/CodeGen/CodeGenPrepare.cpp

  770             Instruction *Insn = dyn_cast<Instruction>(UPN->getIncomingValue(I));
  853         PN.addIncoming(InValPhi->getIncomingValue(i),
 2018       Value *IncomingVal = PN->getIncomingValue(I)->stripPointerCasts();

lib/CodeGen/GlobalISel/IRTranslator.cpp

 2065       ArrayRef<Register> ValRegs = getOrCreateVRegs(*PI->getIncomingValue(i));

lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp

  433   Value *V = PN->getIncomingValue(0);
  466     Value *V = PN->getIncomingValue(i);

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

  368         ConstantExpr *CE = dyn_cast<ConstantExpr>(PN->getIncomingValue(i));

lib/CodeGen/SjLjEHPrepare.cpp

  300             if (PN->getIncomingValue(i) == &Inst)

lib/CodeGen/WinEHPrepare.cpp

  874           Value *IV = SuccPN.getIncomingValue(OldBlockIdx);
 1129         Value *PredVal = PN->getIncomingValue(i);

lib/ExecutionEngine/Interpreter/Execution.cpp

  997     Value *IncomingValue = PN->getIncomingValue(i);

lib/IR/AsmWriter.cpp

 3763       writeOperand(PN->getIncomingValue(op), false); Out << ", ";

lib/IR/BasicBlock.cpp

  348         if (PN->getIncomingValue(0) != PN)
  349           PN->replaceAllUsesWith(PN->getIncomingValue(0));

lib/IR/Core.cpp

 2949   return wrap(unwrap<PHINode>(PhiNode)->getIncomingValue(Index));

lib/IR/Instructions.cpp

  118   Value *Removed = getIncomingValue(Idx);
  158   Value *ConstantValue = getIncomingValue(0);
  160     if (getIncomingValue(i) != ConstantValue && getIncomingValue(i) != this) {
  160     if (getIncomingValue(i) != ConstantValue && getIncomingValue(i) != this) {
  164       ConstantValue = getIncomingValue(i);
  179     Value *Incoming = getIncomingValue(i);

lib/IR/SafepointIRVerifier.cpp

  669           const Value *InValue = PN->getIncomingValue(i);
  803         const Value *InValue = PN->getIncomingValue(i);

lib/IR/Verifier.cpp

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

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

  867           if (isa<ConstantPointerNull>(Phi->getIncomingValue(I)))

lib/Target/AMDGPU/SIAnnotateControlFlow.cpp

  189       if (Phi->getIncomingValue(i) != BoolTrue)
  193       if (Phi->getIncomingValue(i) != BoolFalse)

lib/Target/Hexagon/HexagonISelLowering.cpp

 1731       Value *BackEdgeVal = PN->getIncomingValue(i);
 1748   return PN->getIncomingValue(Idx);

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 1017       Value *InV = P->getIncomingValue(i);
 1094     Type *Ty0 = P->getIncomingValue(0)->getType();

lib/Target/XCore/XCoreLowerThreadLocal.cpp

  137             if (PN->getIncomingValue(I) == CE) {

lib/Transforms/Coroutines/CoroFrame.cpp

  909       Value *V = PN->getIncomingValue(Index);

lib/Transforms/IPO/Attributor.cpp

  225         Worklist.push_back(PHI->getIncomingValue(u));

lib/Transforms/IPO/FunctionAttrs.cpp

 1010         FlowsToReturn.insert(PN->getIncomingValue(i));

lib/Transforms/IPO/GlobalOpt.cpp

 1126       Value *InVal = PN->getIncomingValue(op);
 1433       Value *InVal = PN->getIncomingValue(i);

lib/Transforms/IPO/PartialInlining.cpp

 1056     Value *CommonValue = PN->getIncomingValue(0);

lib/Transforms/InstCombine/InstCombineCasts.cpp

  217           EvaluateInDifferentType(OPN->getIncomingValue(i), Ty, isSigned);
 1072     if (!canEvaluateZExtd(PN->getIncomingValue(0), Ty, BitsToClear, IC, CxtI))
 1075       if (!canEvaluateZExtd(PN->getIncomingValue(i), Ty, Tmp, IC, CxtI) ||

lib/Transforms/InstCombine/InstCombineCompares.cpp

  720         Value *NewIncoming = PHI->getIncomingValue(I);

lib/Transforms/InstCombine/InstCombinePHI.cpp

   33   auto *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
   40     auto *I = cast<Instruction>(PN.getIncomingValue(i));
  132     Value *Arg = PN.getIncomingValue(i);
  284   Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
  295     Instruction *I = dyn_cast<Instruction>(PN.getIncomingValue(i));
  344       Instruction *InInst = cast<Instruction>(PN.getIncomingValue(i));
  367   NewBinOp->copyIRFlags(PN.getIncomingValue(0));
  370     NewBinOp->andIRFlags(PN.getIncomingValue(i));
  377   GetElementPtrInst *FirstInst =cast<GetElementPtrInst>(PN.getIncomingValue(0));
  394     GetElementPtrInst *GEP= dyn_cast<GetElementPtrInst>(PN.getIncomingValue(i));
  467       GetElementPtrInst *InGEP =cast<GetElementPtrInst>(PN.getIncomingValue(i));
  532   LoadInst *FirstLI = cast<LoadInst>(PN.getIncomingValue(0));
  563     LoadInst *LI = dyn_cast<LoadInst>(PN.getIncomingValue(i));
  619     LoadInst *LI = cast<LoadInst>(PN.getIncomingValue(i));
  731   Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
  766     Instruction *I = dyn_cast<Instruction>(PN.getIncomingValue(i));
  788     Value *NewInVal = cast<Instruction>(PN.getIncomingValue(i))->getOperand(0);
  815     BinOp->copyIRFlags(PN.getIncomingValue(0));
  818       BinOp->andIRFlags(PN.getIncomingValue(i));
  974       InvokeInst *II = dyn_cast<InvokeInst>(PN->getIncomingValue(i));
 1066         Value *InVal = PN->getIncomingValue(i);
 1097         if (PHINode *OldInVal = dyn_cast<PHINode>(PN->getIncomingValue(i)))
 1136   if (isa<Instruction>(PN.getIncomingValue(0)) &&
 1137       isa<Instruction>(PN.getIncomingValue(1)) &&
 1138       cast<Instruction>(PN.getIncomingValue(0))->getOpcode() ==
 1139       cast<Instruction>(PN.getIncomingValue(1))->getOpcode() &&
 1142       PN.getIncomingValue(0)->hasOneUse())
 1187         Value *VA = PN.getIncomingValue(i);
 1207            isa<PHINode>(PN.getIncomingValue(InValNo)))
 1211       Value *NonPhiInVal = PN.getIncomingValue(InValNo);
 1216         Value *OpVal = PN.getIncomingValue(InValNo);
 1242         Value *VA = PN.getIncomingValue(i);
 1244         Value *VB = PN.getIncomingValue(j);

lib/Transforms/InstCombine/InstCombineShifts.cpp

  579       PN->setIncomingValue(i, getShiftedValue(PN->getIncomingValue(i), NumBits,

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  120     Value *PHIInVal = PN->getIncomingValue(i);

lib/Transforms/InstCombine/InstructionCombining.cpp

  954     Value *InVal = PN->getIncomingValue(i);
 1009       Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i));
 1026         InV = Builder.CreateSelect(PN->getIncomingValue(i), TrueVInPred,
 1035       if (Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i)))
 1038         InV = Builder.CreateICmp(CI->getPredicate(), PN->getIncomingValue(i),
 1041         InV = Builder.CreateFCmp(CI->getPredicate(), PN->getIncomingValue(i),
 1047       Value *InV = foldOperationIntoPhiValue(BO, PN->getIncomingValue(i),
 1056       if (Constant *InC = dyn_cast<Constant>(PN->getIncomingValue(i)))
 1059         InV = Builder.CreateCast(CI->getOpcode(), PN->getIncomingValue(i),

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

 1804           Value *V = PN.getIncomingValue(I);

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  966             val, DFSF.getShadow(i->first->getIncomingValue(val)));

lib/Transforms/Instrumentation/PoisonChecking.cpp

  308         auto *OldVal = OldPHI->getIncomingValue(i);

lib/Transforms/ObjCARC/ObjCARC.h

   94       auto *PNOpnd = PN.getIncomingValue(I)->stripPointerCasts();

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

  954           GetRCIdentityRoot(PN->getIncomingValue(i));
 1009               GetRCIdentityRoot(PN->getIncomingValue(i));
 1011               Value *Op = PN->getIncomingValue(i);

lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp

   65         if (related(A->getIncomingValue(i),

lib/Transforms/Scalar/CallSiteSplitting.cpp

  433           if (PN->getIncomingValue(0) == PN->getIncomingValue(1))
  433           if (PN->getIncomingValue(0) == PN->getIncomingValue(1))
  435           if (isa<Constant>(PN->getIncomingValue(0)) &&
  436               isa<Constant>(PN->getIncomingValue(1)))

lib/Transforms/Scalar/ConstantHoisting.cpp

  715         Value *IncomingVal = PHI->getIncomingValue(i);

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  165     Value *Incoming = P->getIncomingValue(i);
  217     Value *Incoming = P->getIncomingValue(i);

lib/Transforms/Scalar/GVN.cpp

 1646         if (uint32_t TransVal = lookup(PN->getIncomingValue(i), false))

lib/Transforms/Scalar/GVNSink.cpp

  240       Ops.push_back({PN->getIncomingBlock(I), PN->getIncomingValue(I)});
  617             return V == PN->getIncomingValue(0);
  620       if (PN->getIncomingValue(0) != PN)
  621         PN->replaceAllUsesWith(PN->getIncomingValue(0));

lib/Transforms/Scalar/IndVarSimplify.cpp

  245     if (PHI->getIncomingValue(i) != Def)
  312   auto *InitValueVal = dyn_cast<ConstantFP>(PN->getIncomingValue(IncomingEdge));
  320   auto *Incr = dyn_cast<BinaryOperator>(PN->getIncomingValue(BackEdge));
  624         Value *InVal = PN->getIncomingValue(i);
  718     Instruction *Inst = cast<Instruction>(PN->getIncomingValue(Phi.Ith));
  790         auto *ExitVal = dyn_cast<PHINode>(PN.getIncomingValue(IncomingValIdx));
  807                               ExitVal->getIncomingValue(PreheaderIdx));
  847       if (Phi.PN == P && (Phi.PN)->getIncomingValue(i) == Incoming) {
 2114   Value *IncV = Phi->getIncomingValue(Idx);
 2206   Value *IncV = Phi->getIncomingValue(LatchIdx);
 2236   Value *IncV = Phi->getIncomingValue(LatchIdx);

lib/Transforms/Scalar/JumpThreading.cpp

  248     Value *PhiOpnd = PN->getIncomingValue(i);
  653       Value *InVal = PN->getIncomingValue(i);
  790           LHS = PN->getIncomingValue(i);
  794           RHS = PN->getIncomingValue(i);
 2467     SelectInst *PredSI = dyn_cast<SelectInst>(CondPHI->getIncomingValue(I));
 2508     SelectInst *SI = dyn_cast<SelectInst>(CondLHS->getIncomingValue(I));

lib/Transforms/Scalar/LoopFuse.cpp

 1234       Value *LCV = LCPHI->getIncomingValue(L1LatchBBIdx);
 1476       Value *LCV = LCPHI->getIncomingValue(L1LatchBBIdx);

lib/Transforms/Scalar/LoopInterchange.cpp

  659   return followLCSSA(PHI->getIncomingValue(0));
  724     Instruction *Ins = dyn_cast<Instruction>(PHI.getIncomingValue(0));
  861         dyn_cast<Instruction>(InnerInductionVar->getIncomingValue(1));
  864         dyn_cast<Instruction>(InnerInductionVar->getIncomingValue(0));
  939      Instruction *IncomingI = dyn_cast<Instruction>(PHI.getIncomingValue(i));
 1235       InnerIndexVar = dyn_cast<Instruction>(InductionPHI->getIncomingValue(1));
 1237       InnerIndexVar = dyn_cast<Instruction>(InductionPHI->getIncomingValue(0));
 1407       auto I = dyn_cast<Instruction>(P.getIncomingValue(0));
 1413       NewPhi->setIncomingValue(0, P.getIncomingValue(0));

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 1474       if (PN->getIncomingValue(i) == OperandValToReplace &&
 2136     ConstantInt *Init = dyn_cast<ConstantInt>(PH->getIncomingValue(Entry));
 2143       dyn_cast<BinaryOperator>(PH->getIncomingValue(Latch));
 5310     if (PN->getIncomingValue(i) == LF.OperandValToReplace) {

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

  187     Value *PhiOpnd = PhiDef->getIncomingValue(i);

lib/Transforms/Scalar/MergeICmps.cpp

  818     if (isa<ConstantInt>(Phi.getIncomingValue(I))) continue;
  824     if (!isa<ICmpInst>(Phi.getIncomingValue(I)) ||
  825         cast<ICmpInst>(Phi.getIncomingValue(I))->getParent() !=

lib/Transforms/Scalar/NewGVN.cpp

 1977         Ops.push_back({PN->getIncomingValue(i), PN->getIncomingBlock(i)});

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 1040         Value *InVal = PN->getIncomingValue(i);
 1054           Value *OldBase = BasePHI->getIncomingValue(BlockIndex);
 1828           if (Def == Phi->getIncomingValue(i)) {
 1998     CurrentIncomingValues[OrigRootPhi.getIncomingValue(i)] =
 2005         CurrentIncomingValues.find(AlternateRootPhi.getIncomingValue(i));

lib/Transforms/Scalar/SCCP.cpp

  802     LatticeVal IV = getValueState(PN.getIncomingValue(i));

lib/Transforms/Scalar/SROA.cpp

 1237     Value *InVal = PN.getIncomingValue(Idx);
 1288     Value *InVal = PN.getIncomingValue(Idx);

lib/Transforms/Scalar/Scalarizer.cpp

  757     Scatterer Op = scatter(&PHI, PHI.getIncomingValue(I));

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  244       Value *Incoming = PN.getIncomingValue(i);

lib/Transforms/Scalar/SpeculateAroundPHIs.cpp

  219     auto *IncomingC = dyn_cast<ConstantInt>(PN.getIncomingValue(i));
  645         IncomingValueMap[OpPN->getIncomingBlock(i)] = OpPN->getIncomingValue(i);

lib/Transforms/Utils/BasicBlockUtils.cpp

  144     if (PN->getIncomingValue(0) != PN)
  145       PN->replaceAllUsesWith(PN->getIncomingValue(0));
  220       if (!isa<PHINode>(PN.getIncomingValue(0)) ||
  221           cast<PHINode>(PN.getIncomingValue(0))->getParent() != BB)
  222         IncomingValues.push_back(PN.getIncomingValue(0));
  545           InVal = PN->getIncomingValue(i);
  546         else if (InVal != PN->getIncomingValue(i)) {

lib/Transforms/Utils/BreakCriticalEdges.cpp

  116     Value *V = PN.getIncomingValue(Idx);

lib/Transforms/Utils/CallPromotionUtils.cpp

   85     auto *V = Phi.getIncomingValue(Idx);

lib/Transforms/Utils/CloneFunction.cpp

  536           Value *InVal = MapValue(PN->getIncomingValue(pred),

lib/Transforms/Utils/CodeExtractor.cpp

  685           NewPN->addIncoming(PN->getIncomingValue(i), PN->getIncomingBlock(i));
  736         NewPN->addIncoming(PN.getIncomingValue(i), PN.getIncomingBlock(i));
 1563           IncomingCodeReplacerVal = PN.getIncomingValue(i);
 1565           assert(IncomingCodeReplacerVal == PN.getIncomingValue(i) &&

lib/Transforms/Utils/DemoteRegToStack.cpp

   71         if (PN->getIncomingValue(i) == &I) {
  132     if (InvokeInst *II = dyn_cast<InvokeInst>(P->getIncomingValue(i))) {
  136     new StoreInst(P->getIncomingValue(i), Slot,

lib/Transforms/Utils/Local.cpp

  675     Value *NewVal = PN->getIncomingValue(0);
  785                             PN->getIncomingValue(PI))) {
  802             !CanMergeValues(Val, PN->getIncomingValue(PI))) {
  860     Value *V = PN->getIncomingValue(i);
  875     Value *V = PN->getIncomingValue(i);
  924       Value *PredVal = OldValPN->getIncomingValue(i);

lib/Transforms/Utils/LoopSimplify.cpp

  197       if (PN->getIncomingValue(i) == PN &&
  244     if (PN->getIncomingValue(i) != PN ||
  403       Value *IV = PN->getIncomingValue(i);
  420       PN->setIncomingValue(0, PN->getIncomingValue(PreheaderIdx));

lib/Transforms/Utils/LoopUnrollAndJam.cpp

  426           Value *OldValue = Phi.getIncomingValue(b);

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  391       Value *InVal = NewPHI->getIncomingValue(idx);
  814        Value *newVal = VMap.lookup(Phi->getIncomingValue(i));
  820          newVal = Phi->getIncomingValue(i);
  821          VMap[Phi->getIncomingValue(i)] = Phi->getIncomingValue(i);
  821          VMap[Phi->getIncomingValue(i)] = Phi->getIncomingValue(i);

lib/Transforms/Utils/LoopVersioning.cpp

  135       if (PN->getIncomingValue(0) == Inst)
  158     Value *ClonedValue = PN->getIncomingValue(0);

lib/Transforms/Utils/SSAUpdater.cpp

   87         PHI->getIncomingValue(i)) {
  246     Value *getIncomingValue() { return PHI->getIncomingValue(idx); }

lib/Transforms/Utils/SimplifyCFG.cpp

 2119     Value *OrigV = PN.getIncomingValue(OrigI);
 2120     Value *ThenV = PN.getIncomingValue(ThenI);
 2203     ConstantInt *CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i));
 2338     if (!DominatesMergePoint(PN->getIncomingValue(0), BB, AggressiveInsts,
 2340         !DominatesMergePoint(PN->getIncomingValue(1), BB, AggressiveInsts,
 2364       (isa<BinaryOperator>(PN->getIncomingValue(0)) ||
 2365        isa<BinaryOperator>(PN->getIncomingValue(1)) ||
 2367       !CanHoistNotFromBothValues(PN->getIncomingValue(0),
 2368                                  PN->getIncomingValue(1)))
 2423     Value *TrueVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfFalse);
 2424     Value *FalseVal = PN->getIncomingValue(PN->getIncomingBlock(0) == IfTrue);
 3333     Value *PBIV = PN->getIncomingValue(PBBIdx);
 3418     Value *PBIV = PN.getIncomingValue(PBBIdx);
 3837     auto *IncomingValue = PhiLPInst->getIncomingValue(Idx);
 3994       Value *SrcVal = DestPN->getIncomingValue(Idx);
 4006           DestPN->addIncoming(SrcPN->getIncomingValue(SrcIdx),
 4534     Value *InValue = PHI.getIncomingValue(Idx);
 4576       if (Phi.getIncomingValue(SwitchBBIdx) == CaseValue &&
 4733         LookupConstant(PHI.getIncomingValue(Idx), ConstantPool);
 6020       if (passingValueIsAlwaysUndefined(PHI.getIncomingValue(i), &PHI)) {

lib/Transforms/Utils/SimplifyIndVar.cpp

  215       Value *Incoming = PN->getIncomingValue(Idx);

lib/Transforms/Vectorize/LoopVectorize.cpp

 3635     if (LCSSAPhi.getIncomingValue(0) == Phi) {
 3828     if (LCSSAPhi.getIncomingValue(0) == LoopExitInst)
 3846       auto *IncomingValue = LCSSAPhi.getIncomingValue(0);
 7317           State.ILV->getOrCreateVectorValue(Phi->getIncomingValue(In), Part);

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4322           if (PH->getIncomingValue(i) == Scalar) {
 6692     Rdx = P->getIncomingValue(0);
 6694     Rdx = P->getIncomingValue(1);
 6711     Rdx = P->getIncomingValue(0);
 6713     Rdx = P->getIncomingValue(1);

lib/Transforms/Vectorize/VPlan.cpp

  676     Phi->getIncomingValue(0)->printAsOperand(O, false);
  680       Phi->getIncomingValue(I)->printAsOperand(O, false);

tools/polly/lib/Analysis/ScopBuilder.cpp

 1095     Value *Op = PHI->getIncomingValue(u);
 2085         dyn_cast<Instruction>(PHI->getIncomingValue(Idx));

tools/polly/lib/CodeGen/BlockGenerators.cpp

  836       Value *ScalarValue = PHI->getIncomingValue(Idx);

tools/polly/lib/Support/SCEVValidator.cpp

  789       Final = PHI->getIncomingValue(i);
  806       V = PHI->getIncomingValue(i);