@@ -1618,27 +1618,39 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
16181618
16191619 auto *TI = BB->getTerminator ();
16201620
1621- SmallVector<BasicBlock *> SuccessorBlocks;
1622- for (auto *Succ : successors (BB))
1623- SuccessorBlocks.push_back (Succ);
1621+ SmallVector<BasicBlock *, 8 > SuccessorBBs;
1622+ for (auto *Succ : successors (BB)) {
1623+ BasicBlock::iterator SuccItr = Succ->begin ();
1624+ // If we find an unreachable instruction at the beginning of a basic block,
1625+ // we can still hoist instructions from the rest of the basic blocks.
1626+ if (isa<UnreachableInst>(*SuccItr))
1627+ continue ;
1628+ SuccessorBBs.push_back (Succ);
1629+ }
16241630
1625- // Sort successor blocks based on the number of instructions.
1626- // This is because we always want to iterate over instructions
1627- // of the smallest block.
1628- llvm::stable_sort (SuccessorBlocks, [](BasicBlock *BB1, BasicBlock *BB2) {
1629- return BB1->sizeWithoutDebug () < BB2->sizeWithoutDebug ();
1630- });
1631+ // Find the smallest BB because we always want to iterate over instructions
1632+ // of the smallest Successor.
1633+ auto *SmallestBB = *std::min_element (SuccessorBBs.begin (), SuccessorBBs.end (),
1634+ [](BasicBlock *BB1, BasicBlock *BB2) {
1635+ return BB1->size () < BB2->size ();
1636+ });
1637+ std::iter_swap (
1638+ SuccessorBBs.begin (),
1639+ std::find (SuccessorBBs.begin (), SuccessorBBs.end (), SmallestBB));
16311640
16321641 // The second of pair is a SkipFlags bitmask.
16331642 using SuccIterPair = std::pair<BasicBlock::iterator, unsigned >;
16341643 SmallVector<SuccIterPair, 8 > SuccIterPairs;
1635- for (auto *Succ : SuccessorBlocks ) {
1644+ for (auto *Succ : SuccessorBBs ) {
16361645 BasicBlock::iterator SuccItr = Succ->begin ();
16371646 if (isa<PHINode>(*SuccItr))
16381647 return false ;
16391648 SuccIterPairs.push_back (SuccIterPair (SuccItr, 0 ));
16401649 }
16411650
1651+ if (SuccIterPairs.size () < 2 )
1652+ return false ;
1653+
16421654 // Check if only hoisting terminators is allowed. This does not add new
16431655 // instructions to the hoist location.
16441656 if (EqTermsOnly) {
@@ -1656,14 +1668,6 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
16561668 // many instructions we skip, serving as a compilation time control as well as
16571669 // preventing excessive increase of life ranges.
16581670 unsigned NumSkipped = 0 ;
1659- // If we find an unreachable instruction at the beginning of a basic block, we
1660- // can still hoist instructions from the rest of the basic blocks.
1661- if (SuccIterPairs.size () > 2 ) {
1662- erase_if (SuccIterPairs,
1663- [](const auto &Pair) { return isa<UnreachableInst>(Pair.first ); });
1664- if (SuccIterPairs.size () < 2 )
1665- return false ;
1666- }
16671671
16681672 bool Changed = false ;
16691673 auto *SuccIterPairBegin = SuccIterPairs.begin ();
@@ -1704,7 +1708,7 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
17041708 Instruction *I2 = map[getHash (I1)].first ;
17051709 // We might face with same hash values for different instructions.
17061710 // If that happens, ignore the instruction.
1707- if (!I2 || !I1->isIdenticalTo (I2)) {
1711+ if (!I2 || !I1->isIdenticalToWhenDefined (I2)) {
17081712 HasIdenticalInst = false ;
17091713 break ;
17101714 }
@@ -1720,7 +1724,7 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
17201724 SuccIterPair.second |= skippedInstrFlags (I);
17211725 }
17221726 }
1723- NumSkipped++ ;
1727+ ++NumSkipped ;
17241728 if (I1->isTerminator ())
17251729 return Changed;
17261730 ++BB1ItrPair.first ;
@@ -1810,13 +1814,38 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
18101814 for (auto &map : OtherSuccessorsHash) {
18111815 Instruction *I2 = map[getHash (I1)].first ;
18121816 assert (I2 != I1);
1813- if (!I2->use_empty ())
1817+ // Update hashcode of all instructions using I2
1818+ if (!I2->use_empty ()) {
1819+ SmallVector<llvm::hash_code, 8 > PrevHashCodes;
1820+ SmallVector<llvm::Instruction *, 8 > PrevUsers;
1821+ // Once the uses of I1 are replaced, the hash value computed for
1822+ // those users are not valid anymore so we gather users and then
1823+ // recompute the hash codes for them. We need to do this only for
1824+ // the instructions located in the same block as I2 because we
1825+ // initially only hashed those instructions.
1826+ for (auto *user : I2->users ()) {
1827+ if (auto *I = dyn_cast<Instruction>(user)) {
1828+ if (I->getParent () != I2->getParent ())
1829+ continue ;
1830+ PrevHashCodes.push_back (getHash (I));
1831+ PrevUsers.push_back (I);
1832+ }
1833+ }
18141834 I2->replaceAllUsesWith (I1);
1835+ unsigned index = 0 ;
1836+ for (auto &PrevHash : PrevHashCodes) {
1837+ auto NewHash = getHash (PrevUsers[index]);
1838+ std::swap (map[NewHash], map[PrevHash]);
1839+ map.erase (PrevHash);
1840+ index++;
1841+ }
1842+ }
18151843 I1->andIRFlags (I2);
18161844 combineMetadataForCSE (I1, I2, true );
18171845 // I1 and I2 are being combined into a single instruction. Its debug
18181846 // location is the merged locations of the original instructions.
18191847 I1->applyMergedLocation (I1->getDebugLoc (), I2->getDebugLoc ());
1848+ map.erase (getHash (I1));
18201849 I2->eraseFromParent ();
18211850 }
18221851 }
@@ -1832,10 +1861,11 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
18321861 // We are about to skip over a pair of non-identical instructions. Record
18331862 // if any have characteristics that would prevent reordering instructions
18341863 // across them.
1864+ BB1ItrPair.first ++;
18351865 SkipFlagsBB1 |= skippedInstrFlags (I1);
18361866 if (SameLevelHoist) {
18371867 for (auto &SuccIterPair : OtherSuccIterPairRange) { // update flags
1838- Instruction *I = &*SuccIterPair.first ;
1868+ Instruction *I = &*SuccIterPair.first ++ ;
18391869 SuccIterPair.second |= skippedInstrFlags (I);
18401870 }
18411871 }
@@ -1952,16 +1982,20 @@ bool SimplifyCFGOpt::hoistSuccIdenticalTerminatorToSwitchOrIf(
19521982 }
19531983 }
19541984 }
1985+
19551986 SmallVector<DominatorTree::UpdateType, 4 > Updates;
1987+
19561988 // Update any PHI nodes in our new successors.
19571989 for (BasicBlock *Succ : successors (BB1)) {
19581990 AddPredecessorToBlock (Succ, TIParent, BB1);
19591991 if (DTU)
19601992 Updates.push_back ({DominatorTree::Insert, TIParent, Succ});
19611993 }
1994+
19621995 if (DTU)
19631996 for (BasicBlock *Succ : successors (TI))
19641997 Updates.push_back ({DominatorTree::Delete, TIParent, Succ});
1998+
19651999 EraseTerminatorAndDCECond (TI);
19662000 if (DTU)
19672001 DTU->applyUpdates (Updates);
@@ -3713,7 +3747,6 @@ static bool FoldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
37133747 // Change the PHI node into a select instruction.
37143748 Value *TrueVal = PN->getIncomingValueForBlock (IfTrue);
37153749 Value *FalseVal = PN->getIncomingValueForBlock (IfFalse);
3716-
37173750 Value *Sel = Builder.CreateSelect (IfCond, TrueVal, FalseVal, " "
37183751 PN->replaceAllUsesWith (Sel);
37193752 Sel->takeName (PN);
0 commit comments