SIL: remove the notifyDeleteHandlers mechanism

It's not needed anymore with delayed instruction deletion.
It was used for two purposes:
1. For analysis, which cache instructions, to avoid dangling instruction pointers
2. For passes, which maintain worklists of instructions, to remove a deleted instructions from the worklist. This is now done by checking SILInstruction::isDeleted().

Author: eeckstein

include/swift/SIL/Notifications.h

@@ -239,27 +239,6 @@ class DeserializationNotificationHandlerSet final
   void didDeserialize(ModuleDecl *mod,
                       SILDefaultWitnessTable *wtable) override;
 };
-
-/// A protocol (or interface) for handling value deletion notifications.
-///
-/// This class is used as a base class for any class that need to accept
-/// instruction deletion notification messages. This is used by passes and
-/// analysis that need to invalidate data structures that contain pointers.
-/// This is similar to LLVM's ValueHandle.
-struct DeleteNotificationHandler {
-  DeleteNotificationHandler() { }
-  virtual ~DeleteNotificationHandler() {}
-
-  /// Handle the invalidation message for the value \p Value.
-  virtual void handleDeleteNotification(SILNode *value) { }
-
-  /// Returns True if the pass, analysis or other entity wants to receive
-  /// notifications. This callback is called once when the class is being
-  /// registered, and not once per notification. Entities that implement
-  /// this callback should always return a constant answer (true/false).
-  virtual bool needsNotifications() { return false; }
-};
-
 } // namespace swift
 
 #endif

include/swift/SIL/SILModule.h

