@@ -1562,27 +1562,39 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
15621562
15631563 auto *TI = BB->getTerminator ();
15641564
1565- SmallVector<BasicBlock *> SuccessorBlocks;
1566- for (auto *Succ : successors (BB))
1567- SuccessorBlocks.push_back (Succ);
1565+ SmallVector<BasicBlock *, 8 > SuccessorBBs;
1566+ for (auto *Succ : successors (BB)) {
1567+ BasicBlock::iterator SuccItr = Succ->begin ();
1568+ // If we find an unreachable instruction at the beginning of a basic block,
1569+ // we can still hoist instructions from the rest of the basic blocks.
1570+ if (isa<UnreachableInst>(*SuccItr))
1571+ continue ;
1572+ SuccessorBBs.push_back (Succ);
1573+ }
15681574
1569- // Sort successor blocks based on the number of instructions.
1570- // This is because we always want to iterate over instructions
1571- // of the smallest block.
1572- llvm::stable_sort (SuccessorBlocks, [](BasicBlock *BB1, BasicBlock *BB2) {
1573- return BB1->sizeWithoutDebug () < BB2->sizeWithoutDebug ();
1574- });
1575+ // Find the smallest BB because we always want to iterate over instructions
1576+ // of the smallest Successor.
1577+ auto *SmallestBB = *std::min_element (SuccessorBBs.begin (), SuccessorBBs.end (),
1578+ [](BasicBlock *BB1, BasicBlock *BB2) {
1579+ return BB1->size () < BB2->size ();
1580+ });
1581+ std::iter_swap (
1582+ SuccessorBBs.begin (),
1583+ std::find (SuccessorBBs.begin (), SuccessorBBs.end (), SmallestBB));
15751584
15761585 // The second of pair is a SkipFlags bitmask.
15771586 using SuccIterPair = std::pair<BasicBlock::iterator, unsigned >;
15781587 SmallVector<SuccIterPair, 8 > SuccIterPairs;
1579- for (auto *Succ : SuccessorBlocks ) {
1588+ for (auto *Succ : SuccessorBBs ) {
15801589 BasicBlock::iterator SuccItr = Succ->begin ();
15811590 if (isa<PHINode>(*SuccItr))
15821591 return false ;
15831592 SuccIterPairs.push_back (SuccIterPair (SuccItr, 0 ));
15841593 }
15851594
1595+ if (SuccIterPairs.size () < 2 )
1596+ return false ;
1597+
15861598 // Check if only hoisting terminators is allowed. This does not add new
15871599 // instructions to the hoist location.
15881600 if (EqTermsOnly) {
@@ -1600,14 +1612,6 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
16001612 // many instructions we skip, serving as a compilation time control as well as
16011613 // preventing excessive increase of life ranges.
16021614 unsigned NumSkipped = 0 ;
1603- // If we find an unreachable instruction at the beginning of a basic block, we
1604- // can still hoist instructions from the rest of the basic blocks.
1605- if (SuccIterPairs.size () > 2 ) {
1606- erase_if (SuccIterPairs,
1607- [](const auto &Pair) { return isa<UnreachableInst>(Pair.first ); });
1608- if (SuccIterPairs.size () < 2 )
1609- return false ;
1610- }
16111615
16121616 bool Changed = false ;
16131617 auto *SuccIterPairBegin = SuccIterPairs.begin ();
@@ -1642,14 +1646,25 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
16421646 iterator_range (SuccIterPairBegin, SuccIterPairs.end ());
16431647 Instruction *I1 = &*BB1ItrPair.first ;
16441648 auto *BB1 = I1->getParent ();
1649+
1650+ // Skip debug info if it is not identical.
1651+ bool IdenticalDebugs = all_of (OtherSuccIterRange, [I1](auto &Iter) {
1652+ Instruction *I2 = &*Iter;
1653+ return I1->isIdenticalToWhenDefined (I2);
1654+ });
1655+ if (!IdenticalDebugs) {
1656+ while (isa<DbgInfoIntrinsic>(I1))
1657+ I1 = &*++BB1ItrPair.first ;
1658+ }
1659+
16451660 bool HasIdenticalInst = true ;
16461661
16471662 // Check if there are identical instructions in all other successors
16481663 for (auto &map : OtherSuccessorsHash) {
16491664 Instruction *I2 = map[getHash (I1)].first ;
16501665 // We might face with same hash values for different instructions.
16511666 // If that happens, ignore the instruction.
1652- if (!I2 || !I1->isIdenticalTo (I2)) {
1667+ if (!I2 || !I1->isIdenticalToWhenDefined (I2)) {
16531668 HasIdenticalInst = false ;
16541669 break ;
16551670 }
@@ -1665,7 +1680,7 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
16651680 SuccIterPair.second |= skippedInstrFlags (I);
16661681 }
16671682 }
1668- NumSkipped++ ;
1683+ ++NumSkipped ;
16691684 if (I1->isTerminator ())
16701685 return Changed;
16711686 ++BB1ItrPair.first ;
@@ -1737,13 +1752,38 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
17371752 for (auto &map : OtherSuccessorsHash) {
17381753 Instruction *I2 = map[getHash (I1)].first ;
17391754 assert (I2 != I1);
1740- if (!I2->use_empty ())
1755+ // Update hashcode of all instructions using I2
1756+ if (!I2->use_empty ()) {
1757+ SmallVector<llvm::hash_code, 8 > PrevHashCodes;
1758+ SmallVector<llvm::Instruction *, 8 > PrevUsers;
1759+ // Once the uses of I1 are replaced, the hash value computed for
1760+ // those users are not valid anymore so we gather users and then
1761+ // recompute the hash codes for them. We need to do this only for
1762+ // the instructions located in the same block as I2 because we
1763+ // initially only hashed those instructions.
1764+ for (auto *user : I2->users ()) {
1765+ if (auto *I = dyn_cast<Instruction>(user)) {
1766+ if (I->getParent () != I2->getParent ())
1767+ continue ;
1768+ PrevHashCodes.push_back (getHash (I));
1769+ PrevUsers.push_back (I);
1770+ }
1771+ }
17411772 I2->replaceAllUsesWith (I1);
1773+ unsigned index = 0 ;
1774+ for (auto &PrevHash : PrevHashCodes) {
1775+ auto NewHash = getHash (PrevUsers[index]);
1776+ std::swap (map[NewHash], map[PrevHash]);
1777+ map.erase (PrevHash);
1778+ index++;
1779+ }
1780+ }
17421781 I1->andIRFlags (I2);
17431782 combineMetadataForCSE (I1, I2, true );
17441783 // I1 and I2 are being combined into a single instruction. Its debug
17451784 // location is the merged locations of the original instructions.
17461785 I1->applyMergedLocation (I1->getDebugLoc (), I2->getDebugLoc ());
1786+ map.erase (getHash (I1));
17471787 I2->eraseFromParent ();
17481788 }
17491789 }
@@ -1757,10 +1797,11 @@ bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(BasicBlock *BB,
17571797 // We are about to skip over a pair of non-identical instructions. Record
17581798 // if any have characteristics that would prevent reordering instructions
17591799 // across them.
1800+ BB1ItrPair.first ++;
17601801 SkipFlagsBB1 |= skippedInstrFlags (I1);
17611802 if (SameLevelHoist) {
17621803 for (auto &SuccIterPair : OtherSuccIterPairRange) { // update flags
1763- Instruction *I = &*SuccIterPair.first ;
1804+ Instruction *I = &*SuccIterPair.first ++ ;
17641805 SuccIterPair.second |= skippedInstrFlags (I);
17651806 }
17661807 }
@@ -1874,16 +1915,20 @@ bool SimplifyCFGOpt::hoistSuccIdenticalTerminatorToSwitchOrIf(
18741915 }
18751916 }
18761917 }
1918+
18771919 SmallVector<DominatorTree::UpdateType, 4 > Updates;
1920+
18781921 // Update any PHI nodes in our new successors.
18791922 for (BasicBlock *Succ : successors (BB1)) {
18801923 AddPredecessorToBlock (Succ, TIParent, BB1);
18811924 if (DTU)
18821925 Updates.push_back ({DominatorTree::Insert, TIParent, Succ});
18831926 }
1927+
18841928 if (DTU)
18851929 for (BasicBlock *Succ : successors (TI))
18861930 Updates.push_back ({DominatorTree::Delete, TIParent, Succ});
1931+
18871932 EraseTerminatorAndDCECond (TI);
18881933 if (DTU)
18891934 DTU->applyUpdates (Updates);
@@ -3631,7 +3676,6 @@ static bool FoldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
36313676 // Change the PHI node into a select instruction.
36323677 Value *TrueVal = PN->getIncomingValueForBlock (IfTrue);
36333678 Value *FalseVal = PN->getIncomingValueForBlock (IfFalse);
3634-
36353679 Value *Sel = Builder.CreateSelect (IfCond, TrueVal, FalseVal, " "
36363680 PN->replaceAllUsesWith (Sel);
36373681 Sel->takeName (PN);
0 commit comments