SIL: be more tolerant when a user is deleted during use-list iteration.

Check if an operand's instruction has been deleted in `UseList.next()`.
This allows to delete an instruction, which has two uses of a value, during use-list iteration.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/TestPasses/TestInstructionIteration.swift

@@ -62,6 +62,14 @@ private func handle(instruction: Instruction, _ context: FunctionPassContext) {
         deleteAllInstructions(ofType: BranchInst.self, in: instruction.parentBlock, context)
       case "split_block":
         _ = context.splitBlock(before: instruction)
+      case "print_uses":
+        for use in sl.uses {
+          print("use: \(use)")
+        }
+      case "delete_first_user":
+        deleteUser(of: sl, at: 0, context)
+      case "delete_second_user":
+        deleteUser(of: sl, at: 1, context)
       default:
         break
     }
@@ -75,3 +83,13 @@ private func deleteAllInstructions<InstType: Instruction>(ofType: InstType.Type,
     }
   }
 }
+
+private func deleteUser(of value: Value, at deleteIndex: Int, _ context: FunctionPassContext) {
+  for (idx, use) in value.uses.enumerated() {
+    if idx == deleteIndex {
+      context.erase(instruction: use.instruction)
+    } else {
+      print("use: \(use)")
+    }
+  }  
+}

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -105,8 +105,16 @@ public struct UseList : CollectionLikeSequence {
     var currentOpPtr: OptionalBridgedOperand
 
     public mutating func next() -> Operand? {
-      if let op = currentOpPtr.operand {
-        currentOpPtr = op.getNextUse()
+      if let bridgedOp = currentOpPtr.operand {
+        var op = bridgedOp
+        // Skip operands of deleted instructions.
+        while op.isDeleted() {
+          guard let nextOp = op.getNextUse().operand else {
+            return nil
+          }
+          op = nextOp
+        }
+        currentOpPtr = op.getNextUse();
         return Operand(bridged: op)
       }
       return nil

include/swift/SIL/SILBridging.h

@@ -384,6 +384,7 @@ struct BridgedOperand {
   BRIDGED_INLINE bool isTypeDependent() const;
   BRIDGED_INLINE bool isLifetimeEnding() const;
   BRIDGED_INLINE bool canAcceptOwnership(BridgedValue::Ownership ownership) const;
+  BRIDGED_INLINE bool isDeleted() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE OptionalBridgedOperand getNextUse() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedValue getValue() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction getUser() const;

include/swift/SIL/SILBridgingImpl.h

@@ -616,6 +616,10 @@ bool BridgedOperand::canAcceptOwnership(BridgedValue::Ownership ownership) const
   return op->canAcceptKind(BridgedValue::unbridge(ownership));
 }
 
+bool BridgedOperand::isDeleted() const {
+  return op->getUser() == nullptr;
+}
+
 OptionalBridgedOperand BridgedOperand::getNextUse() const {
   return {op->getNextUse()};
 }

include/swift/SIL/SILValue.h

@@ -1052,6 +1052,7 @@ class Operand {
   Operand **Back = nullptr;
 
   /// The owner of this operand.
+  /// If null, the Owner was deleted (but not freed, yet).
   /// FIXME: this could be space-compressed.
   SILInstruction *Owner;
 
@@ -1104,9 +1105,12 @@ class Operand {
   void drop() {
     removeFromCurrent();
     TheValue = SILValue();
-    NextUse = nullptr;
     Back = nullptr;
     Owner = nullptr;
+    // Note: we are _not_ clearing the `NextUse` pointer to be able to delete
+    // users while iterating over the use list.
+    // In such a case, the iterator can detect that the Owner is null and skip
+    // to the next (non-deleted) use by following the non-null `NextUse` pointer.
   }
 
   ~Operand() {

test/SIL/instruction_iteration.sil

@@ -235,3 +235,61 @@ bb0:
   return %0 : $()
 }
 
+sil @use1 : $@convention(thin) (Builtin.RawPointer) -> ()
+sil @use2 : $@convention(thin) (Builtin.RawPointer, Builtin.RawPointer) -> ()
+
+// LOG-LABEL: Test instruction iteration in print_uses:
+// LOG-NEXT:  bb0:
+// LOG-NEXT:    %0 = string_literal utf8 "print_uses"
+// LOG-NEXT:  use: operand #2 of   %4 = apply %3(%0, %0)
+// LOG-NEXT:  use: operand #1 of   %4 = apply %3(%0, %0)
+// LOG-NEXT:  use: operand #1 of   %2 = apply %1(%0)
+// LOG-NEXT:    // function_ref use1
+// LOG:       End function print_uses:
+sil @print_uses : $@convention(thin) () -> () {
+bb0:
+  %0 = string_literal utf8 "print_uses"
+  %1 = function_ref @use1 : $@convention(thin) (Builtin.RawPointer) -> ()
+  %2 = apply %1(%0) : $@convention(thin) (Builtin.RawPointer) -> ()
+  %3 = function_ref @use2 : $@convention(thin) (Builtin.RawPointer, Builtin.RawPointer) -> ()
+  %4 = apply %3(%0, %0) : $@convention(thin) (Builtin.RawPointer, Builtin.RawPointer) -> ()
+  %5 = tuple ()
+  return %5
+}
+
+// LOG-LABEL: Test instruction iteration in delete_first_user:
+// LOG-NEXT:  bb0:
+// LOG-NEXT:    %0 = string_literal utf8 "delete_first_user"
+// LOG-NEXT:  use: operand #1 of   %2 = apply %1(%0)
+// LOG-NEXT:    // function_ref use1
+// LOG:       End function delete_first_user:
+sil @delete_first_user : $@convention(thin) () -> () {
+bb0:
+  %0 = string_literal utf8 "delete_first_user"
+  %1 = function_ref @use1 : $@convention(thin) (Builtin.RawPointer) -> ()
+  %2 = apply %1(%0) : $@convention(thin) (Builtin.RawPointer) -> ()
+  %3 = function_ref @use2 : $@convention(thin) (Builtin.RawPointer, Builtin.RawPointer) -> ()
+  %4 = apply %3(%0, %0) : $@convention(thin) (Builtin.RawPointer, Builtin.RawPointer) -> ()
+  %5 = tuple ()
+  return %5
+}
+
+// LOG-LABEL: Test instruction iteration in delete_second_user:
+// LOG-NEXT:  bb0:
+// LOG-NEXT:    %0 = string_literal utf8 "delete_second_user"
+// LOG-NEXT:  use: operand #1 of   %5 = apply %1(%0)
+// LOG-NEXT:  use: operand #1 of   %2 = apply %1(%0)
+// LOG-NEXT:    // function_ref use1
+// LOG:       End function delete_second_user:
+sil @delete_second_user : $@convention(thin) () -> () {
+bb0:
+  %0 = string_literal utf8 "delete_second_user"
+  %1 = function_ref @use1 : $@convention(thin) (Builtin.RawPointer) -> ()
+  %2 = apply %1(%0) : $@convention(thin) (Builtin.RawPointer) -> ()
+  %3 = function_ref @use2 : $@convention(thin) (Builtin.RawPointer, Builtin.RawPointer) -> ()
+  %4 = apply %3(%0, %0) : $@convention(thin) (Builtin.RawPointer, Builtin.RawPointer) -> ()
+  %5 = apply %1(%0) : $@convention(thin) (Builtin.RawPointer) -> ()
+  %6 = tuple ()
+  return %6
+}
+