Add UpdatingInstructionIterator.

Track in-use iterators and update them both when instructions are
deleted and when they are added.

Safe iteration in the presence of arbitrary changes now looks like
this:

    for (SILInstruction *inst : deleter.updatingRange(&bb)) {
      modify(inst);
    }

Author: atrick

include/swift/SILOptimizer/Analysis/SimplifyInstruction.h

@@ -25,7 +25,7 @@
 namespace swift {
 
 class SILInstruction;
-class InstModCallbacks;
+struct InstModCallbacks;
 
 /// Replace an instruction with a simplified result and erase it. If the
 /// instruction initiates a scope, do not replace the end of its scope; it will

include/swift/SILOptimizer/Utils/CFGOptUtils.h

@@ -36,7 +36,7 @@ namespace swift {
 class DominanceInfo;
 class SILLoop;
 class SILLoopInfo;
-class InstModCallbacks;
+struct InstModCallbacks;
 
 /// Adds a new argument to an edge between a branch and a destination
 /// block. Allows for user injected callbacks via \p callbacks.

include/swift/SILOptimizer/Utils/InstModCallbacks.h

@@ -68,7 +68,7 @@ namespace swift {
 /// default operation inline. What is nice about this from a perf perspective is
 /// that in a loop this property should predict well since you have a single
 /// branch that is going to go the same way everytime.
-class InstModCallbacks {
+struct InstModCallbacks {
   /// A function that is called to notify that a new function was created.
   ///
   /// Default implementation is a no-op, but we still mark madeChange.
@@ -135,7 +135,6 @@ class InstModCallbacks {
   /// A boolean that tracks if any of our callbacks were ever called.
   bool wereAnyCallbacksInvoked = false;
 
-public:
   InstModCallbacks() = default;
   ~InstModCallbacks() = default;
   InstModCallbacks(const InstModCallbacks &) = default;

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -20,14 +20,15 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_INSTOPTUTILS_H
 #define SWIFT_SILOPTIMIZER_UTILS_INSTOPTUTILS_H
 
-#include "swift/SILOptimizer/Utils/InstModCallbacks.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SILOptimizer/Analysis/ARCAnalysis.h"
 #include "swift/SILOptimizer/Analysis/ClassHierarchyAnalysis.h"
 #include "swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h"
 #include "swift/SILOptimizer/Analysis/SimplifyInstruction.h"
+#include "swift/SILOptimizer/Utils/InstModCallbacks.h"
+#include "swift/SILOptimizer/Utils/UpdatingInstructionIterator.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
 namespace swift {
@@ -208,8 +209,6 @@ bool tryCheckedCastBrJumpThreading(
 ///   deleter.deleteIfDead(instruction);
 ///   deleter.cleanupDeadInstructions();
 ///
-///
-///
 /// This is designed to be used with a single 'onDelete' callback, which is
 /// invoked consistently just before deleting each instruction. It's usually
 /// used to avoid iterator invalidation (see the updatingIterator() factory
@@ -230,37 +229,36 @@ bool tryCheckedCastBrJumpThreading(
 /// Note that the forceDelete* APIs only invoke notifyWillBeDeletedFunc() when
 /// an operand's definition will become dead after force-deleting the specified
 /// instruction. Some clients force-delete related instructions one at a
-/// time. They may not force-deleted. It's the client's responsiblity to invoke
-/// notifyWillBeDeletedFunc() on those explicitly deleted instructions if
-/// needed.
-///
+/// time. It is the client's responsiblity to invoke notifyWillBeDeletedFunc()
+/// on those explicitly deleted instructions if needed.
 class InstructionDeleter {
-public:
-  static InstructionDeleter updatingIterator(SILBasicBlock::iterator &iter) {
-    auto onDelete = InstModCallbacks().onDelete([&](SILInstruction *deadInst) {
-      if (deadInst->getIterator() == iter)
-        ++iter;
-      deadInst->eraseFromParent();
-    });
-    return InstructionDeleter(onDelete);
-  }
-
-private:
   /// A set vector of instructions that are found to be dead. The ordering of
   /// instructions in this set is important as when a dead instruction is
   /// removed, new instructions will be generated to fix the lifetime of the
   /// instruction's operands. This has to be deterministic.
   SmallSetVector<SILInstruction *, 8> deadInstructions;
 
-  /// Callbacks used when adding/deleting instructions.
-  InstModCallbacks callbacks;
+  UpdatingInstructionIteratorRegistry iteratorRegistry;
 
 public:
-  InstructionDeleter() : deadInstructions(), callbacks() {}
-  InstructionDeleter(InstModCallbacks callbacks)
-      : deadInstructions(), callbacks(callbacks) {}
+  InstructionDeleter(InstModCallbacks chainedCallbacks = InstModCallbacks())
+      : deadInstructions(), iteratorRegistry(chainedCallbacks) {}
+
+  InstModCallbacks &getCallbacks() { return iteratorRegistry.getCallbacks(); }
+
+  UpdatingInstructionIteratorRegistry &getIteratorRegistry() {
+    return iteratorRegistry;
+  }
 
-  InstModCallbacks &getCallbacks() { return callbacks; }
+  llvm::iterator_range<UpdatingInstructionIterator>
+  updatingRange(SILBasicBlock *bb) {
+    return iteratorRegistry.makeIteratorRange(bb);
+  }
+
+  llvm::iterator_range<UpdatingReverseInstructionIterator>
+  updatingReverseRange(SILBasicBlock *bb) {
+    return iteratorRegistry.makeReverseIteratorRange(bb);
+  }
 
   /// If the instruction \p inst is dead, record it so that it can be cleaned
   /// up.