[Inliner] Don't removeDeadConstantUsers() when checking if a function is dead

[aeubanks]

Summary

If a function has many uses, this can take a good chunk of compile times.

[aeubanks]

typo

[nikic]

LGTM

llvm/lib/Transforms/IPO/Inliner.cpp

942–943

You can merge the if blocks as well.

llvm/include/llvm/IR/Constant.h

public:
   void removeDeadConstantUsers() const;
 
   /// Return true if the constant has exactly one live use.
   ///
   /// This returns the same result as calling Value::hasOneUse after
   /// Constant::removeDeadConstantUsers, but doesn't remove dead constants.
   bool hasOneLiveUse() const;
 
+  /// Return true if the constant has no live uses.
+  ///
+  /// This returns the same result as calling Value::use_empty after
+  /// Constant::removeDeadConstantUsers, but doesn't remove dead constants.
+  bool hasZeroLiveUses() const;
+
   const Constant *stripPointerCasts() const {
     return cast<Constant>(Value::stripPointerCasts());
   }
 
   Constant *stripPointerCasts() {
     return const_cast<Constant*>(
                       static_cast<const Constant *>(this)->stripPointerCasts());
   }
enum PossibleRelocationsTy {
 
     /// This constant holds dynamic relocations that the dynamic linker will
     /// need to resolve.
     GlobalRelocation = 2,
   };
 
   /// Determine what potential relocations may be needed by this constant.
   PossibleRelocationsTy getRelocationInfo() const;
+
+  bool hasNLiveUses(unsigned N) const;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_IR_CONSTANT_H

llvm/lib/Analysis/LazyCallGraph.cpp

void LazyCallGraph::removeEdge(Node &SourceN, Node &TargetN) {
   bool Removed = SourceN->removeEdgeInternal(TargetN);
   (void)Removed;
   assert(Removed && "Target not in the edge set for this caller?");
 }
 
 void LazyCallGraph::removeDeadFunction(Function &F) {
   // FIXME: This is unnecessarily restrictive. We should be able to remove
   // functions which recursively call themselves.
-  assert(F.use_empty() &&
+  assert(F.hasZeroLiveUses() &&
          "This routine should only be called on trivially dead functions!");
 
   // We shouldn't remove library functions as they are never really dead while
   // the call graph is in use -- every function definition refers to them.
   assert(!isLibFunction(F) &&
          "Must not remove lib functions from the call graph!");
 
   auto NI = NodeMap.find(&F);

llvm/lib/IR/Constants.cpp

while (I != E) {
     // If the constant was dead, then the iterator is invalidated.
     if (LastNonDeadUser == E)
       I = user_begin();
     else
       I = std::next(LastNonDeadUser);
   }
 }
 
-bool Constant::hasOneLiveUse() const {
+bool Constant::hasOneLiveUse() const { return hasNLiveUses(1); }
+
+bool Constant::hasZeroLiveUses() const { return hasNLiveUses(0); }
+
+bool Constant::hasNLiveUses(unsigned N) const {
   unsigned NumUses = 0;
-  for (const Use &use : uses()) {
-    const Constant *User = dyn_cast<Constant>(use.getUser());
+  for (const Use &U : uses()) {
+    const Constant *User = dyn_cast<Constant>(U.getUser());
     if (!User || !constantIsDead(User, /* RemoveDeadUsers= */ false)) {
       ++NumUses;
 
-      if (NumUses > 1)
+      if (NumUses > N)
         return false;
     }
   }
-  return NumUses == 1;
+  return NumUses == N;
 }
 
 Constant *Constant::replaceUndefsWith(Constant *C, Constant *Replacement) {
   assert(C && Replacement && "Expected non-nullptr constant arguments");
   Type *Ty = C->getType();
   if (match(C, m_Undef())) {
     assert(Ty == Replacement->getType() && "Expected matching types");
     return Replacement;

llvm/lib/Transforms/IPO/Inliner.cpp

while (!Calls->empty() && Calls->front().first->getCaller() == &F) {
 
       // Merge the attributes based on the inlining.
       AttributeFuncs::mergeAttributesForInlining(F, Callee);
 
       // For local functions, check whether this makes the callee trivially
       // dead. In that case, we can drop the body of the function eagerly
       // which may reduce the number of callers of other functions to one,
       // changing inline cost thresholds.
       bool CalleeWasDeleted = false;
-      if (Callee.hasLocalLinkage()) {
-        // To check this we also need to nuke any dead constant uses (perhaps
-        // made dead by this operation on other functions).
-        Callee.removeDeadConstantUsers();
-        if (Callee.use_empty() && !CG.isLibFunction(Callee)) {
-          Calls->erase_if([&](const std::pair<CallBase *, int> &Call) {
-            return Call.first->getCaller() == &Callee;
-          });
-          // Clear the body and queue the function itself for deletion when we
-          // finish inlining and call graph updates.
-          // Note that after this point, it is an error to do anything other
-          // than use the callee's address or delete it.
-          Callee.dropAllReferences();
-          assert(!is_contained(DeadFunctions, &Callee) &&
-                 "Cannot put cause a function to become dead twice!");
-          DeadFunctions.push_back(&Callee);
-          CalleeWasDeleted = true;
-        }
-      }
+      if (Callee.hasLocalLinkage() && Callee.hasZeroLiveUses() &&
+          !CG.isLibFunction(Callee)) {
       if (CalleeWasDeleted)
         Advice->recordInliningWithCalleeDeleted();
       else
         Advice->recordInlining();
     }
 
     if (!DidInline)
       continue;