|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
examples/BrainF/BrainF.cpp 305 phi_0->addIncoming(curhead, bb_0);
439 phi->addIncoming(curhead, builder->GetInsertBlock());
460 phi_1->addIncoming(head_0, testbb);
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp 882 PN->addIncoming(ThenV, ThenBB);
883 PN->addIncoming(ElseV, ElseBB);
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp 882 PN->addIncoming(ThenV, ThenBB);
883 PN->addIncoming(ElseV, ElseBB);
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp 881 PN->addIncoming(ThenV, ThenBB);
882 PN->addIncoming(ElseV, ElseBB);
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp 867 PN->addIncoming(ThenV, ThenBB);
868 PN->addIncoming(ElseV, ElseBB);
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp 891 PN->addIncoming(ThenV, ThenBB);
892 PN->addIncoming(ElseV, ElseBB);
examples/Kaleidoscope/Chapter5/toy.cpp 668 PN->addIncoming(ThenV, ThenBB);
669 PN->addIncoming(ElseV, ElseBB);
709 Variable->addIncoming(StartVal, PreheaderBB);
756 Variable->addIncoming(NextVar, LoopEndBB);
examples/Kaleidoscope/Chapter6/toy.cpp 780 PN->addIncoming(ThenV, ThenBB);
781 PN->addIncoming(ElseV, ElseBB);
821 Variable->addIncoming(StartVal, PreheaderBB);
868 Variable->addIncoming(NextVar, LoopEndBB);
examples/Kaleidoscope/Chapter7/toy.cpp 887 PN->addIncoming(ThenV, ThenBB);
888 PN->addIncoming(ElseV, ElseBB);
examples/Kaleidoscope/Chapter8/toy.cpp 886 PN->addIncoming(ThenV, ThenBB);
887 PN->addIncoming(ElseV, ElseBB);
examples/Kaleidoscope/Chapter9/toy.cpp 1049 PN->addIncoming(ThenV, ThenBB);
1050 PN->addIncoming(ElseV, ElseBB);
lib/Analysis/MemoryBuiltins.cpp 1011 SizePHI->addIncoming(EdgeData.first, PHI.getIncomingBlock(i));
1012 OffsetPHI->addIncoming(EdgeData.second, PHI.getIncomingBlock(i));
lib/Analysis/ScalarEvolutionExpander.cpp 1306 PN->addIncoming(StartV, Pred);
1324 PN->addIncoming(IncV, Pred);
1576 CanonicalIV->addIncoming(CanonicalIV->getIncomingValueForBlock(HP), HP);
1588 CanonicalIV->addIncoming(Add, HP);
1590 CanonicalIV->addIncoming(Constant::getNullValue(Ty), HP);
lib/AsmParser/LLParser.cpp 6696 PN->addIncoming(PHIVals[i].first, PHIVals[i].second);
lib/Bitcode/Reader/BitcodeReader.cpp 4662 PN->addIncoming(V, BB);
lib/CodeGen/AtomicExpandPass.cpp 886 Loaded_MaskOut->addIncoming(InitLoaded_MaskOut, BB);
920 Loaded_MaskOut->addIncoming(OldVal_MaskOut, FailureBB);
1253 Success->addIncoming(ConstantInt::getTrue(Ctx), SuccessBB);
1254 Success->addIncoming(ConstantInt::getFalse(Ctx), FailureBB);
1263 TryStoreLoaded->addIncoming(UnreleasedLoad, ReleasingStoreBB);
1264 TryStoreLoaded->addIncoming(SecondLoad, ReleasedLoadBB);
1268 NoStoreLoaded->addIncoming(UnreleasedLoad, StartBB);
1269 NoStoreLoaded->addIncoming(SecondLoad, ReleasedLoadBB);
1273 ExitLoaded->addIncoming(TryStoreLoaded, SuccessBB);
1274 ExitLoaded->addIncoming(NoStoreLoaded, FailureBB);
1385 Loaded->addIncoming(InitLoaded, BB);
1399 Loaded->addIncoming(NewLoaded, LoopBB);
lib/CodeGen/CodeGenPrepare.cpp 853 PN.addIncoming(InValPhi->getIncomingValue(i),
860 PN.addIncoming(InVal, BBPN->getIncomingBlock(i));
863 PN.addIncoming(InVal, *PI);
1763 PN->addIncoming(BitWidth, StartBlock);
1764 PN->addIncoming(CountZeros, CallBlock);
3404 PHI->addIncoming(ST.Get(Map[PV]), B);
6085 PN->addIncoming(getTrueOrFalseValue(SI, true, INS), TrueBlock);
6086 PN->addIncoming(getTrueOrFalseValue(SI, false, INS), FalseBlock);
7263 PN.addIncoming(Val, TmpBB);
lib/CodeGen/DwarfEHPrepare.cpp 244 PN->addIncoming(ExnObj, Parent);
lib/CodeGen/ExpandMemCmp.cpp 294 PhiRes->addIncoming(Diff, LoadCmpBlocks[BlockIndex]);
421 PhiRes->addIncoming(Zero, LoadCmpBlocks[BlockIndex]);
474 ResBlock.PhiSrc1->addIncoming(LoadSrc1, LoadCmpBlocks[BlockIndex]);
475 ResBlock.PhiSrc2->addIncoming(LoadSrc2, LoadCmpBlocks[BlockIndex]);
492 PhiRes->addIncoming(Zero, LoadCmpBlocks[BlockIndex]);
506 PhiRes->addIncoming(Res, ResBlock.BB);
523 PhiRes->addIncoming(Res, ResBlock.BB);
lib/CodeGen/HardwareLoops.cpp 435 Index->addIncoming(NumElts, Preheader);
436 Index->addIncoming(EltsRem, Latch);
lib/CodeGen/IndirectBrExpandPass.cpp 203 SwitchPN->addIncoming(GetSwitchValue(IBr), IBr->getParent());
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp 227 Phi->addIncoming(NewVResult, CondBlock);
228 Phi->addIncoming(VResult, PrevIfBlock);
476 Phi->addIncoming(NewVResult, CondBlock);
477 Phi->addIncoming(VResult, PrevIfBlock);
692 ResultPhi->addIncoming(NewVResult, CondBlock);
693 ResultPhi->addIncoming(VResult, PrevIfBlock);
699 PtrPhi->addIncoming(NewPtr, CondBlock);
700 PtrPhi->addIncoming(Ptr, PrevIfBlock);
799 PtrPhi->addIncoming(NewPtr, CondBlock);
800 PtrPhi->addIncoming(Ptr, PrevIfBlock);
lib/CodeGen/WinEHPrepare.cpp 883 SuccPN.addIncoming(IV, NewBlock);
lib/FuzzMutate/Operations.cpp 159 PHI.addIncoming(UndefValue::get(PHI.getType()), Block);
lib/IR/Core.cpp 2941 PhiVal->addIncoming(unwrap(IncomingValues[I]), unwrap(IncomingBlocks[I]));
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp 584 PHI->addIncoming(UndefValue::get(Ty), EntryBB);
585 PHI->addIncoming(NewI, SingleLaneTerminator->getParent());
647 PHI->addIncoming(UndefValue::get(Ty), PixelEntryBB);
648 PHI->addIncoming(Result, I.getParent());
lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp 145 PN->addIncoming(BB->getTerminator()->getOperand(0), BB);
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp 282 Broken->addIncoming(PHIValue, Pred);
lib/Target/ARM/MVETailPredication.cpp 478 Processed->addIncoming(NumElements, L->getLoopPreheader());
501 Processed->addIncoming(Remaining, L->getLoopLatch());
lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp 641 NewPhi->addIncoming(InstInPreheader, LoopPH);
642 NewPhi->addIncoming(BEVal, BB);
lib/Target/PowerPC/PPCBoolRetToInt.cpp 105 Q->addIncoming(Zero, P->getIncomingBlock(i));
lib/Target/PowerPC/PPCLoopPreIncPrep.cpp 384 NewPHI->addIncoming(BasePtrStart, LoopPredecessor);
396 NewPHI->addIncoming(PtrInc, PI);
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp 590 LabelPHI->addIncoming(ThenLabel, EndBB2);
592 LabelPHI->addIncoming(IRB.getInt32(-1), ElseBB1);
925 SetjmpRet->addIncoming(IRB.getInt32(0), BB);
1039 SetjmpRetPHIs[I]->addIncoming(LongjmpResult, EndBB);
lib/Transforms/Coroutines/CoroFrame.cpp 851 LandingPadReplacement->addIncoming(NewLP, NewBB);
913 InputV->addIncoming(V, Pred);
lib/Transforms/Coroutines/CoroSplit.cpp 349 PN->addIncoming(Builder.getInt8(-1), SuspendBB);
350 PN->addIncoming(S, ResumeBB);
1302 ReturnPHIs[0]->addIncoming(Continuation, SuspendBB);
1305 ReturnPHIs[NextPHIIndex++]->addIncoming(&*VUse, SuspendBB);
lib/Transforms/IPO/GlobalOpt.cpp 1436 FieldPN->addIncoming(InVal, PN->getIncomingBlock(i));
lib/Transforms/IPO/LowerTypeTests.cpp 791 Phi.addIncoming(Phi.getIncomingValueForBlock(Then), InitialBB);
808 P->addIncoming(ConstantInt::get(Int1Ty, 0), InitialBB);
809 P->addIncoming(Bit, ThenB.GetInsertBlock());
lib/Transforms/IPO/PartialInlining.cpp 1078 RetPhi->addIncoming(&*I, PreReturn);
1080 RetPhi->addIncoming(OldPhi->getIncomingValueForBlock(E), E);
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/InstCombineLoadStoreAlloca.cpp 1574 PN->addIncoming(SI.getOperand(0), SI.getParent());
1575 PN->addIncoming(OtherStore->getOperand(0), OtherBB);
lib/Transforms/InstCombine/InstCombinePHI.cpp 239 NewPtrPHI->addIncoming(IncomingVal, IncomingBB);
273 NewPtrPHI->addIncoming(CI, IncomingBB);
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));
472 OpPhi->addIncoming(InGEP->getOperand(op), InBB);
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));
1061 EltPHI->addIncoming(PredVal, Pred);
1069 EltPHI->addIncoming(PredVal, Pred);
1078 EltPHI->addIncoming(PredVal, Pred);
1091 EltPHI->addIncoming(Res, Pred);
lib/Transforms/InstCombine/InstCombineVectorOps.cpp 137 scalarPHI->addIncoming(newPHIUser, inBB);
152 scalarPHI->addIncoming(newEI, inBB);
lib/Transforms/InstCombine/InstructionCombining.cpp 1029 NewPN->addIncoming(InV, ThisBB);
1043 NewPN->addIncoming(InV, PN->getIncomingBlock(i));
1049 NewPN->addIncoming(InV, PN->getIncomingBlock(i));
1061 NewPN->addIncoming(InV, PN->getIncomingBlock(i));
1780 NewPN->addIncoming(cast<GEPOperator>(I)->getOperand(DI),
lib/Transforms/Instrumentation/AddressSanitizer.cpp 2924 PHI->addIncoming(ValueIfFalse, CondBlock);
2926 PHI->addIncoming(ValueIfTrue, ThenBlock);
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 1620 PN->addIncoming(&I, Pred);
1808 PN.addIncoming(V, cast<BasicBlock>(VMap[Pred]));
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 1139 Phi->addIncoming(Call, Call->getParent());
1140 Phi->addIncoming(V1, Head);
1287 Shadow->addIncoming(FallbackCall, FallbackBB);
1288 Shadow->addIncoming(TruncShadow, LastBr->getParent());
1773 ShadowPN->addIncoming(UndefShadow, *i);
lib/Transforms/Instrumentation/GCOVProfiling.cpp 824 Phi->addIncoming(EdgeCounter, Pred);
1097 IV->addIncoming(Builder.getInt32(0), BB);
1130 JV->addIncoming(Builder.getInt32(0), FileLoopHeader);
1172 JV->addIncoming(NextJV, CounterLoopHeader);
1181 IV->addIncoming(NextIV, FileLoopLatch);
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 955 ThreadLongPhi->addIncoming(ThreadLong, ThreadLong->getParent());
956 ThreadLongPhi->addIncoming(ReloadThreadLong, ReloadThreadLong->getParent());
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 267 NewPHI->addIncoming(UndefValue::get(Int1Ty),
lib/Transforms/Scalar/CallSiteSplitting.cpp 353 CallPN->addIncoming(NewCI, SplitBlock);
405 NewPN->addIncoming(Mapping[CurrentI],
lib/Transforms/Scalar/GVN.cpp 2390 Phi->addIncoming(V, predMap[i].second);
2392 Phi->addIncoming(PREInstr, PREPred);
lib/Transforms/Scalar/GVNSink.cpp 855 PN->addIncoming(I->getOperand(O), I->getParent());
lib/Transforms/Scalar/IndVarSimplify.cpp 459 NewPHI->addIncoming(ConstantInt::get(Int32Ty, InitValue),
465 NewPHI->addIncoming(NewAdd, PN->getIncomingBlock(BackEdge));
1565 WidePhi->addIncoming(DU.WideDef, UsePhi->getIncomingBlock(0));
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 1172 PN.addIncoming(GetClonedValue(OldIncoming), ClonedBB);
1315 NewPHI->addIncoming(PN.getIncomingValueForBlock(Preheader), Preheader);
1316 NewPHI->addIncoming(PN.getIncomingValueForBlock(LS.Latch),
1323 RRI.IndVarEnd->addIncoming(IndVarStart, Preheader);
1324 RRI.IndVarEnd->addIncoming(IndVarBase, RRI.ExitSelector);
lib/Transforms/Scalar/InferAddressSpaces.cpp 478 NewPHI->addIncoming(NewPointerOperands[OperandNo],
lib/Transforms/Scalar/JumpThreading.cpp 1514 PN->addIncoming(PredV, I->first);
1919 PN.addIncoming(IV, NewPred);
2003 NewPN->addIncoming(PN->getIncomingValueForBlock(PredBB), PredBB);
2445 SIUse->addIncoming(SI->getTrueValue(), NewBB);
2456 Phi->addIncoming(Phi->getIncomingValueForBlock(Pred), NewBB);
2612 NewPN->addIncoming(SI->getTrueValue(), Term->getParent());
2613 NewPN->addIncoming(SI->getFalseValue(), BB);
2748 NewPN->addIncoming(UnguardedMapping[Inst], UnguardedBlock);
2749 NewPN->addIncoming(GuardedMapping[Inst], GuardedBlock);
lib/Transforms/Scalar/LICM.cpp 1426 OpPN->addIncoming(OInst, PN.getIncomingBlock(i));
1758 PN->addIncoming(I, Pred);
lib/Transforms/Scalar/LoopFuse.cpp 1238 L1HeaderPHI->addIncoming(LCV, FC0.Latch);
1239 L1HeaderPHI->addIncoming(UndefValue::get(LCV->getType()),
1480 L1HeaderPHI->addIncoming(LCV, FC0.Latch);
1481 L1HeaderPHI->addIncoming(UndefValue::get(LCV->getType()),
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 1762 TcPhi->addIncoming(Count, Preheader);
1763 TcPhi->addIncoming(TcDec, Body);
1869 TcPhi->addIncoming(TripCnt, PreHead);
1870 TcPhi->addIncoming(TcDec, Body);
lib/Transforms/Scalar/LoopLoadElimination.cpp 443 PHI->addIncoming(Initial, PH);
444 PHI->addIncoming(Cand.Store->getOperand(0), L->getLoopLatch());
lib/Transforms/Scalar/LoopStrengthReduce.cpp 2174 NewPH->addIncoming(NewInit, PH->getIncomingBlock(Entry));
2175 NewPH->addIncoming(NewIncr, PH->getIncomingBlock(Latch));
lib/Transforms/Scalar/LoopUnswitch.cpp 1324 PN.addIncoming(V, NewExit);
1336 PN->addIncoming(LPI, BB);
lib/Transforms/Scalar/MergeICmps.cpp 665 Phi.addIncoming(IsEqual, BB);
670 Phi.addIncoming(ConstantInt::getFalse(Context), BB);
lib/Transforms/Scalar/MergedLoadStoreMotion.cpp 220 NewPN->addIncoming(Opd1, S0->getParent());
221 NewPN->addIncoming(Opd2, S1->getParent());
lib/Transforms/Scalar/NewGVN.cpp 2835 ValuePHI->addIncoming(PHIOp.first, PHIOp.second);
lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp 82 Phi->addIncoming(Call, &CurrBB);
83 Phi->addIncoming(LibCall, LibCallBB);
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 1055 BasePHI->addIncoming(OldBase, InBB);
1075 BasePHI->addIncoming(Base, InBB);
lib/Transforms/Scalar/SROA.cpp 1295 NewPN->addIncoming(V, Pred);
1309 NewPN->addIncoming(Load, Pred);
lib/Transforms/Scalar/Scalarizer.cpp 760 cast<PHINode>(Res[J])->addIncoming(Op[J], IncomingBlock);
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 249 NewPN->addIncoming(Incoming, &OldPH);
255 NewPN->addIncoming(&PN, &ExitBB);
1056 MergePN->addIncoming(&I, ExitBB);
1057 MergePN->addIncoming(&ClonedI, ClonedExitBB);
lib/Transforms/Scalar/SimplifyCFGPass.cpp 130 RetBlockPHI->addIncoming(InVal, *PI);
137 RetBlockPHI->addIncoming(Ret->getOperand(0), &BB);
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp 709 SpecIPN->addIncoming(SpeculatedVals[PredIdx], SpecPreds[PredIdx]);
lib/Transforms/Scalar/StructurizeCFG.cpp 597 Phi.addIncoming(Undef, From);
lib/Transforms/Scalar/TailRecursionElimination.cpp 599 PN->addIncoming(&*I, NewEntry);
621 ArgumentPHIs[i]->addIncoming(CI->getArgOperand(i), BB);
645 AccPN->addIncoming(AccumulatorRecursionEliminationInitVal, P);
647 AccPN->addIncoming(AccPN, P);
653 AccPN->addIncoming(AccRecInstr, BB);
662 AccPN->addIncoming(Ret->getReturnValue(), BB);
lib/Transforms/Utils/BasicBlockUtils.cpp 568 PN->addIncoming(InVal, NewBB);
586 NewPHI->addIncoming(V, IncomingBB);
590 PN->addIncoming(NewPHI, NewBB);
647 cast<PHINode>(I)->addIncoming(UndefValue::get(I->getType()), NewBB);
754 PN->addIncoming(Clone1, NewBB1);
755 PN->addIncoming(Clone2, NewBB2);
lib/Transforms/Utils/BreakCriticalEdges.cpp 129 NewPN->addIncoming(V, Preds[i]);
455 NewIndPHI->addIncoming(IndPHI->getIncomingValueForBlock(IBRPred),
462 MergePHI->addIncoming(NewIndPHI, Target);
463 MergePHI->addIncoming(DirPHI, DirectSucc);
lib/Transforms/Utils/BypassSlowDivision.cpp 316 QuoPhi->addIncoming(LHS.Quotient, LHS.BB);
317 QuoPhi->addIncoming(RHS.Quotient, RHS.BB);
319 RemPhi->addIncoming(LHS.Remainder, LHS.BB);
320 RemPhi->addIncoming(RHS.Remainder, RHS.BB);
lib/Transforms/Utils/CallPromotionUtils.cpp 87 Phi.addIncoming(V, ElseBlock);
117 Phi->addIncoming(OrigInst, OrigInst->getParent());
118 Phi->addIncoming(NewInst, NewInst->getParent());
lib/Transforms/Utils/CodeExtractor.cpp 679 NewPN->addIncoming(PN, OldPred);
685 NewPN->addIncoming(PN->getIncomingValue(i), PN->getIncomingBlock(i));
736 NewPN->addIncoming(PN.getIncomingValue(i), PN.getIncomingBlock(i));
739 PN.addIncoming(NewPN, NewBB);
lib/Transforms/Utils/InlineFunction.cpp 156 phi->addIncoming(UnwindDestPHIValues[i], src);
185 InnerPHI->addIncoming(OuterPHI, OuterResumeDest);
192 InnerEHValuesPHI->addIncoming(CallerLPad, OuterResumeDest);
213 InnerEHValuesPHI->addIncoming(RI->getOperand(0), Src);
667 PHI->addIncoming(V, Src);
2330 PHI->addIncoming(RI->getReturnValue(), RI->getParent());
lib/Transforms/Utils/IntegerDivision.cpp 344 Carry_1->addIncoming(Zero, Preheader);
345 Carry_1->addIncoming(Carry, DoWhile);
347 SR_3->addIncoming(SR_1, Preheader);
348 SR_3->addIncoming(SR_2, DoWhile);
350 R_1->addIncoming(Tmp3, Preheader);
351 R_1->addIncoming(R, DoWhile);
353 Q_2->addIncoming(Q, Preheader);
354 Q_2->addIncoming(Q_1, DoWhile);
356 Carry_2->addIncoming(Zero, BB1);
357 Carry_2->addIncoming(Carry, DoWhile);
359 Q_3->addIncoming(Q, BB1);
360 Q_3->addIncoming(Q_1, DoWhile);
362 Q_5->addIncoming(Q_4, LoopExit);
363 Q_5->addIncoming(RetVal, SpecialCases);
lib/Transforms/Utils/LCSSA.cpp 153 PN->addIncoming(I, Pred);
lib/Transforms/Utils/Local.cpp 930 PN->addIncoming(Selected, PredBB);
942 PN->addIncoming(Selected, PredBB);
lib/Transforms/Utils/LoopRotationUtils.cpp 389 PN->addIncoming(PN->getIncomingValueForBlock(OrigHeader), OrigPreheader);
lib/Transforms/Utils/LoopSimplify.cpp 407 NewPN->addIncoming(IV, IBB);
428 PN->addIncoming(NewPN, BEBlock);
lib/Transforms/Utils/LoopUnroll.cpp 646 PHI.addIncoming(Incoming, New);
708 PN->addIncoming(InVal, Latches.back());
lib/Transforms/Utils/LoopUnrollPeel.cpp 560 PHI.addIncoming(LatchVal, cast<BasicBlock>(VMap[Edge.first]));
lib/Transforms/Utils/LoopUnrollRuntime.cpp 107 NewPN->addIncoming(PN.getIncomingValueForBlock(NewPreHeader),
111 NewPN->addIncoming(UndefValue::get(PN.getType()), PreHeader);
122 NewPN->addIncoming(V, PrologLatch);
130 PN.addIncoming(NewPN, PrologExit);
223 PN.addIncoming(UndefValue::get(PN.getType()), PreHeader);
232 EpilogPN->addIncoming(V, EpilogLatch);
259 NewPN->addIncoming(PN.getIncomingValueForBlock(NewPreHeader), PreHeader);
261 NewPN->addIncoming(PN.getIncomingValueForBlock(Latch), Latch);
366 NewIdx->addIncoming(NewIter, InsertTop);
367 NewIdx->addIncoming(IdxSub, NewBB);
823 Phi->addIncoming(newVal,
908 NewIdx->addIncoming(TestVal, NewPreHeader);
909 NewIdx->addIncoming(IdxSub, Latch);
lib/Transforms/Utils/LoopVersioning.cpp 148 PN->addIncoming(Inst, VersionedLoop->getExitingBlock());
163 PN->addIncoming(ClonedValue, NonVersionedLoop->getExitingBlock());
lib/Transforms/Utils/LowerMemIntrinsics.cpp 71 LoopIndex->addIncoming(ConstantInt::get(TypeOfCopyLen, 0U), PreLoopBB);
82 LoopIndex->addIncoming(NewIndex, LoopBB);
181 LoopIndex->addIncoming(ConstantInt::get(CopyLenType, 0U), PreLoopBB);
190 LoopIndex->addIncoming(NewIndex, LoopBB);
228 ResidualIndex->addIncoming(Zero, ResHeaderBB);
244 ResidualIndex->addIncoming(ResNewIndex, ResLoopBB);
342 LoopPhi->addIncoming(IndexPtr, LoopBB);
343 LoopPhi->addIncoming(CopyLen, CopyBackwardsBB);
361 FwdCopyPhi->addIncoming(FwdIndexPtr, FwdLoopBB);
362 FwdCopyPhi->addIncoming(ConstantInt::get(TypeOfCopyLen, 0), CopyForwardBB);
393 LoopIndex->addIncoming(ConstantInt::get(TypeOfCopyLen, 0), OrigBB);
402 LoopIndex->addIncoming(NewIndex, LoopBB);
lib/Transforms/Utils/PromoteMemoryToRegister.cpp 761 SomePHI->addIncoming(UndefVal, Pred);
909 APN->addIncoming(IncomingVals[AllocaNo], Pred);
lib/Transforms/Utils/SSAUpdater.cpp 166 InsertedPHI->addIncoming(PredValue.second, PredValue.first);
288 PHI->addIncoming(Val, Pred);
lib/Transforms/Utils/SSAUpdaterBulk.cpp 171 PN->addIncoming(computeValueAt(Pred, R, DT), Pred);
lib/Transforms/Utils/SimplifyCFG.cpp 305 PN.addIncoming(PN.getIncomingValueForBlock(ExistPred), NewPred);
1597 PN->addIncoming(I->getOperand(O), I->getParent());
2937 PHI->addIncoming(V, BB);
2940 PHI->addIncoming(
3257 NewPN->addIncoming(
3261 NewPN->addIncoming(BI->getCondition(), P);
3685 PHIUse->addIncoming(NewCst, NewBB);
3797 PN->addIncoming(InVal, BB);
4006 DestPN->addIncoming(SrcPN->getIncomingValue(SrcIdx),
4014 DestPN->addIncoming(SrcVal, pred);
4038 PN->addIncoming(PN, pred);
4868 PHI->addIncoming(SelectValue, SelectBB);
5509 PHI->addIncoming(Result, LookupBB);
lib/Transforms/Utils/UnifyFunctionExitNodes.cpp 107 PN->addIncoming(BB->getTerminator()->getOperand(0), BB);
lib/Transforms/Vectorize/LoopVectorize.cpp 1747 VecInd->addIncoming(SteppedStart, LoopVectorPreHeader);
1748 VecInd->addIncoming(LastInduction, LoopVectorLatch);
2542 Induction->addIncoming(Start, L->getLoopPreheader());
2543 Induction->addIncoming(Next, Latch);
3028 BCResumeVal->addIncoming(EndValue, MiddleBlock);
3034 BCResumeVal->addIncoming(II.getStartValue(), BB);
3162 PHI->addIncoming(I.second, MiddleBlock);
3548 VecPhi->addIncoming(VectorInit, LoopVectorPreHeader);
3592 VecPhi->addIncoming(Incoming, LI->getLoopFor(LoopVectorBody)->getLoopLatch());
3623 Start->addIncoming(Incoming, BB);
3636 LCSSAPhi.addIncoming(ExtractForPhiUsedOutsideLoop, LoopMiddleBlock);
3709 cast<PHINode>(VecRdxPhi)->addIncoming(StartVal, LoopVectorPreHeader);
3711 ->addIncoming(Val, LI->getLoopFor(LoopVectorBody)->getLoopLatch());
3814 BCBlockPhi->addIncoming(ReductionStartValue, LoopBypassBlocks[I]);
3815 BCBlockPhi->addIncoming(ReducedPartRdx, LoopMiddleBlock);
3829 LCSSAPhi.addIncoming(ReducedPartRdx, LoopMiddleBlock);
3859 LCSSAPhi.addIncoming(lastIncomingValue, LoopMiddleBlock);
3959 NewPhi->addIncoming(NewIncV, NewPredBB);
7417 VPhi->addIncoming(IEI->getOperand(0), PredicatingBB); // Unmodified vector.
7418 VPhi->addIncoming(IEI, PredicatedBB); // New vector with inserted element.
7423 Phi->addIncoming(UndefValue::get(ScalarPredInst->getType()), PredicatingBB);
7424 Phi->addIncoming(ScalarPredInst, PredicatedBB);
lib/Transforms/Vectorize/SLPVectorizer.cpp 3777 NewPhi->addIncoming(NewPhi->getIncomingValueForBlock(IBB), IBB);
3784 NewPhi->addIncoming(Vec, IBB);
tools/bugpoint/Miscompilation.cpp 905 FuncPtr->addIncoming(CastedResolver, LookupBB);
906 FuncPtr->addIncoming(CachedVal, EntryBB);
tools/clang/lib/CodeGen/CGAtomic.cpp 1779 PHI->addIncoming(OldVal, CurBB);
1792 PHI->addIncoming(Res.first, CGF.Builder.GetInsertBlock());
1861 PHI->addIncoming(OldVal, CurBB);
1872 PHI->addIncoming(Res.first, CGF.Builder.GetInsertBlock());
tools/clang/lib/CodeGen/CGBuiltin.cpp 936 Result->addIncoming(ResZero, Begin);
957 Result->addIncoming(ResOne, NotZero);
2316 Result->addIncoming(ZeroLiteral, Begin);
2324 Result->addIncoming(NanLiteral, NotZero);
2335 Result->addIncoming(InfLiteral, NotNan);
2348 Result->addIncoming(NormalResult, NotInf);
2515 DstPhi->addIncoming(Dst, Entry);
2517 SrcPhi->addIncoming(Src, Entry);
2519 SizePhi->addIncoming(Size, Entry);
2538 DstPhi->addIncoming(NextDst, Next);
2539 SrcPhi->addIncoming(NextSrc, Next);
2540 SizePhi->addIncoming(NextSize, Next);
2544 Ret->addIncoming(ConstantInt::get(IntTy, 0), Entry);
2545 Ret->addIncoming(ConstantInt::get(IntTy, 1), CmpGT);
2546 Ret->addIncoming(ConstantInt::get(IntTy, -1), CmpLT);
2547 Ret->addIncoming(ConstantInt::get(IntTy, 0), Next);
2962 Result->addIncoming(RMW, BBs[i]);
tools/clang/lib/CodeGen/CGCall.cpp 3321 phiToUse->addIncoming(valueToUse, copyBB);
3322 phiToUse->addIncoming(llvm::UndefValue::get(valueToUse->getType()),
tools/clang/lib/CodeGen/CGClass.cpp 367 PHI->addIncoming(Value.getPointer(), notNullBB);
368 PHI->addIncoming(llvm::Constant::getNullValue(BasePtrTy), origBB);
427 PHI->addIncoming(Value, CastNotNull);
428 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
1951 cur->addIncoming(arrayBegin, entryBB);
2004 cur->addIncoming(next, Builder.GetInsertBlock());
tools/clang/lib/CodeGen/CGCoroutine.cpp 592 Phi->addIncoming(NullPtr, EntryBB);
593 Phi->addIncoming(AllocateCall, AllocOrInvokeContBB);
tools/clang/lib/CodeGen/CGDecl.cpp 1726 Cur->addIncoming(Begin.getPointer(), OriginBB);
1736 Cur->addIncoming(Next, LoopBB);
2165 elementPast->addIncoming(end, entryBB);
2185 elementPast->addIncoming(element, Builder.GetInsertBlock());
tools/clang/lib/CodeGen/CGExpr.cpp 4266 phi->addIncoming(lhs->getPointer(), lhsBlock);
4267 phi->addIncoming(rhs->getPointer(), rhsBlock);
tools/clang/lib/CodeGen/CGExprAgg.cpp 596 currentElement->addIncoming(element, entryBB);
626 currentElement->addIncoming(nextElement, Builder.GetInsertBlock());
1673 index->addIncoming(zero, entryBB);
1715 index->addIncoming(nextIndex, Builder.GetInsertBlock());
tools/clang/lib/CodeGen/CGExprCXX.cpp 1229 CurPtrPhi->addIncoming(CurPtr.getPointer(), EntryBB);
1265 CurPtrPhi->addIncoming(NextPtr, Builder.GetInsertBlock());
1741 PHI->addIncoming(resultPtr, notNullBB);
1742 PHI->addIncoming(llvm::Constant::getNullValue(resultPtr->getType()),
2264 PHI->addIncoming(Value, CastNotNull);
2265 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
tools/clang/lib/CodeGen/CGExprComplex.cpp 742 RealPHI->addIncoming(ResR, OrigBB);
743 RealPHI->addIncoming(ResR, INaNBB);
744 RealPHI->addIncoming(LibCallR, LibCallBB);
746 ImagPHI->addIncoming(ResI, OrigBB);
747 ImagPHI->addIncoming(ResI, INaNBB);
748 ImagPHI->addIncoming(LibCallI, LibCallBB);
1045 RealPN->addIncoming(LHS.first, LHSBlock);
1046 RealPN->addIncoming(RHS.first, RHSBlock);
1050 ImagPN->addIncoming(LHS.second, LHSBlock);
1051 ImagPN->addIncoming(RHS.second, RHSBlock);
tools/clang/lib/CodeGen/CGExprScalar.cpp 2403 atomicPHI->addIncoming(value, startBB);
2566 atomicPHI->addIncoming(old, curBlock);
2897 atomicPHI->addIncoming(OpInfo.LHS, startBB);
2922 atomicPHI->addIncoming(old, curBlock);
3150 phi->addIncoming(result, initialBB);
3151 phi->addIncoming(handlerResult, overflowBB);
3646 BaseCheck->addIncoming(Builder.getTrue(), Orig);
3647 BaseCheck->addIncoming(ValidBase, CheckShiftBase);
4016 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
4034 PN->addIncoming(RHSCond, RHSBlock);
4101 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);
4118 PN->addIncoming(RHSCond, RHSBlock);
4283 PN->addIncoming(LHS, LHSBlock);
4284 PN->addIncoming(RHS, RHSBlock);
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 369 PHIs[I]->addIncoming(StartAddrs[I].getPointer(), PreheaderBB);
402 PHIs[I]->addIncoming(NewAddrs[I].getPointer(), LoopBB);
tools/clang/lib/CodeGen/CGObjC.cpp 1748 index->addIncoming(zero, LoopInitBB);
1752 count->addIncoming(initialBufferLimit, LoopInitBB);
1872 index->addIncoming(indexPlusOne, AfterBody.getBlock());
1873 count->addIncoming(count, AfterBody.getBlock());
1887 index->addIncoming(zero, Builder.GetInsertBlock());
1888 count->addIncoming(refetchCount, Builder.GetInsertBlock());
tools/clang/lib/CodeGen/CGObjCGNU.cpp 2735 phi->addIncoming(v, messageBB);
2736 phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
2744 phi->addIncoming(v.getPointer(), messageBB);
2745 phi->addIncoming(NullVal.getPointer(), startBB);
2750 phi->addIncoming(v.first, messageBB);
2751 phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
2754 phi2->addIncoming(v.second, messageBB);
2755 phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
tools/clang/lib/CodeGen/CGObjCMac.cpp 1786 phi->addIncoming(result.getScalarVal(), callBB);
1787 phi->addIncoming(null, NullBB);
1813 real->addIncoming(callResult.first, callBB);
1814 real->addIncoming(scalarZero, NullBB);
1816 imag->addIncoming(callResult.second, callBB);
1817 imag->addIncoming(scalarZero, NullBB);
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 900 SrcElementPHI->addIncoming(SrcBegin, EntryBB);
907 DestElementPHI->addIncoming(DestBegin, EntryBB);
927 SrcElementPHI->addIncoming(SrcElementNext, CGF.Builder.GetInsertBlock());
937 DestElementPHI->addIncoming(DestElementNext, CGF.Builder.GetInsertBlock());
5501 RHSElementPHI->addIncoming(RHSBegin, EntryBB);
5508 LHSElementPHI->addIncoming(LHSBegin, EntryBB);
5530 LHSElementPHI->addIncoming(LHSElementNext, CGF.Builder.GetInsertBlock());
5531 RHSElementPHI->addIncoming(RHSElementNext, CGF.Builder.GetInsertBlock());
8919 PtrPHI->addIncoming(PtrBegin, EntryBB);
8979 MemberMapType->addIncoming(OriMapType, MemberBB);
8980 MemberMapType->addIncoming(CombinedMember, MemberCombineBB);
9039 CurMapType->addIncoming(AllocMapType, AllocBB);
9040 CurMapType->addIncoming(ToMapType, ToBB);
9041 CurMapType->addIncoming(FromMapType, FromBB);
9042 CurMapType->addIncoming(MemberMapType, ToElseBB);
9059 PtrPHI->addIncoming(PtrNext, BodyBB);
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 2195 Phi->addIncoming(RecPtr.getPointer(), SPMDBB);
2196 Phi->addIncoming(GlobalRecCastAddr, NonSPMDBB);
2904 PhiSrc->addIncoming(Ptr.getPointer(), CurrentBB);
2907 PhiDest->addIncoming(ElemPtr.getPointer(), CurrentBB);
2922 PhiSrc->addIncoming(LocalPtr.getPointer(), ThenBB);
2923 PhiDest->addIncoming(LocalElemPtr.getPointer(), ThenBB);
tools/clang/lib/CodeGen/CGStmt.cpp 627 cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 669 SrcElementPHI->addIncoming(SrcBegin, EntryBB);
676 DestElementPHI->addIncoming(DestBegin, EntryBB);
693 DestElementPHI->addIncoming(DestElementNext, Builder.GetInsertBlock());
694 SrcElementPHI->addIncoming(SrcElementNext, Builder.GetInsertBlock());
tools/clang/lib/CodeGen/CGVTables.cpp 103 PHI->addIncoming(ReturnValue, AdjustNotNull);
104 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
tools/clang/lib/CodeGen/CodeGenFunction.cpp 1597 cur->addIncoming(begin.getPointer(), originBB);
1613 cur->addIncoming(next, loopBB);
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 777 CalleePtr->addIncoming(VirtualFn, FnVirtual);
778 CalleePtr->addIncoming(NonVirtualFn, FnNonVirtual);
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 3026 Phi->addIncoming(Base.getPointer(), OriginalBB);
3027 Phi->addIncoming(AdjustedBase, VBaseAdjustBB);
3138 Phi->addIncoming(DstNull, OriginalBB);
3139 Phi->addIncoming(Dst, ConvertBB);
tools/clang/lib/CodeGen/TargetInfo.cpp 379 PHI->addIncoming(Addr1.getPointer(), Block1);
380 PHI->addIncoming(Addr2.getPointer(), Block2);
tools/polly/lib/CodeGen/BlockGenerators.cpp 891 MergePHI->addIncoming(EscapeInstReload, OptExitBB);
892 MergePHI->addIncoming(EscapeInst, ExitBB);
969 MergePHI->addIncoming(Reload, OptExitBB);
970 MergePHI->addIncoming(OriginalValue, ExitBB);
1598 LoopPHI->addIncoming(LoopPHIInc, EndBlockMap[PredBB]);
1600 LoopPHI->addIncoming(NullVal, EndBlockMap[PredBB]);
1605 LoopPHI->addIncoming(NullVal, PredBBCopy);
1656 NewPHI->addIncoming(NewIncomingValue, NewIncomingBlockEnd);
1782 PHICopy->addIncoming(OpCopy, BBCopyEnd);
tools/polly/lib/CodeGen/IslExprBuilder.cpp 639 PHI->addIncoming(OpType == isl_ast_op_and_then ? Builder.getFalse()
642 PHI->addIncoming(RHS, RightBB);
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 1310 MergePHI->addIncoming(PreAccInst, ExecBB);
1311 MergePHI->addIncoming(Constant::getNullValue(AccInstTy), CondBB);
tools/polly/lib/CodeGen/LoopGenerators.cpp 153 IV->addIncoming(LB, PreHeaderBB);
164 IV->addIncoming(IncrementedIV, HeaderBB);
unittests/Analysis/PhiValuesTest.cpp 46 Phi1->addIncoming(Val1, If);
47 Phi1->addIncoming(Val2, Else);
49 Phi2->addIncoming(Val1, If);
50 Phi2->addIncoming(Val3, Else);
119 Phi1->addIncoming(Val1, If1);
120 Phi1->addIncoming(Val2, Else1);
122 Phi2->addIncoming(Val2, If1);
123 Phi2->addIncoming(Val3, Else1);
125 Phi3->addIncoming(Phi1, If2);
126 Phi3->addIncoming(Val3, Else2);
unittests/Analysis/ScalarEvolutionTest.cpp 130 PN->addIncoming(Constant::getNullValue(Ty), EntryBB);
131 PN->addIncoming(UndefValue::get(Ty), LoopBB);
378 Phi->addIncoming(Acc[i], LoopBB);
379 Phi->addIncoming(UndefValue::get(Ty), EntryBB);
695 PN->addIncoming(ConstantInt::get(Context, APInt(64, 100)), PrevBB);
707 PN->addIncoming(Dec, IncBB);
777 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
778 Phi->addIncoming(Add, L);
853 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
854 Phi->addIncoming(Add, L);
953 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
954 Phi->addIncoming(Add, L);
1022 Phi->addIncoming(MinInt64, EntryBB);
1023 Phi->addIncoming(Add, LoopBB);
1080 Phi->addIncoming(Arg, EntryBB);
1081 Phi->addIncoming(Add, LoopBB);
1179 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
1180 Phi->addIncoming(Add, L);
unittests/FuzzMutate/OperationsTest.cpp 262 PHI1->addIncoming(ConstantInt::get(Int8Ty, 0), BB1);
263 PHI1->addIncoming(ConstantInt::get(Int8Ty, 1), BB2);
265 PHI2->addIncoming(ConstantInt::get(Int8Ty, 1), BB1);
266 PHI2->addIncoming(ConstantInt::get(Int8Ty, 0), BB2);
unittests/IR/BasicBlockTest.cpp 54 P1->addIncoming(P2, BB.get());
55 P2->addIncoming(P1, BB.get());
56 P3->addIncoming(Sum, BB.get());
61 PN.addIncoming(UndefValue::get(Int32Ty), BB1.get());
62 PN.addIncoming(UndefValue::get(Int32Ty), BB2.get());
unittests/Transforms/Utils/LocalTest.cpp 41 phi->addIncoming(phi, bb0);
42 phi->addIncoming(phi, bb1);
82 P1->addIncoming(B.getInt32(42), Entry);
85 P2->addIncoming(B.getInt32(42), Entry);
88 P3->addIncoming(B.getInt32(42), Entry);
89 P3->addIncoming(B.getInt32(23), BB);
92 P4->addIncoming(B.getInt32(42), Entry);
93 P4->addIncoming(B.getInt32(23), BB);
95 P1->addIncoming(P3, BB);
96 P2->addIncoming(P4, BB);