Lines Matching defs:PN
43 void InstCombinerImpl::PHIArgMergedDebugLoc(Instruction *Inst, PHINode &PN) {
44 auto *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
50 for (Value *V : drop_begin(PN.incoming_values())) {
59 bool InstCombinerImpl::foldDeadPhiWeb(PHINode &PN) {
62 Stack.push_back(&PN);
84 // Replace Integer typed PHI PN if the PHI's value is used as a pointer value.
85 // If there is an existing pointer typed PHI that produces the same value as PN,
86 // replace PN and the IntToPtr operation with it. Otherwise, synthesize a new
134 bool InstCombinerImpl::foldIntegerTypedPHI(PHINode &PN) {
135 if (!PN.getType()->isIntegerTy())
137 if (!PN.hasOneUse())
140 auto *IntToPtr = dyn_cast<IntToPtrInst>(PN.user_back());
170 for (auto Incoming : zip(PN.blocks(), PN.incoming_values())) {
222 auto *BB = PN.getParent();
223 assert(AvailablePtrVals.size() == PN.getNumIncomingValues() &&
231 if (&PtrPHI == &PN || PtrPHI.getType() != IntToPtr->getType())
233 if (any_of(zip(PN.blocks(), AvailablePtrVals),
251 eraseInstFromFunction(PN);
281 IntToPtr->getType(), PN.getNumIncomingValues(), PN.getName() + ".ptr");
283 InsertNewInstBefore(NewPtrPHI, PN.getIterator());
285 for (auto Incoming : zip(PN.blocks(), AvailablePtrVals)) {
333 eraseInstFromFunction(PN);
339 Instruction *InstCombinerImpl::foldPHIArgIntToPtrToPHI(PHINode &PN) {
342 if (!all_of(PN.users(), [](User *U) { return isa<PtrToIntInst>(U); }))
348 for (unsigned OpNum = 0; OpNum != PN.getNumIncomingValues(); ++OpNum) {
350 simplifyIntToPtrRoundTripCast(PN.getIncomingValue(OpNum))) {
351 replaceOperand(PN, OpNum, NewOp);
357 return &PN;
363 InstCombinerImpl::foldPHIArgInsertValueInstructionIntoPHI(PHINode &PN) {
364 auto *FirstIVI = cast<InsertValueInst>(PN.getIncomingValue(0));
368 for (Value *V : drop_begin(PN.incoming_values())) {
381 FirstIVI->getOperand(OpIdx)->getType(), PN.getNumIncomingValues(),
384 for (auto Incoming : zip(PN.blocks(), PN.incoming_values()))
388 InsertNewInstBefore(NewOperand, PN.getIterator());
393 FirstIVI->getIndices(), PN.getName());
395 PHIArgMergedDebugLoc(NewIVI, PN);
403 InstCombinerImpl::foldPHIArgExtractValueInstructionIntoPHI(PHINode &PN) {
404 auto *FirstEVI = cast<ExtractValueInst>(PN.getIncomingValue(0));
408 for (Value *V : drop_begin(PN.incoming_values())) {
419 FirstEVI->getAggregateOperand()->getType(), PN.getNumIncomingValues(),
422 for (auto Incoming : zip(PN.blocks(), PN.incoming_values()))
426 InsertNewInstBefore(NewAggregateOperand, PN.getIterator());
430 FirstEVI->getIndices(), PN.getName());
432 PHIArgMergedDebugLoc(NewEVI, PN);
439 Instruction *InstCombinerImpl::foldPHIArgBinOpIntoPHI(PHINode &PN) {
440 Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
450 for (Value *V : drop_begin(PN.incoming_values())) {
482 NewLHS = PHINode::Create(LHSType, PN.getNumIncomingValues(),
484 NewLHS->addIncoming(InLHS, PN.getIncomingBlock(0));
485 InsertNewInstBefore(NewLHS, PN.getIterator());
490 NewRHS = PHINode::Create(RHSType, PN.getNumIncomingValues(),
492 NewRHS->addIncoming(InRHS, PN.getIncomingBlock(0));
493 InsertNewInstBefore(NewRHS, PN.getIterator());
499 for (auto Incoming : drop_begin(zip(PN.blocks(), PN.incoming_values()))) {
517 PHIArgMergedDebugLoc(NewCI, PN);
525 NewBinOp->copyIRFlags(PN.getIncomingValue(0));
527 for (Value *V : drop_begin(PN.incoming_values()))
530 PHIArgMergedDebugLoc(NewBinOp, PN);
534 Instruction *InstCombinerImpl::foldPHIArgGEPIntoPHI(PHINode &PN) {
535 GetElementPtrInst *FirstInst =cast<GetElementPtrInst>(PN.getIncomingValue(0));
552 for (Value *V : drop_begin(PN.incoming_values())) {
617 InsertNewInstBefore(NewPN, PN.getIterator());
619 NewPN->addIncoming(FirstOp, PN.getIncomingBlock(0));
627 for (auto Incoming : drop_begin(zip(PN.blocks(), PN.incoming_values()))) {
642 PHIArgMergedDebugLoc(NewGEP, PN);
697 Instruction *InstCombinerImpl::foldPHIArgLoadIntoPHI(PHINode &PN) {
698 LoadInst *FirstLI = cast<LoadInst>(PN.getIncomingValue(0));
717 if (FirstLI->getParent() != PN.getIncomingBlock(0) ||
728 for (auto Incoming : drop_begin(zip(PN.blocks(), PN.incoming_values()))) {
761 PN.getNumIncomingValues(),
762 PN.getName()+".in");
765 NewPN->addIncoming(InVal, PN.getIncomingBlock(0));
771 for (auto Incoming : drop_begin(zip(PN.blocks(), PN.incoming_values()))) {
788 InsertNewInstBefore(NewPN, PN.getIterator());
795 for (Value *IncValue : PN.incoming_values())
798 PHIArgMergedDebugLoc(NewLI, PN);
879 Instruction *InstCombinerImpl::foldPHIArgOpIntoPHI(PHINode &PN) {
882 if (Instruction *TI = PN.getParent()->getTerminator())
886 Instruction *FirstInst = cast<Instruction>(PN.getIncomingValue(0));
889 return foldPHIArgGEPIntoPHI(PN);
891 return foldPHIArgLoadIntoPHI(PN);
893 return foldPHIArgInsertValueInstructionIntoPHI(PN);
895 return foldPHIArgExtractValueInstructionIntoPHI(PN);
909 if (PN.getType()->isIntegerTy() && CastSrcTy->isIntegerTy()) {
910 if (!shouldChangeType(PN.getType(), CastSrcTy))
918 return foldPHIArgBinOpIntoPHI(PN);
924 for (Value *V : drop_begin(PN.incoming_values())) {
939 PN.getNumIncomingValues(),
940 PN.getName()+".in");
943 NewPN->addIncoming(InVal, PN.getIncomingBlock(0));
946 for (auto Incoming : drop_begin(zip(PN.blocks(), PN.incoming_values()))) {
962 InsertNewInstBefore(NewPN, PN.getIterator());
969 PN.getType());
970 PHIArgMergedDebugLoc(NewCI, PN);
976 BinOp->copyIRFlags(PN.getIncomingValue(0));
978 for (Value *V : drop_begin(PN.incoming_values()))
981 PHIArgMergedDebugLoc(BinOp, PN);
988 PHIArgMergedDebugLoc(NewCI, PN);
995 static bool PHIsEqualValue(PHINode *PN, Value *&NonPhiInVal,
998 if (!ValueEqualPHIs.insert(PN).second)
1007 for (Value *Op : PN->incoming_values()) {
1023 static ConstantInt *getAnyNonZeroConstInt(PHINode &PN) {
1024 assert(isa<IntegerType>(PN.getType()) && "Expect only integer type phi");
1025 for (Value *V : PN.operands())
1029 return ConstantInt::get(cast<IntegerType>(PN.getType()), 1);
1052 PHINode *PN; // The PHI that was lowered.
1057 : PN(Phi), Shift(Sh), Width(Ty->getPrimitiveSizeInBits()) {}
1060 LoweredPHIRecord(PHINode *Phi, unsigned Sh) : PN(Phi), Shift(Sh), Width(0) {}
1074 return DenseMapInfo<PHINode*>::getHashValue(Val.PN) ^ (Val.Shift>>3) ^
1079 return LHS.PN == RHS.PN && LHS.Shift == RHS.Shift &&
1110 PHINode *PN = PHIsToSlice[PHIId];
1116 for (auto Incoming : zip(PN->blocks(), PN->incoming_values())) {
1134 for (auto *Pred : PN->blocks())
1138 for (User *U : PN->users()) {
1192 PHINode *PN = PHIsToSlice[PHIId];
1200 if ((EltPHI = ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)]) == nullptr) {
1203 EltPHI = PHINode::Create(Ty, PN->getNumIncomingValues(),
1204 PN->getName() + ".off" + Twine(Offset),
1205 PN->getIterator());
1206 assert(EltPHI->getType() != PN->getType() &&
1209 for (auto Incoming : zip(PN->blocks(), PN->incoming_values())) {
1221 if (InVal == PN) {
1227 if (PHINode *InPHI = dyn_cast<PHINode>(PN)) {
1264 ExtractedVals[LoweredPHIRecord(PN, Offset, Ty)] = EltPHI;
1279 static Value *simplifyUsingControlFlow(InstCombiner &Self, PHINode &PN,
1294 if (!all_of(PN.operands(), [](Value *V) { return isa<ConstantInt>(V); }))
1297 BasicBlock *BB = PN.getParent();
1303 LLVMContext &Context = PN.getContext();
1328 if (Cond->getType() != PN.getType())
1334 for (auto Pair : zip(PN.incoming_values(), PN.blocks())) {
1382 static Value *foldDependentIVs(PHINode &PN, IRBuilderBase &Builder) {
1383 BasicBlock *BB = PN.getParent();
1384 if (PN.getNumIncomingValues() != 2)
1400 if (!MatchOuterIV(PN.getIncomingValue(0), PN.getIncomingValue(1)) &&
1401 !MatchOuterIV(PN.getIncomingValue(1), PN.getIncomingValue(0)))
1432 Instruction *InstCombinerImpl::visitPHINode(PHINode &PN) {
1433 if (Value *V = simplifyInstruction(&PN, SQ.getWithInstruction(&PN)))
1434 return replaceInstUsesWith(PN, V);
1436 if (Instruction *Result = foldPHIArgZextsIntoPHI(PN))
1439 if (Instruction *Result = foldPHIArgIntToPtrToPHI(PN))
1444 auto *Inst0 = dyn_cast<Instruction>(PN.getIncomingValue(0));
1445 auto *Inst1 = dyn_cast<Instruction>(PN.getIncomingValue(1));
1448 if (Instruction *Result = foldPHIArgOpIntoPHI(PN))
1453 if (PN.getType()->isPointerTy() &&
1454 PN.getParent()->getFirstInsertionPt() != PN.getParent()->end()) {
1455 Value *IV0 = PN.getIncomingValue(0);
1462 all_of(PN.incoming_values(), [&CheckedIVs, IV0Stripped](Value *IV) {
1466 return CastInst::CreatePointerCast(IV0Stripped, PN.getType());
1470 if (foldDeadPhiWeb(PN))
1474 if (PN.hasOneUse()) {
1475 if (foldIntegerTypedPHI(PN))
1484 Instruction *PHIUser = cast<Instruction>(PN.user_back());
1488 PHIUser->user_back() == &PN) {
1489 return replaceInstUsesWith(PN, PoisonValue::get(PN.getType()));
1505 if (!PN.hasNUsesOrMore(3)) {
1507 bool AllUsesOfPhiEndsInCmp = all_of(PN.users(), [&](User *U) {
1512 if (U->hasOneUse() && match(U, m_c_Or(m_Specific(&PN), m_Value()))) {
1517 if (!CmpInst || !isa<IntegerType>(PN.getType()) ||
1527 for (unsigned I = 0, E = PN.getNumIncomingValues(); I != E; ++I) {
1528 Instruction *CtxI = PN.getIncomingBlock(I)->getTerminator();
1529 Value *VA = PN.getIncomingValue(I);
1532 NonZeroConst = getAnyNonZeroConstInt(PN);
1534 replaceOperand(PN, I, NonZeroConst);
1543 return &PN;
1556 unsigned InValNo = 0, NumIncomingVals = PN.getNumIncomingValues();
1559 isa<PHINode>(PN.getIncomingValue(InValNo)))
1563 InValNo != NumIncomingVals ? PN.getIncomingValue(InValNo) : nullptr;
1569 Value *OpVal = PN.getIncomingValue(InValNo);
1579 if (PHIsEqualValue(&PN, NonPhiInVal, ValueEqualPHIs))
1580 return replaceInstUsesWith(PN, NonPhiInVal);
1588 auto Res = PredOrder.try_emplace(PN.getParent());
1591 for (unsigned I = 0, E = PN.getNumIncomingValues(); I != E; ++I) {
1592 BasicBlock *BBA = PN.getIncomingBlock(I);
1595 Value *VA = PN.getIncomingValue(I);
1596 unsigned J = PN.getBasicBlockIndex(BBB);
1597 Value *VB = PN.getIncomingValue(J);
1598 PN.setIncomingBlock(I, BBB);
1599 PN.setIncomingValue(I, VB);
1600 PN.setIncomingBlock(J, BBA);
1601 PN.setIncomingValue(J, VA);
1602 // NOTE: Instcombine normally would want us to "return &PN" if we
1610 append_range(Res.first->second, PN.blocks());
1614 for (PHINode &IdenticalPN : PN.getParent()->phis()) {
1616 if (&IdenticalPN == &PN)
1621 if (!PN.isIdenticalToWhenDefined(&IdenticalPN))
1625 return replaceInstUsesWith(PN, &IdenticalPN);
1632 if (PN.getType()->isIntegerTy() &&
1633 !DL.isLegalInteger(PN.getType()->getPrimitiveSizeInBits()))
1634 if (Instruction *Res = SliceUpIllegalIntegerPHI(PN))
1638 if (auto *V = simplifyUsingControlFlow(*this, PN, DT))
1639 return replaceInstUsesWith(PN, V);
1641 if (Value *Res = foldDependentIVs(PN, Builder))
1642 return replaceInstUsesWith(PN, Res);