@@ -345,10 +345,6 @@ class SILModule {
   /// Action to be executed for serializing the SILModule.
   ActionCallback SerializeSILAction;
 
-  /// A list of clients that need to be notified when an instruction
-  /// invalidation message is sent.
-  llvm::SetVector<DeleteNotificationHandler*> NotificationHandlers;
-
   SILModule(llvm::PointerUnion<FileUnit *, ModuleDecl *> context,
             Lowering::TypeConverter &TC, const SILOptions &Options);
 
@@ -424,16 +420,6 @@ class SILModule {
   /// Called after an instruction is moved from one function to another.
   void notifyMovedInstruction(SILInstruction *inst, SILFunction *fromFunction);
 
-  /// Add a delete notification handler \p Handler to the module context.
-  void registerDeleteNotificationHandler(DeleteNotificationHandler* Handler);
-
-  /// Remove the delete notification handler \p Handler from the module context.
-  void removeDeleteNotificationHandler(DeleteNotificationHandler* Handler);
-
-  /// Send the invalidation message that \p V is being deleted to all
-  /// registered handlers. The order of handlers is deterministic but arbitrary.
-  void notifyDeleteHandlers(SILNode *node);
-
   /// Set a serialization action.
   void setSerializeSILAction(ActionCallback SerializeSILAction);
   ActionCallback getSerializeSILAction() const;

include/swift/SILOptimizer/Analysis/Analysis.h

@@ -36,7 +36,7 @@ struct SILAnalysisKind {
 };
 
 /// The base class for all SIL-level analysis.
-class SILAnalysis : public DeleteNotificationHandler {
+class SILAnalysis {
 public:
   /// This is a list of values that allow passes to communicate to analysis
   /// which traits of the code were invalidated. Based on this information

include/swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h

@@ -235,12 +235,6 @@ class EpilogueARCFunctionInfo {
   llvm::DenseMap<SILValue, ARCInstructions> EpilogueReleaseInstCache;
 
 public:
-  void handleDeleteNotification(SILNode *node) {
-    // Being conservative and clear everything for now.
-    EpilogueRetainInstCache.clear();
-    EpilogueReleaseInstCache.clear();
-  }
-
   /// Constructor.
   EpilogueARCFunctionInfo(SILFunction *F, PostOrderAnalysis *PO,
                           AliasAnalysis *AA, RCIdentityAnalysis *RC)
@@ -288,22 +282,6 @@ class EpilogueARCAnalysis : public FunctionAnalysisBase<EpilogueARCFunctionInfo>
   EpilogueARCAnalysis(const EpilogueARCAnalysis &) = delete;
   EpilogueARCAnalysis &operator=(const EpilogueARCAnalysis &) = delete;
 
-  virtual void handleDeleteNotification(SILNode *node) override {
-    // If the parent function of this instruction was just turned into an
-    // external declaration, bail. This happens during SILFunction destruction.
-    SILFunction *F = node->getFunction();
-    if (F->isExternalDeclaration()) {
-      return;
-    }
-
-    // If we do have an analysis, tell it to handle its delete notifications.
-    if (auto A = maybeGet(F)) {
-      A.get()->handleDeleteNotification(node);
-    }
-  }
-
-  virtual bool needsNotifications() override { return true; }
-
   static bool classof(const SILAnalysis *S) {
     return S->getKind() == SILAnalysisKind::EpilogueARC;
   }

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -832,11 +832,6 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
     /// Propagates the escape states through the graph.
     void propagateEscapeStates();
 
-    /// Remove a value from the graph. Do not delete the mapped node, but reset
-    /// mappedValue if it is set to this value, and make sure that the node
-    /// cannot be looked up with getNode().
-    void removeFromGraph(ValueBase *V);
-
     enum class Traversal { Follow, Backtrack, Halt };
 
     /// Traverse backward from startNode, following predecessor edges.
@@ -1237,10 +1232,6 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   /// Notify the analysis about changed witness or vtables.
   virtual void invalidateFunctionTables() override { }
 
-  virtual void handleDeleteNotification(SILNode *N) override;
-
-  virtual bool needsNotifications() override { return true; }
-
   virtual void verify() const override;
 
   virtual void verify(SILFunction *F) const override;

include/swift/SILOptimizer/Analysis/RCIdentityAnalysis.h

@@ -69,20 +69,6 @@ class RCIdentityFunctionInfo {
   /// intermediate array.
   void visitRCUses(SILValue V, function_ref<void(Operand *)> Visitor);
 
-  void handleDeleteNotification(SILNode *node) {
-    auto value = dyn_cast<ValueBase>(node);
-    if (!value)
-      return;
-
-    // Check the cache. If we don't find it, there is nothing to do.
-    auto Iter = RCCache.find(SILValue(value));
-    if (Iter == RCCache.end())
-      return;
-
-    // Then erase Iter from the cache.
-    RCCache.erase(Iter);
-  }
-
 private:
   SILValue getRCIdentityRootInner(SILValue V, unsigned RecursionDepth);
   SILValue stripRCIdentityPreservingOps(SILValue V, unsigned RecursionDepth);
@@ -104,18 +90,6 @@ class RCIdentityAnalysis : public FunctionAnalysisBase<RCIdentityFunctionInfo> {
   RCIdentityAnalysis(const RCIdentityAnalysis &) = delete;
   RCIdentityAnalysis &operator=(const RCIdentityAnalysis &) = delete;
 
-  virtual void handleDeleteNotification(SILNode *node) override {
-    // If the parent function of this instruction was just turned into an
-    // external declaration, bail. This happens during SILFunction destruction.
-    SILFunction *F = node->getFunction();
-    if (F->isExternalDeclaration()) {
-      return;
-    }
-    get(F)->handleDeleteNotification(node);
-  }
-
-  virtual bool needsNotifications() override { return true; }
-
   static bool classof(const SILAnalysis *S) {
     return S->getKind() == SILAnalysisKind::RCIdentity;
   }

include/swift/SILOptimizer/PassManager/Transforms.h

@@ -22,7 +22,7 @@ namespace swift {
   class PrettyStackTraceSILFunctionTransform;
 
   /// The base class for all SIL-level transformations.
-  class SILTransform : public DeleteNotificationHandler {
+  class SILTransform {
   public:
     /// The kind of transformation passes we use.
     enum class TransformKind {

lib/SIL/IR/SILBasicBlock.cpp

@@ -158,9 +158,6 @@ SILFunctionArgument *SILBasicBlock::replaceFunctionArgument(
 
   assert(ArgumentList[i]->use_empty() && "Expected no uses of the old arg!");
 
-  // Notify the delete handlers that this argument is being deleted.
-  M.notifyDeleteHandlers(ArgumentList[i]);
-
   SILFunctionArgument *NewArg = new (M) SILFunctionArgument(Ty, Kind, D);
   NewArg->setParent(this);
 
@@ -184,9 +181,6 @@ SILPhiArgument *SILBasicBlock::replacePhiArgument(unsigned i, SILType Ty,
 
   assert(ArgumentList[i]->use_empty() && "Expected no uses of the old BB arg!");
 
-  // Notify the delete handlers that this argument is being deleted.
-  M.notifyDeleteHandlers(ArgumentList[i]);
-
   SILPhiArgument *NewArg = new (M) SILPhiArgument(Ty, Kind, D);
   NewArg->setParent(this);
 
@@ -246,8 +240,6 @@ SILPhiArgument *SILBasicBlock::insertPhiArgument(unsigned AtArgPos, SILType Ty,
 void SILBasicBlock::eraseArgument(int Index) {
   assert(getArgument(Index)->use_empty() &&
          "Erasing block argument that has uses!");
-  // Notify the delete handlers that this BB argument is going away.
-  getModule().notifyDeleteHandlers(getArgument(Index));
   ArgumentList.erase(ArgumentList.begin() + Index);
 }
 

lib/SIL/IR/SILModule.cpp

@@ -808,36 +808,6 @@ void SILModule::notifyMovedInstruction(SILInstruction *inst,
   }
 }
 
-void SILModule::registerDeleteNotificationHandler(
-    DeleteNotificationHandler *handler) {
-  // Ask the handler (that can be an analysis, a pass, or some other data
-  // structure) if it wants to receive delete notifications.
-  if (handler->needsNotifications()) {
-    NotificationHandlers.insert(handler);
-  }
-}
-
-void SILModule::
-removeDeleteNotificationHandler(DeleteNotificationHandler* Handler) {
-  NotificationHandlers.remove(Handler);
-}
-
-void SILModule::notifyDeleteHandlers(SILNode *node) {
-  // Update openedArchetypeDefs.
-  if (auto *svi = dyn_cast<SingleValueInstruction>(node)) {
-    if (CanArchetypeType archeTy = svi->getOpenedArchetype()) {
-      OpenedArchetypeKey key = {archeTy, svi->getFunction()};
-      assert(openedArchetypeDefs.lookup(key) == svi &&
-             "archetype def was not registered");
-      openedArchetypeDefs.erase(key);
-    }
-  }
-
-  for (auto *Handler : NotificationHandlers) {
-    Handler->handleDeleteNotification(node);
-  }
-}
-
 // TODO: We should have an "isNoReturn" bit on Swift's BuiltinInfo, but for
 // now, let's recognize noreturn intrinsics and builtins specially here.
 bool SILModule::isNoReturnBuiltinOrIntrinsic(Identifier Name) {

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -1271,15 +1271,6 @@ bool EscapeAnalysis::ConnectionGraph::forwardTraverseDefer(
   return true;
 }
 
-void EscapeAnalysis::ConnectionGraph::removeFromGraph(ValueBase *V) {
-  CGNode *node = Values2Nodes.lookup(V);
-  if (!node)
-    return;
-  Values2Nodes.erase(V);
-  if (node->mappedValue == V)
-    node->mappedValue = nullptr;
-}
-
 //===----------------------------------------------------------------------===//
 //                      Dumping, Viewing and Verification
 //===----------------------------------------------------------------------===//
@@ -2922,21 +2913,6 @@ void EscapeAnalysis::invalidate(SILFunction *F, InvalidationKind K) {
   }
 }
 
-void EscapeAnalysis::handleDeleteNotification(SILNode *node) {
-  auto value = dyn_cast<ValueBase>(node);
-  if (!value) return;
-
-  if (SILBasicBlock *Parent = node->getParentBlock()) {
-    SILFunction *F = Parent->getParent();
-    if (FunctionInfo *FInfo = Function2Info.lookup(F)) {
-      if (FInfo->isValid()) {
-        FInfo->Graph.removeFromGraph(value);
-        FInfo->SummaryGraph.removeFromGraph(value);
-      }
-    }
-  }
-}
-
 void EscapeAnalysis::verify() const {
 #ifndef NDEBUG
   for (auto Iter : Function2Info) {