[SIL] Perf: Cache basic block during SILSuccessor iteration

include/swift/SIL/SILInstruction.h

@@ -8094,6 +8094,15 @@ inline EnumElementDecl **SelectEnumInstBase::getEnumElementDeclStorage() {
   llvm_unreachable("Unhandled SelectEnumInstBase subclass");
 }
 
+inline void SILSuccessor::pred_iterator::cacheBasicBlock() {
+  if (Cur != nullptr) {
+    Block = Cur->ContainingInst->getParent();
+    assert(Block != nullptr);
+  } else {
+    Block = nullptr;
+  }
+}
+
 } // end swift namespace
 
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILSuccessor.h

@@ -87,33 +87,45 @@ class SILSuccessor {
   class pred_iterator {
     SILSuccessor *Cur;
 
+    // Cache the basic block to avoid repeated pointer chasing.
+    SILBasicBlock *Block;
+
+    void cacheBasicBlock();
+
   public:
     using difference_type = std::ptrdiff_t;
     using value_type = SILBasicBlock *;
     using pointer = SILBasicBlock **;
     using reference = SILBasicBlock *&;
     using iterator_category = std::forward_iterator_tag;
 
-    pred_iterator(SILSuccessor *Cur = 0) : Cur(Cur) {}
+    pred_iterator(SILSuccessor *Cur = nullptr) : Cur(Cur), Block(nullptr) {
+      cacheBasicBlock();
+    }
 
     bool operator==(pred_iterator I2) const { return Cur == I2.Cur; }
     bool operator!=(pred_iterator I2) const { return Cur != I2.Cur; }
 
     pred_iterator &operator++() {
-      assert(Cur && "Trying to advance past end");
+      assert(Cur != nullptr);
       Cur = Cur->Next;
+      cacheBasicBlock();
       return *this;
     }
 
-    pred_iterator operator++(int) {
-      pred_iterator copy = *this;
-      ++*this;
+    pred_iterator operator+(unsigned distance) const {
+      auto copy = *this;
+      if (distance == 0)
+        return copy;
+      do {
+        copy.Cur = Cur->Next;
+      } while (--distance > 0);
+      copy.cacheBasicBlock();
       return copy;
     }
 
     SILSuccessor *getSuccessorRef() const { return Cur; }
-    SILBasicBlock *operator*();
-    const SILBasicBlock *operator*() const;
+    SILBasicBlock *operator*() const { return Block; }
   };
 };
 

lib/SIL/SILSuccessor.cpp

@@ -37,15 +37,3 @@ void SILSuccessor::operator=(SILBasicBlock *BB) {
 
   SuccessorBlock = BB;
 }
-
-// Dereferencing the pred_iterator returns the predecessor's SILBasicBlock.
-SILBasicBlock *SILSuccessor::pred_iterator::operator*() {
-  assert(Cur && "Can't deference end (or default constructed) iterator");
-  return Cur->ContainingInst->getParent();
-}
-
-// Dereferencing the pred_iterator returns the predecessor's SILBasicBlock.
-const SILBasicBlock *SILSuccessor::pred_iterator::operator*() const {
-  assert(Cur && "Can't deference end (or default constructed) iterator");
-  return Cur->ContainingInst->getParent();
-}