Add mark_dependence [nonescaping] flag.

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.

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: {

lib/SIL/IR/SILPrinter.cpp

@@ -2526,6 +2526,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     *this << getIDAndType(CBOI->getOperand());
   }
   void visitMarkDependenceInst(MarkDependenceInst *MDI) {
+    if (MDI->isNonEscaping()) {
+      *this << "[nonescaping] ";
+    }
     *this << getIDAndType(MDI->getValue()) << " on "
           << getIDAndType(MDI->getBase());
     printForwardingOwnershipKind(MDI, MDI->getValue());

lib/SIL/Parser/ParseSIL.cpp

@@ -3756,17 +3756,20 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   }
 
   case SILInstructionKind::MarkDependenceInst: {
+    bool nonEscaping = false;
     SILValue Base;
-    if (parseTypedValueRef(Val, B) || parseVerbatim("on") ||
-        parseTypedValueRef(Base, B))
+    if (parseSILOptional(nonEscaping, *this, "nonescaping")
+        || parseTypedValueRef(Val, B) || parseVerbatim("on")
+        || parseTypedValueRef(Base, B))
       return true;
 
     ValueOwnershipKind forwardingOwnership = Val->getOwnershipKind();
     if (parseForwardingOwnershipKind(forwardingOwnership)
         || parseSILDebugLocation(InstLoc, B))
       return true;
 
-    ResultVal = B.createMarkDependence(InstLoc, Val, Base, forwardingOwnership);
+    ResultVal = B.createMarkDependence(InstLoc, Val, Base, forwardingOwnership,
+                                       nonEscaping);
     break;
   }
 

lib/SILGen/SILGenApply.cpp

@@ -2908,7 +2908,7 @@ class DelayedArgument {
       if (valueTL.isTrivial()) {
         SILValue dependentValue =
           SGF.B.createMarkDependence(eval, value.forward(SGF),
-                                     owner.getValue());
+                                     owner.getValue(), /*isNonEscaping*/false);
         value = SGF.emitManagedRValueWithCleanup(dependentValue, valueTL);
       }
     }
@@ -6352,7 +6352,8 @@ SILGenFunction::emitUninitializedArrayAllocation(Type ArrayTy,
 
   // Add a mark_dependence between the interior pointer and the array value
   auto dependentValue = B.createMarkDependence(Loc, resultElts[1].getValue(),
-                                               resultElts[0].getValue());
+                                               resultElts[0].getValue(),
+                                               /*isNonEscaping*/false);
   return {resultElts[0], dependentValue};
 }
 

lib/SILGen/SILGenBuilder.cpp

@@ -1024,10 +1024,12 @@ ManagedValue SILGenBuilder::createProjectBox(SILLocation loc, ManagedValue mv,
 
 ManagedValue SILGenBuilder::createMarkDependence(SILLocation loc,
                                                  ManagedValue value,
-                                                 ManagedValue base) {
+                                                 ManagedValue base,
+                                                 bool isNonEscaping) {
   CleanupCloner cloner(*this, value);
   auto *mdi = createMarkDependence(loc, value.forward(getSILGenFunction()),
-                                   base.forward(getSILGenFunction()));
+                                   base.forward(getSILGenFunction()),
+                                   isNonEscaping);
   return cloner.clone(mdi);
 }
 

lib/SILGen/SILGenBuilder.h

