[CodeGenPrepare] Cache known-live PHIs when deleting dead PHI chains (#207191)

This patch fixes a compile-time issue in CodeGenPrepare for huge
functions.

`DeleteDeadPHIs` may repeatedly prove overlapping PHI chains non-dead.
For very large functions, many PHIs can share the same non-dead def-use
suffix, causing the same suffix to be scanned many times.

Add an `KnownNonDeadPHIs` cache to `RecursivelyDeleteDeadPHINode`
and `DeleteDeadPHIs`. When a chain is proven non-dead, visited PHIs are
recorded so later queries can stop once they reach one of them.

This reduces the pathological CodeGenPrepare case from ~30mins to ~30s.

Author: Jolyon0202

llvm/include/llvm/Transforms/Utils/BasicBlockUtils.h

@@ -91,9 +91,10 @@ FoldSingleEntryPHINodes(BasicBlock *BB,
 /// recursively delete any operands that become dead as a result. This includes
 /// tracing the def-use list from the PHI to see if it is ultimately unused or
 /// if it reaches an unused cycle. Return true if any PHIs were deleted.
-LLVM_ABI bool DeleteDeadPHIs(BasicBlock *BB,
-                             const TargetLibraryInfo *TLI = nullptr,
-                             MemorySSAUpdater *MSSAU = nullptr);
+LLVM_ABI bool
+DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI = nullptr,
+               MemorySSAUpdater *MSSAU = nullptr,
+               SmallPtrSetImpl<PHINode *> *KnownNonDeadPHIs = nullptr);
 
 /// Attempts to merge a block into its predecessor, if possible. The return
 /// value indicates success or failure.

llvm/include/llvm/Transforms/Utils/Local.h

@@ -28,6 +28,7 @@ class DataLayout;
 class Value;
 class WeakTrackingVH;
 class WeakVH;
+template <typename PtrType> class SmallPtrSetImpl;
 template <typename T> class SmallVectorImpl;
 class AAResults;
 class AllocaInst;
@@ -129,10 +130,10 @@ LLVM_ABI bool RecursivelyDeleteTriviallyDeadInstructionsPermissive(
 /// by a trivially dead instruction, delete it. If that makes any of its
 /// operands trivially dead, delete them too, recursively. Return true if a
 /// change was made.
-LLVM_ABI bool
-RecursivelyDeleteDeadPHINode(PHINode *PN,
-                             const TargetLibraryInfo *TLI = nullptr,
-                             MemorySSAUpdater *MSSAU = nullptr);
+LLVM_ABI bool RecursivelyDeleteDeadPHINode(
+    PHINode *PN, const TargetLibraryInfo *TLI = nullptr,
+    MemorySSAUpdater *MSSAU = nullptr,
+    SmallPtrSetImpl<PHINode *> *KnownNonDeadPHIs = nullptr);
 
 /// Scan the specified basic block and try to simplify any instructions in it
 /// and recursively delete dead instructions.

llvm/lib/CodeGen/CodeGenPrepare.cpp

@@ -946,11 +946,12 @@ bool CodeGenPrepare::eliminateMostlyEmptyBlocks(Function &F, bool &ResetLI) {
 
   ResetLI = false;
   bool MadeChange = false;
+  SmallPtrSet<PHINode *, 32> KnownNonDeadPHIs;
   // Note that this intentionally skips the entry block.
   for (auto &Block : llvm::drop_begin(F)) {
     // Delete phi nodes that could block deleting other empty blocks.
     if (!DisableDeletePHIs)
-      MadeChange |= DeleteDeadPHIs(&Block, TLInfo);
+      MadeChange |= DeleteDeadPHIs(&Block, TLInfo, nullptr, &KnownNonDeadPHIs);
   }
 
   for (auto &Block : llvm::drop_begin(F)) {

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

@@ -212,16 +212,25 @@ bool llvm::FoldSingleEntryPHINodes(BasicBlock *BB,
 }
 
 bool llvm::DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI,
-                          MemorySSAUpdater *MSSAU) {
+                          MemorySSAUpdater *MSSAU,
+                          SmallPtrSetImpl<PHINode *> *KnownNonDeadPHIs) {
   // Recursively deleting a PHI may cause multiple PHIs to be deleted
   // or RAUW'd undef, so use an array of WeakTrackingVH for the PHIs to delete.
   SmallVector<WeakTrackingVH, 8> PHIs(llvm::make_pointer_range(BB->phis()));
 
-  bool Changed = false;
-  for (const auto &PHI : PHIs)
-    if (PHINode *PN = dyn_cast_or_null<PHINode>(PHI.operator Value *()))
-      Changed |= RecursivelyDeleteDeadPHINode(PN, TLI, MSSAU);
+  SmallPtrSet<PHINode *, 32> LocalKnownNonDeadPHIs;
+  if (!KnownNonDeadPHIs)
+    KnownNonDeadPHIs = &LocalKnownNonDeadPHIs;
 
+  bool Changed = false;
+  for (const auto &PHI : PHIs) {
+    if (PHINode *PN = dyn_cast_or_null<PHINode>(PHI.operator Value *())) {
+      bool PHIChanged = RecursivelyDeleteDeadPHINode(PN, TLI, MSSAU, KnownNonDeadPHIs);
+      Changed |= PHIChanged;
+      if (PHIChanged && KnownNonDeadPHIs)
+        KnownNonDeadPHIs->clear();
+    }
+  }
   return Changed;
 }
 

llvm/lib/Transforms/Utils/Local.cpp

@@ -640,10 +640,12 @@ static bool areAllUsesEqual(Instruction *I) {
 /// either forms a cycle or is terminated by a trivially dead instruction,
 /// delete it.  If that makes any of its operands trivially dead, delete them
 /// too, recursively.  Return true if a change was made.
-bool llvm::RecursivelyDeleteDeadPHINode(PHINode *PN,
-                                        const TargetLibraryInfo *TLI,
-                                        llvm::MemorySSAUpdater *MSSAU) {
+bool llvm::RecursivelyDeleteDeadPHINode(
+    PHINode *PN, const TargetLibraryInfo *TLI, llvm::MemorySSAUpdater *MSSAU,
+    SmallPtrSetImpl<PHINode *> *KnownNonDeadPHIs) {
   SmallPtrSet<Instruction*, 4> Visited;
+  SmallVector<PHINode *, 8> VisitedPHIs;
+
   for (Instruction *I = PN; areAllUsesEqual(I) && !I->mayHaveSideEffects();
        I = cast<Instruction>(*I->user_begin())) {
     if (I->use_empty())
@@ -657,7 +659,18 @@ bool llvm::RecursivelyDeleteDeadPHINode(PHINode *PN,
       (void)RecursivelyDeleteTriviallyDeadInstructions(I, TLI, MSSAU);
       return true;
     }
+
+    if (PHINode *CurPN = dyn_cast<PHINode>(I)) {
+      if (KnownNonDeadPHIs && KnownNonDeadPHIs->contains(CurPN))
+        break;
+      VisitedPHIs.push_back(CurPN);
+    }
   }
+
+  if (KnownNonDeadPHIs)
+    for (PHINode *VisitedPN : VisitedPHIs)
+      KnownNonDeadPHIs->insert(VisitedPN);
+
   return false;
 }