SIL: improve and fix mark-dependence instruction APIs

* Move the mutating APIs into Context.swift, because SIL can only be mutated through a MutatingContext
* move the `baseOperand` and `base` properties from the instruction classes to the `MarkDependenceInstruction` protocol
* add `valueOrAddressOperand` and `valueOrAddress` in the `MarkDependenceInstruction` protocol

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -69,7 +69,7 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
       // mark_dependence will hanceforth be treated as an unknown use by the optimizer.  In the future, we should not
       // need to set this flag during diagnostics because, for escapable types, mark_dependence [unresolved] will all be
       // settled during an early LifetimeNormalization pass.
-      markDep.settleToEscaping()
+      markDep.settleToEscaping(context)
       continue
     }
     if let apply = instruction as? FullApplySite {

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -776,6 +776,20 @@ extension CopyAddrInst {
   }
 }
 
+extension MarkDependenceInstruction {
+  func resolveToNonEscaping(_ context: some MutatingContext) {
+    context.notifyInstructionsChanged()
+    bridged.MarkDependenceInstruction_resolveToNonEscaping()
+    context.notifyInstructionChanged(self)
+  }
+
+  func settleToEscaping(_ context: some MutatingContext) {
+    context.notifyInstructionsChanged()
+    bridged.MarkDependenceInstruction_settleToEscaping()
+    context.notifyInstructionChanged(self)
+  }
+}
+
 extension TermInst {
   func replaceBranchTarget(from fromBlock: BasicBlock, to toBlock: BasicBlock, _ context: some MutatingContext) {
     context.notifyBranchesChanged()

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -226,9 +226,9 @@ extension LifetimeDependence {
     return scope.computeRange(context)
   }
 
-  func resolve(_ context: some Context) {
+  func resolve(_ context: some MutatingContext) {
     if let mdi = markDepInst {
-      mdi.resolveToNonEscaping()
+      mdi.resolveToNonEscaping(context)
     }
   }
 }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1124,58 +1124,39 @@ public enum MarkDependenceKind: Int32 {
 }
 
 public protocol MarkDependenceInstruction: Instruction {
-  var baseOperand: Operand { get }
-  var base: Value { get }
   var dependenceKind: MarkDependenceKind { get }
-  func resolveToNonEscaping()
-  func settleToEscaping()
 }
 
 extension MarkDependenceInstruction {
   public var isNonEscaping: Bool { dependenceKind == .NonEscaping }
   public var isUnresolved: Bool { dependenceKind == .Unresolved }
+
+  public var valueOrAddressOperand: Operand { operands[0] }
+  public var valueOrAddress: Value { valueOrAddressOperand.value }
+  public var baseOperand: Operand { operands[1] }
+  public var base: Value { baseOperand.value }
 }
 
 final public class MarkDependenceInst : SingleValueInstruction, MarkDependenceInstruction {
-  public var valueOperand: Operand { operands[0] }
-  public var baseOperand: Operand { operands[1] }
+  public var valueOperand: Operand { valueOrAddressOperand }
   public var value: Value { return valueOperand.value }
-  public var base: Value { return baseOperand.value }
 
   public var dependenceKind: MarkDependenceKind {
     MarkDependenceKind(rawValue: bridged.MarkDependenceInst_dependenceKind().rawValue)!
   }
 
-  public func resolveToNonEscaping() {
-    bridged.MarkDependenceInst_resolveToNonEscaping()
-  }
-
-  public func settleToEscaping() {
-    bridged.MarkDependenceInst_settleToEscaping()
-  }
-
   public var hasScopedLifetime: Bool {
     return isNonEscaping && type.isObject && ownership == .owned && type.isEscapable(in: parentFunction)
   }
 }
 
 final public class MarkDependenceAddrInst : Instruction, MarkDependenceInstruction {
-  public var addressOperand: Operand { operands[0] }
-  public var baseOperand: Operand { operands[1] }
+  public var addressOperand: Operand { valueOrAddressOperand }
   public var address: Value { return addressOperand.value }
-  public var base: Value { return baseOperand.value }
 
   public var dependenceKind: MarkDependenceKind {
     MarkDependenceKind(rawValue: bridged.MarkDependenceAddrInst_dependenceKind().rawValue)!
   }
-
-  public func resolveToNonEscaping() {
-    bridged.MarkDependenceAddrInst_resolveToNonEscaping()
-  }
-
-  public func settleToEscaping() {
-    bridged.MarkDependenceAddrInst_settleToEscaping()
-  }
 }
 
 final public class RefToBridgeObjectInst : SingleValueInstruction {

include/swift/SIL/SILBridging.h

@@ -803,11 +803,9 @@ struct BridgedInstruction {
   BRIDGED_INLINE SwiftInt StoreInst_getStoreOwnership() const;
   BRIDGED_INLINE SwiftInt AssignInst_getAssignOwnership() const;
   BRIDGED_INLINE MarkDependenceKind MarkDependenceInst_dependenceKind() const;
-  BRIDGED_INLINE void MarkDependenceInst_resolveToNonEscaping() const;
-  BRIDGED_INLINE void MarkDependenceInst_settleToEscaping() const;
+  BRIDGED_INLINE void MarkDependenceInstruction_resolveToNonEscaping() const;
+  BRIDGED_INLINE void MarkDependenceInstruction_settleToEscaping() const;
   BRIDGED_INLINE MarkDependenceKind MarkDependenceAddrInst_dependenceKind() const;
-  BRIDGED_INLINE void MarkDependenceAddrInst_resolveToNonEscaping() const;
-  BRIDGED_INLINE void MarkDependenceAddrInst_settleToEscaping() const;
   BRIDGED_INLINE SwiftInt BeginAccessInst_getAccessKind() const;
   BRIDGED_INLINE bool BeginAccessInst_isStatic() const;
   BRIDGED_INLINE bool BeginAccessInst_isUnsafe() const;

include/swift/SIL/SILBridgingImpl.h

@@ -1425,26 +1425,26 @@ BridgedInstruction::MarkDependenceKind BridgedInstruction::MarkDependenceInst_de
   return (MarkDependenceKind)getAs<swift::MarkDependenceInst>()->dependenceKind();
 }
 
-void BridgedInstruction::MarkDependenceInst_resolveToNonEscaping() const {
-  getAs<swift::MarkDependenceInst>()->resolveToNonEscaping();
+void BridgedInstruction::MarkDependenceInstruction_resolveToNonEscaping() const {
+  if (auto *mdi = llvm::dyn_cast<swift::MarkDependenceInst>(unbridged())) {
+    mdi->resolveToNonEscaping();
+  } else {
+    getAs<swift::MarkDependenceAddrInst>()->resolveToNonEscaping();
+  }
 }
 
-void BridgedInstruction::MarkDependenceInst_settleToEscaping() const {
-  getAs<swift::MarkDependenceInst>()->settleToEscaping();
+void BridgedInstruction::MarkDependenceInstruction_settleToEscaping() const {
+  if (auto *mdi = llvm::dyn_cast<swift::MarkDependenceInst>(unbridged())) {
+    mdi->settleToEscaping();
+  } else {
+    getAs<swift::MarkDependenceAddrInst>()->settleToEscaping();
+  }
 }
 
 BridgedInstruction::MarkDependenceKind BridgedInstruction::MarkDependenceAddrInst_dependenceKind() const {
   return (MarkDependenceKind)getAs<swift::MarkDependenceAddrInst>()->dependenceKind();
 }
 
-void BridgedInstruction::MarkDependenceAddrInst_resolveToNonEscaping() const {
-  getAs<swift::MarkDependenceAddrInst>()->resolveToNonEscaping();
-}
-
-void BridgedInstruction::MarkDependenceAddrInst_settleToEscaping() const {
-  getAs<swift::MarkDependenceAddrInst>()->settleToEscaping();
-}
-
 SwiftInt BridgedInstruction::BeginAccessInst_getAccessKind() const {
   return (SwiftInt)getAs<swift::BeginAccessInst>()->getAccessKind();
 }