@@ -461,7 +461,7 @@ class SILGenBuilder : public SILBuilder {
 
   using SILBuilder::createMarkDependence;
   ManagedValue createMarkDependence(SILLocation loc, ManagedValue value,
-                                    ManagedValue base);
+                                    ManagedValue base, bool isNonEscaping);
 
   using SILBuilder::createBeginBorrow;
   ManagedValue createBeginBorrow(SILLocation loc, ManagedValue value,

lib/SILGen/SILGenBuiltin.cpp

@@ -1442,7 +1442,8 @@ static ManagedValue emitBuiltinConvertUnownedUnsafeToGuaranteed(
   auto guaranteedNonTrivialRefMV =
       SGF.emitManagedBorrowedRValueWithCleanup(guaranteedNonTrivialRef);
   // Now create a mark dependence on our base and return the result.
-  return SGF.B.createMarkDependence(loc, guaranteedNonTrivialRefMV, baseMV);
+  return SGF.B.createMarkDependence(loc, guaranteedNonTrivialRefMV, baseMV,
+                                    /*isNonEscaping*/false);
 }
 
 // Emit SIL for the named builtin: getCurrentAsyncTask.

lib/SILGen/SILGenExpr.cpp

@@ -5876,7 +5876,8 @@ class AutoreleasingWritebackComponent : public LogicalPathComponent {
     // is important to ensure that the destroy of the assign is not hoisted
     // above the retain. We are doing unmanaged things here so we need to be
     // extra careful.
-    ownedMV = SGF.B.createMarkDependence(loc, ownedMV, base);
+    ownedMV = SGF.B.createMarkDependence(loc, ownedMV, base,
+                                         /*isNonEscaping*/false);
 
     // Then reassign the mark dependence into the +1 storage.
     ownedMV.assignInto(SGF, loc, base.getUnmanagedValue());
@@ -6191,7 +6192,8 @@ SILGenFunction::emitArrayToPointer(SILLocation loc, ManagedValue array,
   // Mark the dependence of the pointer on the owner value.
   auto owner = resultScalars[0];
   auto pointer = resultScalars[1].forward(*this);
-  pointer = B.createMarkDependence(loc, pointer, owner.getValue());
+  pointer = B.createMarkDependence(loc, pointer, owner.getValue(),
+                                   /*isNonEscaping*/false);
 
   // The owner's already in its own cleanup.  Return the pointer.
   return {ManagedValue::forObjectRValueWithoutOwnership(pointer), owner};
@@ -6226,7 +6228,8 @@ SILGenFunction::emitStringToPointer(SILLocation loc, ManagedValue stringValue,
   // Mark the dependence of the pointer on the owner value.
   auto owner = results[0];
   auto pointer = results[1].forward(*this);
-  pointer = B.createMarkDependence(loc, pointer, owner.getValue());
+  pointer = B.createMarkDependence(loc, pointer, owner.getValue(),
+                                   /*isNonEscaping*/false);
 
   return {ManagedValue::forObjectRValueWithoutOwnership(pointer), owner};
 }

lib/SILGen/SILGenPoly.cpp

@@ -5707,7 +5707,8 @@ SILGenFunction::createWithoutActuallyEscapingClosure(
   // long as we represent these captures by the same value the following works.
   thunkedFn = emitManagedRValueWithCleanup(
     B.createMarkDependence(loc, thunkedFn.forward(*this),
-                           noEscapingFunctionValue.getValue()));
+                           noEscapingFunctionValue.getValue(),
+                           /*isNonEscaping*/false));
 
   return thunkedFn;
 }

lib/SILOptimizer/IPO/ClosureSpecializer.cpp

@@ -783,7 +783,8 @@ SILValue ClosureSpecCloner::cloneCalleeConversion(
     return addToOldToNewClosureMap(
         origCalleeValue,
         Builder.createMarkDependence(CallSiteDesc.getLoc(), calleeValue,
-                                     CapturedMap[MD->getBase()]));
+                                     CapturedMap[MD->getBase()],
+                                     /*isNonEscaping*/false));
   }
 
 

lib/SILOptimizer/Mandatory/ClosureLifetimeFixup.cpp

@@ -277,7 +277,9 @@ static void extendLifetimeToEndOfFunction(SILFunction &fn,
   // Create a borrow scope and a mark_dependence to prevent the enum being
   // optimized away.
   auto *borrow = lifetimeExtendBuilder.createBeginBorrow(loc, optionalSome);
-  auto *mdi = lifetimeExtendBuilder.createMarkDependence(loc, cvt, borrow);
+  auto *mdi =
+    lifetimeExtendBuilder.createMarkDependence(loc, cvt, borrow,
+                                               /*isNonEscaping*/false);
 
   // Replace all uses of the non escaping closure with mark_dependence
   SmallVector<Operand *, 4> convertUses;
@@ -402,7 +404,8 @@ static SILValue insertMarkDependenceForCapturedArguments(PartialApplyInst *pai,
     if (auto *m = dyn_cast<MoveOnlyWrapperToCopyableValueInst>(arg.get()))
       if (m->hasGuaranteedInitialKind())
         continue;
-    curr = b.createMarkDependence(pai->getLoc(), curr, arg.get());
+    curr = b.createMarkDependence(pai->getLoc(), curr, arg.get(),
+                                  /*isNonEscaping*/false);
   }
 
   return curr;

lib/SILOptimizer/Mandatory/LowerHopToActor.cpp

@@ -228,7 +228,8 @@ SILValue LowerHopToActor::emitGetExecutor(SILBuilderWithScope &B,
 
   // Mark the dependence of the resulting value on the actor value to
   // force the actor to stay alive.
-  executor = B.createMarkDependence(loc, unmarkedExecutor, actor);
+  executor = B.createMarkDependence(loc, unmarkedExecutor, actor,
+                                    /*isNonEscaping*/false);
 
   // Cache the non-optional result for later.
   ExecutorForActor.insert(actor, executor);

lib/SILOptimizer/Mandatory/OwnershipModelEliminator.cpp

@@ -450,7 +450,8 @@ bool OwnershipModelEliminatorVisitor::visitPartialApplyInst(
       }
 
       // If this is a nontrivial value argument, insert the mark_dependence.
-      auto mdi = b.createMarkDependence(loc, newValue, op);
+      auto mdi = b.createMarkDependence(loc, newValue, op,
+                                        /*isNonEscaping*/false);
       if (!firstNewMDI)
         firstNewMDI = mdi;
       newValue = mdi;