[SCCP] Add API for AdditionalUsers to the Instruction Visitor.

[labrinea]

Summary

• Make it possible to remove an Additional User.
• Accumulate the Additional Users in a list.

Discussion: https://discourse.llvm.org/t/rfc-should-we-enable-function-specialization/61518

[labrinea]

ping

[labrinea]

Abandoning in favor of D126455.

llvm/lib/Transforms/Utils/SCCPSolver.cpp

class SCCPInstVisitor : public InstVisitor<SCCPInstVisitor> {
   SmallVector<BasicBlock *, 64> BBWorkList;
 
   /// KnownFeasibleEdges - Entries in this set are edges which have already had
   /// PHI nodes retriggered.
   using Edge = std::pair<BasicBlock *, BasicBlock *>;
   DenseSet<Edge> KnownFeasibleEdges;
 
   DenseMap<Function *, AnalysisResultsForFn> AnalysisResults;
-  DenseMap<Value *, SmallPtrSet<User *, 2>> AdditionalUsers;
+  DenseMap<Value *, SmallPtrSet<User *, 8>> AdditionalUsers;
+  DenseMap<User *, SmallPtrSet<Value *, 8>> AdditionalUserOf;
 
   LLVMContext &Ctx;
 
 private:
   ConstantInt *getConstantInt(const ValueLatticeElement &IV) const {
     return dyn_cast_or_null<ConstantInt>(getConstant(IV));
   }
 
private:
   // information, we need to update the specified user of this instruction.
   void operandChangedState(Instruction *I) {
     if (BBExecutable.count(I->getParent())) // Inst is executable?
       visit(*I);
   }
 
   // Add U as additional user of V.
   void addAdditionalUser(Value *V, User *U) {
-    auto Iter = AdditionalUsers.insert({V, {}});
-    Iter.first->second.insert(U);
+    AdditionalUsers[V].insert(U);
+    AdditionalUserOf[U].insert(V);
   }
 
   // Mark I's users as changed, including AdditionalUsers.
   void markUsersAsChanged(Value *I) {
     // Functions include their arguments in the use-list. Changed function
     // values mean that the result of the function changed. We only need to
     // update the call sites with the new function result and do not have to
     // propagate the call arguments.
     if (isa<Function>(I)) {
       for (User *U : I->users()) {
         if (auto *CB = dyn_cast<CallBase>(U))
           handleCallResult(*CB);
       }
     } else {
       for (User *U : I->users())
         if (auto *UI = dyn_cast<Instruction>(U))
           operandChangedState(UI);
     }
 
-    auto Iter = AdditionalUsers.find(I);
-    if (Iter != AdditionalUsers.end()) {
-      // Copy additional users before notifying them of changes, because new
-      // users may be added, potentially invalidating the iterator.
-      SmallVector<Instruction *, 2> ToNotify;
-      for (User *U : Iter->second)
-        if (auto *UI = dyn_cast<Instruction>(U))
-          ToNotify.push_back(UI);
-      for (Instruction *UI : ToNotify)
-        operandChangedState(UI);
-    }
-  }
+    SmallVector<Instruction *, 8> ToNotify;
+    findAdditionalUsersFor(I, ToNotify);
   void handleCallOverdefined(CallBase &CB);
   void handleCallResult(CallBase &CB);
   void handleCallArguments(CallBase &CB);
 
 private:
   friend class InstVisitor<SCCPInstVisitor>;
 
   // visit implementations - Something changed in this instruction.  Either an
public:
 
   bool removePredicateInfoFor(Instruction *I) {
     auto A = AnalysisResults.find(I->getParent()->getParent());
     if (A == AnalysisResults.end())
       return false;
     return A->second.PredInfo->removePredicateInfoFor(I);
   }
 
+  void removeFromAdditionalUsers(User *U) {
+    auto AUO = AdditionalUserOf.find(U);
+    if (AUO != AdditionalUserOf.end()) {
+      for (Value *V : AUO->second) {
+        auto AU = AdditionalUsers.find(V);
+        if (AU != AdditionalUsers.end())
+          AU->second.erase(U);
+      }
+    }
+  }
+
+  void removeFromAdditionalUserOf(Value *V) {
+    auto AU = AdditionalUsers.find(V);
+    if (AU != AdditionalUsers.end()) {
+      for (User *U : AU->second) {
+        auto AUO = AdditionalUserOf.find(U);
+        if (AUO != AdditionalUserOf.end())
+          AUO->second.erase(V);
+      }
+    }
+  }
+
+  void findAdditionalUsersFor(Value *V, SmallVectorImpl<Instruction *> &Users) {
+    auto Iter = AdditionalUsers.find(V);
+    if (Iter != AdditionalUsers.end())
+      for (User *U : Iter->second)
+        if (auto *I = dyn_cast<Instruction>(U))
+          Users.push_back(I);
+  }
+
   DomTreeUpdater getDTU(Function &F) {
     auto A = AnalysisResults.find(&F);
     assert(A != AnalysisResults.end() && "Need analysis results for function.");
     return {A->second.DT, A->second.PDT, DomTreeUpdater::UpdateStrategy::Lazy};
   }
 
   SCCPInstVisitor(const DataLayout &DL,
                   std::function<const TargetLibraryInfo &(Function &)> GetTLI,