Merge pull request #70705 from atrick/markdep-nonescaping

Add mark_dependence [nonescaping] flag.

Author: atrick

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -375,4 +375,9 @@ public struct Builder {
     let endMutation = bridged.createEndCOWMutation(instance.bridged, keepUnique)
     return notifyNew(endMutation.getAs(EndCOWMutationInst.self))
   }
+
+  public func createMarkDependence(value: Value, base: Value, isNonEscaping: Bool) -> MarkDependenceInst {
+    let markDependence = bridged.createMarkDependence(value.bridged, base.bridged, isNonEscaping)
+    return notifyNew(markDependence.getAs(MarkDependenceInst.self))
+  }
 }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -824,13 +824,13 @@ class GetAsyncContinuationInst : SingleValueInstruction {}
 final public
 class GetAsyncContinuationAddrInst : SingleValueInstruction, UnaryInstruction {}
 
-
 final public
 class MarkDependenceInst : SingleValueInstruction, ForwardingInstruction {
   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 isNonEscaping: Bool { bridged.MarkDependenceInst_isNonEscaping() }
 }
 
 final public class RefToBridgeObjectInst : SingleValueInstruction, ForwardingInstruction {

docs/SIL.rst

@@ -5503,24 +5503,35 @@ mark_dependence
 
 ::
 
-  sil-instruction :: 'mark_dependence' sil-operand 'on' sil-operand
-
-  %2 = mark_dependence %0 : $*T on %1 : $Builtin.NativeObject
-
-Indicates that the validity of the first operand depends on the value
-of the second operand.  Operations that would destroy the second value
-must not be moved before any instructions which depend on the result
-of this instruction, exactly as if the address had been obviously
-derived from that operand (e.g. using ``ref_element_addr``).
-
-The result is always equal to the first operand.  The first operand
-will typically be an address, but it could be an address in a
-non-obvious form, such as a Builtin.RawPointer or a struct containing
-the same.  Transformations should be somewhat forgiving here.
-
-The second operand may have either object or address type.  In the
-latter case, the dependency is on the current value stored in the
-address.
+  sil-instruction :: 'mark_dependence' '[nonescaping]'? sil-operand 'on' sil-operand
+
+  %2 = mark_dependence %value : $*T on %base : $Builtin.NativeObject
+
+Indicates that the validity of ``%value`` depends on the value of
+``%base``. Operations that would destroy ``%base`` must not be moved
+before any instructions which depend on the result of this
+instruction, exactly as if the address had been directly derived from
+that operand (e.g. using ``ref_element_addr``).
+
+The result is the forwarded value of ``%value``. ``%value`` may be an
+address, but it could be an address in a non-obvious form, such as a
+Builtin.RawPointer or a struct containing the same.
+
+``%base`` may have either object or address type. In the latter case,
+the dependency is on the current value stored in the address.
+
+The optional ``nonescaping`` attribute indicates that no value derived
+from ``%value`` escapes the lifetime of ``%base``. As with escaping
+``mark_dependence``, all values transitively forwarded from ``%value``
+must be destroyed within the lifetime of ``%base``. Unlike escaping
+``mark_dependence``, this must be statically verifiable. Additionally,
+unlike escaping ``mark_dependence``, derived values include copies of
+``%value`` and values transitively forwarded from those copies. If
+``%base`` is identical to ``%value`` this simply means that copies of
+``%value`` do not outlive the original OSSA lifetime of
+``%value``. Furthermore, unlike escaping ``mark_dependence``, no value
+derived from ``%value`` may have a bitwise escape (conversion to
+UnsafePointer) or pointer escape (unknown use).
 
 is_unique
 `````````

include/swift/SIL/SILBridging.h

@@ -794,6 +794,7 @@ struct BridgedInstruction {
   BRIDGED_INLINE SwiftInt SwitchEnumInst_getCaseIndex(SwiftInt idx) const;
   BRIDGED_INLINE SwiftInt StoreInst_getStoreOwnership() const;
   BRIDGED_INLINE SwiftInt AssignInst_getAssignOwnership() const;
+  BRIDGED_INLINE bool MarkDependenceInst_isNonEscaping() const;
   BRIDGED_INLINE AccessKind BeginAccessInst_getAccessKind() const;
   BRIDGED_INLINE bool BeginAccessInst_isStatic() const;
   BRIDGED_INLINE bool CopyAddrInst_isTakeOfSrc() const;
@@ -1118,6 +1119,7 @@ struct BridgedBuilder{
                                           BridgedType::MetatypeRepresentation representation) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createEndCOWMutation(BridgedValue instance,
                                                                              bool keepUnique) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createMarkDependence(BridgedValue value, BridgedValue base, bool isNonEscaping) const;
 };
 
 // Passmanager and Context

include/swift/SIL/SILBridgingImpl.h

@@ -1040,6 +1040,10 @@ SwiftInt BridgedInstruction::AssignInst_getAssignOwnership() const {
   return (SwiftInt)getAs<swift::AssignInst>()->getOwnershipQualifier();
 }
 
+bool BridgedInstruction::MarkDependenceInst_isNonEscaping() const {
+  return getAs<swift::MarkDependenceInst>()->isNonEscaping();
+}
+
 BridgedInstruction::AccessKind BridgedInstruction::BeginAccessInst_getAccessKind() const {
   return (AccessKind)getAs<swift::BeginAccessInst>()->getAccessKind();
 }
@@ -1599,6 +1603,10 @@ BridgedInstruction BridgedBuilder::createEndCOWMutation(BridgedValue instance, b
                                            keepUnique)};
 }
 
+BridgedInstruction BridgedBuilder::createMarkDependence(BridgedValue value, BridgedValue base, bool isNonEscaping) const {
+  return {unbridged().createMarkDependence(regularLoc(), value.getSILValue(), base.getSILValue(), isNonEscaping)};
+}
+
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
 #endif

include/swift/SIL/SILBuilder.h

@@ -2284,15 +2284,18 @@ class SILBuilder {
                                                        SILValue value);
 
   MarkDependenceInst *createMarkDependence(SILLocation Loc, SILValue value,
-                                           SILValue base) {
-    return createMarkDependence(Loc, value, base, value->getOwnershipKind());
+                                           SILValue base, bool isNonEscaping) {
+    return createMarkDependence(Loc, value, base, value->getOwnershipKind(),
+                                isNonEscaping);
   }
 
   MarkDependenceInst *
   createMarkDependence(SILLocation Loc, SILValue value, SILValue base,
-                       ValueOwnershipKind forwardingOwnershipKind) {
+                       ValueOwnershipKind forwardingOwnershipKind,
+                       bool isNonEscaping) {
     return insert(new (getModule()) MarkDependenceInst(
-        getSILDebugLocation(Loc), value, base, forwardingOwnershipKind));
+                    getSILDebugLocation(Loc), value, base,
+                    forwardingOwnershipKind, isNonEscaping));
   }
 
   IsUniqueInst *createIsUnique(SILLocation Loc, SILValue operand) {

include/swift/SIL/SILCloner.h

@@ -2950,8 +2950,9 @@ void SILCloner<ImplClass>::visitMarkDependenceInst(MarkDependenceInst *Inst) {
                 getOpLocation(Inst->getLoc()), getOpValue(Inst->getValue()),
                 getOpValue(Inst->getBase()),
                 getBuilder().hasOwnership()
-                    ? Inst->getForwardingOwnershipKind()
-                    : ValueOwnershipKind(OwnershipKind::None)));
+                ? Inst->getForwardingOwnershipKind()
+                : ValueOwnershipKind(OwnershipKind::None),
+                /*isNonEscaping*/false));
 }
 
 template<typename ImplClass>

include/swift/SIL/SILInstruction.h

@@ -8290,17 +8290,33 @@ class UncheckedOwnershipConversionInst
 /// result) have a dependence on "base" being alive. Do not allow for things
 /// that /may/ destroy base to be moved earlier than any of these uses of
 /// "value"'.
+///
+/// The dependent 'value' may be marked 'nonescaping', which guarantees that the
+/// lifetime dependence is statically enforceable. In this case, the compiler
+/// must be able to follow all values forwarded from the dependent 'value', and
+/// recognize all final (non-forwarded, non-escaping) use points. This implies
+/// that `findPointerEscape` is false. A diagnostic pass checks that the
+/// incoming SIL to verify that these use points are all initially within the
+/// 'base' lifetime. Regular 'mark_dependence' semantics ensure that
+/// optimizations cannot violate the lifetime dependence after diagnostics.
 class MarkDependenceInst
     : public InstructionBase<SILInstructionKind::MarkDependenceInst,
                              OwnershipForwardingSingleValueInstruction> {
   friend SILBuilder;
 
   FixedOperandList<2> Operands;
 
+  USE_SHARED_UINT8;
+
   MarkDependenceInst(SILDebugLocation DebugLoc, SILValue value, SILValue base,
-                     ValueOwnershipKind forwardingOwnershipKind)
+                     ValueOwnershipKind forwardingOwnershipKind,
+                     bool isNonEscaping)
       : InstructionBase(DebugLoc, value->getType(), forwardingOwnershipKind),
-        Operands{this, value, base} {}
+        Operands{this, value, base} {
+    if (isNonEscaping) {
+      sharedUInt8().MarkDependenceInst.nonEscaping = true;
+    }
+  }
 
 public:
   enum { Value, Base };
@@ -8318,6 +8334,10 @@ class MarkDependenceInst
 
   ArrayRef<Operand> getAllOperands() const { return Operands.asArray(); }
   MutableArrayRef<Operand> getAllOperands() { return Operands.asArray(); }
+
+  bool isNonEscaping() const {
+    return sharedUInt8().MarkDependenceInst.nonEscaping;
+  }
 };
 
 /// Promote an Objective-C block that is on the stack to the heap, or simply

include/swift/SIL/SILNode.h

@@ -276,6 +276,9 @@ class alignas(8) SILNode :
                  pointerEscape : 1,
                  fromVarDecl : 1);
 
+    SHARED_FIELD(MarkDependenceInst, uint8_t
+                 nonEscaping : 1);
+
   // Do not use `_sharedUInt8_private` outside of SILNode.
   } _sharedUInt8_private;
   // clang-format on

lib/IRGen/LoadableByAddress.cpp

@@ -2840,7 +2840,8 @@ bool LoadableByAddress::recreateConvInstr(SILInstruction &I,
   case SILInstructionKind::MarkDependenceInst: {
     auto instr = cast<MarkDependenceInst>(convInstr);
     newInstr = convBuilder.createMarkDependence(
-        instr->getLoc(), instr->getValue(), instr->getBase());
+      instr->getLoc(), instr->getValue(), instr->getBase(),
+      instr->isNonEscaping());
     break;
   }
   case SILInstructionKind::DifferentiableFunctionInst: {