SIL: Add mark_dependence_addr

Author: atrick

SwiftCompilerSources/Sources/Optimizer/TestPasses/MemBehaviorDumper.swift

@@ -75,6 +75,7 @@ private extension Instruction {
          is BuiltinInst,
          is StoreBorrowInst,
          is MarkDependenceInst,
+         is MarkDependenceAddrInst,
          is DebugValueInst:
       return true
     default:

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -568,11 +568,17 @@ public struct Builder {
     return notifyNew(endMutation.getAs(EndCOWMutationInst.self))
   }
 
-  public func createMarkDependence(value: Value, base: Value, kind: MarkDependenceInst.DependenceKind) -> MarkDependenceInst {
+  public func createMarkDependence(value: Value, base: Value, kind: MarkDependenceKind) -> MarkDependenceInst {
     let markDependence = bridged.createMarkDependence(value.bridged, base.bridged,
                                                       BridgedInstruction.MarkDependenceKind(rawValue: kind.rawValue)!)
     return notifyNew(markDependence.getAs(MarkDependenceInst.self))
   }
+
+  public func createMarkDependenceAddr(value: Value, base: Value, kind: MarkDependenceKind) -> MarkDependenceAddrInst {
+    let markDependence = bridged.createMarkDependenceAddr(
+      value.bridged, base.bridged, BridgedInstruction.MarkDependenceKind(rawValue: kind.rawValue)!)
+    return notifyNew(markDependence.getAs(MarkDependenceAddrInst.self))
+  }
 
   @discardableResult
   public func createEndAccess(beginAccess: BeginAccessInst) -> EndAccessInst {

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1082,22 +1082,34 @@ class GetAsyncContinuationAddrInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class ExtractExecutorInst : SingleValueInstruction {}
 
-final public
-class MarkDependenceInst : SingleValueInstruction {
-  public enum DependenceKind: Int32 {
-    case Unresolved = 0
-    case Escaping = 1
-    case NonEscaping = 2
-  }
+public enum MarkDependenceKind: Int32 {
+  case Unresolved = 0
+  case Escaping = 1
+  case NonEscaping = 2
+}
+
+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 }
+}
+
+final public class MarkDependenceInst : SingleValueInstruction, MarkDependenceInstruction {
   public var valueOperand: Operand { operands[0] }
   public var baseOperand: Operand { operands[1] }
   public var value: Value { return valueOperand.value }
   public var base: Value { return baseOperand.value }
-  public var dependenceKind: DependenceKind {
-    DependenceKind(rawValue: bridged.MarkDependenceInst_dependenceKind().rawValue)!
+
+  public var dependenceKind: MarkDependenceKind {
+    MarkDependenceKind(rawValue: bridged.MarkDependenceInst_dependenceKind().rawValue)!
   }
-  public var isNonEscaping: Bool { dependenceKind == .NonEscaping }
-  public var isUnresolved: Bool { dependenceKind == .Unresolved }
 
   public func resolveToNonEscaping() {
     bridged.MarkDependenceInst_resolveToNonEscaping()
@@ -1112,6 +1124,25 @@ class MarkDependenceInst : SingleValueInstruction {
   }
 }
 
+final public class MarkDependenceAddrInst : Instruction, MarkDependenceInstruction {
+  public var addressOperand: Operand { operands[0] }
+  public var baseOperand: Operand { operands[1] }
+  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 {
   public var convertedOperand: Operand { operands[0] }
   public var maskOperand: Operand { operands[1] }

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -195,6 +195,7 @@ public func registerSILClasses() {
   register(ObjCMetatypeToObjectInst.self)
   register(ValueToBridgeObjectInst.self)
   register(MarkDependenceInst.self)
+  register(MarkDependenceAddrInst.self)
   register(RefToBridgeObjectInst.self)
   register(BridgeObjectToRefInst.self)
   register(BridgeObjectToWordInst.self)

include/swift/SIL/AddressWalker.h

@@ -305,19 +305,25 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) {
       continue;
     }
 
-    if (auto *mdi = dyn_cast<MarkDependenceInst>(user)) {
+    if (auto mdi = MarkDependenceInstruction(user)) {
       // TODO: continue walking the dependent value, which may not be an
       // address. See AddressUtils.swift. Until that is implemented, this must
       // be considered a pointer escape.
-      if (op->get() == mdi->getBase()) {
+      if (op->get() == mdi.getBase()) {
         recordEscape(op, AddressUseKind::Dependent);
         callVisitUse(op);
         continue;
       }
-
-      // If we are the value use, look through it.
-      transitiveResultUses(op);
-      continue;
+      if (auto *mdi = dyn_cast<MarkDependenceInst>(user)) {
+        // If we are the value use of a forwarding markdep, look through it.
+        transitiveResultUses(op);
+        continue;
+      }
+      if (auto *mdi = dyn_cast<MarkDependenceAddrInst>(user)) {
+        // The address operand is simply a leaf use.
+        callVisitUse(op);
+        continue;
+      }
     }
 
     // We were unable to recognize this user, so set AddressUseKind to unknown

include/swift/SIL/InstWrappers.h

@@ -293,7 +293,7 @@ class ForwardingOperation {
     case SILInstructionKind::DifferentiableFunctionInst:
       return nullptr;
     case SILInstructionKind::MarkDependenceInst:
-      return &forwardingInst->getOperandRef(MarkDependenceInst::Value);
+      return &forwardingInst->getOperandRef(MarkDependenceInst::Dependent);
     case SILInstructionKind::RefToBridgeObjectInst:
       return
         &forwardingInst->getOperandRef(RefToBridgeObjectInst::ConvertedOperand);

include/swift/SIL/SILBridging.h

@@ -777,6 +777,9 @@ struct BridgedInstruction {
   BRIDGED_INLINE MarkDependenceKind MarkDependenceInst_dependenceKind() const;
   BRIDGED_INLINE void MarkDependenceInst_resolveToNonEscaping() const;
   BRIDGED_INLINE void MarkDependenceInst_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;
@@ -1222,6 +1225,9 @@ struct BridgedBuilder{
                                                                              bool keepUnique) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createMarkDependence(
     BridgedValue value, BridgedValue base, BridgedInstruction::MarkDependenceKind dependenceKind) const;
+
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createMarkDependenceAddr(
+    BridgedValue value, BridgedValue base, BridgedInstruction::MarkDependenceKind dependenceKind) const;
 
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createEndAccess(BridgedValue value) const;
 

include/swift/SIL/SILBridgingImpl.h

@@ -1356,6 +1356,18 @@ void BridgedInstruction::MarkDependenceInst_settleToEscaping() const {
   getAs<swift::MarkDependenceInst>()->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();
 }
@@ -2378,6 +2390,12 @@ BridgedInstruction BridgedBuilder::createMarkDependence(BridgedValue value, Brid
   return {unbridged().createMarkDependence(regularLoc(), value.getSILValue(), base.getSILValue(), swift::MarkDependenceKind(kind))};
 }
 
+BridgedInstruction BridgedBuilder::createMarkDependenceAddr(BridgedValue value, BridgedValue base, BridgedInstruction::MarkDependenceKind kind) const {
+  return {unbridged().createMarkDependenceAddr(
+      regularLoc(), value.getSILValue(), base.getSILValue(),
+      swift::MarkDependenceKind(kind))};
+}
+
 BridgedInstruction BridgedBuilder::createEndAccess(BridgedValue value) const {
   return {unbridged().createEndAccess(regularLoc(), value.getSILValue(), false)};
 }

include/swift/SIL/SILBuilder.h

@@ -2338,6 +2338,14 @@ class SILBuilder {
                     forwardingOwnershipKind, dependenceKind));
   }
 
+  MarkDependenceAddrInst *
+  createMarkDependenceAddr(SILLocation Loc, SILValue address, SILValue base,
+                           MarkDependenceKind dependenceKind) {
+    return insert(new (getModule()) MarkDependenceAddrInst(
+                    getSILDebugLocation(Loc), address, base,
+                    dependenceKind));
+  }
+
   IsUniqueInst *createIsUnique(SILLocation Loc, SILValue operand) {
     auto Int1Ty = SILType::getBuiltinIntegerType(1, getASTContext());
     return insert(new (getModule()) IsUniqueInst(getSILDebugLocation(Loc),

include/swift/SIL/SILCloner.h

@@ -3142,6 +3142,17 @@ void SILCloner<ImplClass>::visitMarkDependenceInst(MarkDependenceInst *Inst) {
                 Inst->dependenceKind()));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::
+visitMarkDependenceAddrInst(MarkDependenceAddrInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createMarkDependenceAddr(
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getAddress()),
+                getOpValue(Inst->getBase()),
+                Inst->dependenceKind()));
+}
+
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitStrongReleaseInst(StrongReleaseInst *Inst) {