Merge pull request #15046 from aschwaighofer/without_actually_escaping_verification

Implement withoutActuallyEscaping verification

Author: aschwaighofer

docs/SIL.rst

@@ -2855,6 +2855,19 @@ memory object or a reference to a pinned object. Returns 1 if the
 strong reference count is 1 or the object has been marked pinned by
 strong_pin.
 
+is_escaping_closure
+```````````````````
+
+::
+  sil-instruction ::= 'is_escaping_closure' sil-operand
+
+  %1 = is_escaping_closure %0 : $@callee_guaranteed () -> ()
+  // %0 must be an escaping swift closure.
+  // %1 will be of type Builtin.Int1
+
+Checks whether the context reference is not nil and bigger than one and returns
+true if it is.
+
 copy_block
 ``````````
 ::

include/swift/Runtime/Debug.h

@@ -18,6 +18,8 @@
 #define _SWIFT_RUNTIME_DEBUG_HELPERS_
 
 #include <llvm/Support/Compiler.h>
+#include <cstdarg>
+#include <cstdio>
 #include <stdint.h>
 #include "swift/Runtime/Config.h"
 #include "swift/Runtime/Unreachable.h"
@@ -222,6 +224,39 @@ void _swift_reportToDebugger(uintptr_t flags, const char *message,
 SWIFT_RUNTIME_STDLIB_SPI
 bool _swift_reportFatalErrorsToDebugger;
 
+LLVM_ATTRIBUTE_ALWAYS_INLINE
+inline static int swift_asprintf(char **strp, const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+#if defined(_WIN32)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuninitialized"
+  int len = _vscprintf(fmt, args);
+#pragma GCC diagnostic pop
+  if (len < 0) {
+    va_end(args);
+    return -1;
+  }
+  char *buffer = static_cast<char *>(malloc(len + 1));
+  if (!buffer) {
+    va_end(args);
+    return -1;
+  }
+  int result = vsprintf(buffer, fmt, args);
+  if (result < 0) {
+    va_end(args);
+    free(buffer);
+    return -1;
+  }
+  *strp = buffer;
+#else
+  int result = vasprintf(strp, fmt, args);
+#endif
+  va_end(args);
+  return result;
+}
+
+
 // namespace swift
 }
 

include/swift/Runtime/HeapObject.h

@@ -280,6 +280,16 @@ SWIFT_RUNTIME_EXPORT
 bool swift_isUniquelyReferencedOrPinned_nonNull_native(
   const struct HeapObject *);
 
+/// Is this native Swift pointer non-null and has a reference count greater than
+/// one.
+/// This runtime call will print an error message with file name and location if
+/// the closure is escaping but it will not abort.
+SWIFT_RUNTIME_EXPORT
+bool swift_isEscapingClosureAtFileLocation(const struct HeapObject *object,
+                                           const unsigned char *filename,
+                                           int32_t filenameLength,
+                                           int32_t line);
+
 /// Deallocate the given memory.
 ///
 /// It must have been returned by swift_allocObject and the strong reference

include/swift/Runtime/RuntimeFunctions.def

@@ -677,6 +677,16 @@ FUNCTION(IsUniquelyReferencedOrPinned_nonNull_native,
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind, ZExt))
 
+// bool swift_isEscapingClosureAtFileLocation(const struct HeapObject *object,
+//                                            const unsigned char *filename,
+//                                            int32_t filenameLength,
+//                                            int32_t line);
+FUNCTION(IsEscapingClosureAtFileLocation, swift_isEscapingClosureAtFileLocation,
+         C_CC,
+         RETURNS(Int1Ty),
+         ARGS(RefCountedPtrTy, Int8PtrTy, Int32Ty, Int32Ty),
+         ATTRS(NoUnwind, ZExt))
+
 // void swift_arrayInitWithCopy(opaque*, opaque*, size_t, type*);
 FUNCTION(ArrayInitWithCopy, swift_arrayInitWithCopy, C_CC,
          RETURNS(VoidTy),

include/swift/SIL/SILBuilder.h

@@ -1538,6 +1538,12 @@ class SILBuilder {
     return insert(new (getModule()) IsUniqueOrPinnedInst(
         getSILDebugLocation(Loc), value, Int1Ty));
   }
+  IsEscapingClosureInst *createIsEscapingClosure(SILLocation Loc,
+                                                 SILValue operand) {
+    auto Int1Ty = SILType::getBuiltinIntegerType(1, getASTContext());
+    return insert(new (getModule()) IsEscapingClosureInst(
+        getSILDebugLocation(Loc), operand, Int1Ty));
+  }
 
   DeallocStackInst *createDeallocStack(SILLocation Loc, SILValue operand) {
     return insert(new (getModule())
@@ -1615,7 +1621,14 @@ class SILBuilder {
   // Runtime failure
   //===--------------------------------------------------------------------===//
 
-  CondFailInst *createCondFail(SILLocation Loc, SILValue Operand) {
+  CondFailInst *createCondFail(SILLocation Loc, SILValue Operand,
+                               bool Inverted = false) {
+    if (Inverted) {
+      SILType Ty = Operand->getType();
+      SILValue True(createIntegerLiteral(Loc, Ty, 1));
+      Operand =
+          createBuiltinBinaryFunction(Loc, "xor", Ty, Ty, {Operand, True});
+    }
     return insert(new (getModule())
                       CondFailInst(getSILDebugLocation(Loc), Operand));
   }

include/swift/SIL/SILCloner.h

@@ -2013,6 +2013,14 @@ visitIsUniqueOrPinnedInst(IsUniqueOrPinnedInst *Inst) {
     getBuilder().createIsUniqueOrPinned(getOpLocation(Inst->getLoc()),
                                         getOpValue(Inst->getOperand())));
 }
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitIsEscapingClosureInst(
+    IsEscapingClosureInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(
+      Inst, getBuilder().createIsEscapingClosure(
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getOperand())));
+}
 
 template<typename ImplClass>
 void

include/swift/SIL/SILInstruction.h

@@ -6194,6 +6194,18 @@ class IsUniqueOrPinnedInst
       : UnaryInstructionBase(DebugLoc, Operand, BoolTy) {}
 };
 
+/// Given an escaping closure return true iff it has a non-nil context and the
+/// context has a strong reference count greater than 1.
+class IsEscapingClosureInst
+    : public UnaryInstructionBase<SILInstructionKind::IsEscapingClosureInst,
+                                  SingleValueInstruction> {
+  friend SILBuilder;
+
+  IsEscapingClosureInst(SILDebugLocation DebugLoc, SILValue Operand,
+                        SILType BoolTy)
+      : UnaryInstructionBase(DebugLoc, Operand, BoolTy) {}
+};
+
 //===----------------------------------------------------------------------===//
 // DeallocationInsts
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILNodes.def

@@ -379,6 +379,9 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   SINGLE_VALUE_INST(IsUniqueOrPinnedInst, is_unique_or_pinned,
                     SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
 
+  SINGLE_VALUE_INST(IsEscapingClosureInst, is_escaping_closure,
+                    SingleValueInstruction, MayRead, DoesNotRelease)
+
   // Accessing memory
   SINGLE_VALUE_INST(LoadInst, load,
                     SingleValueInstruction, MayRead, DoesNotRelease)

lib/IRGen/GenHeap.cpp

@@ -24,6 +24,7 @@
 
 #include "swift/Basic/SourceLoc.h"
 #include "swift/ABI/MetadataValues.h"
+#include "swift/AST/ASTContext.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/IRGenOptions.h"
 
@@ -1430,6 +1431,20 @@ emitIsUniqueCall(llvm::Value *value, SourceLoc loc, bool isNonNull,
   return call;
 }
 
+llvm::Value *IRGenFunction::emitIsEscapingClosureCall(llvm::Value *value,
+                                                      SourceLoc sourceLoc) {
+  auto loc = SILLocation::decode(sourceLoc, IGM.Context.SourceMgr);
+  auto line = llvm::ConstantInt::get(IGM.Int32Ty, loc.Line);
+  auto filename = IGM.getAddrOfGlobalString(loc.Filename);
+  auto filenameLength =
+      llvm::ConstantInt::get(IGM.Int32Ty, loc.Filename.size());
+  llvm::CallInst *call =
+      Builder.CreateCall(IGM.getIsEscapingClosureAtFileLocationFn(),
+                         {value, filename, filenameLength, line});
+  call->setDoesNotThrow();
+  return call;
+}
+
 namespace {
 /// Basic layout and common operations for box types.
 class BoxTypeInfo : public HeapTypeInfo<BoxTypeInfo> {

lib/IRGen/IRGenFunction.h

@@ -435,6 +435,8 @@ class IRGenFunction {
   llvm::Value *emitIsUniqueCall(llvm::Value *value, SourceLoc loc,
                                 bool isNonNull, bool checkPinned);
 
+  llvm::Value *emitIsEscapingClosureCall(llvm::Value *value, SourceLoc loc);
+
 //--- Expression emission ------------------------------------------------------
 public:
   void emitFakeExplosion(const TypeInfo &type, Explosion &explosion);

lib/IRGen/IRGenSIL.cpp

@@ -1027,6 +1027,7 @@ class IRGenSILFunction :
   void visitStoreUnownedInst(StoreUnownedInst *i);
   void visitIsUniqueInst(IsUniqueInst *i);
   void visitIsUniqueOrPinnedInst(IsUniqueOrPinnedInst *i);
+  void visitIsEscapingClosureInst(IsEscapingClosureInst *i);
   void visitDeallocStackInst(DeallocStackInst *i);
   void visitDeallocBoxInst(DeallocBoxInst *i);
   void visitDeallocRefInst(DeallocRefInst *i);
@@ -3883,6 +3884,27 @@ visitIsUniqueOrPinnedInst(swift::IsUniqueOrPinnedInst *i) {
   setLoweredExplosion(i, out);
 }
 
+void IRGenSILFunction::visitIsEscapingClosureInst(
+    swift::IsEscapingClosureInst *i) {
+  assert(i->getOperand()->getType().is<SILFunctionType>() &&
+         i->getOperand()
+             ->getType()
+             .getAs<SILFunctionType>()
+             ->getExtInfo()
+             .hasContext() &&
+         "Must have a closure operand");
+
+  Explosion closure = getLoweredExplosion(i->getOperand());
+  auto func = closure.claimNext();
+  (void)func;
+  auto context = closure.claimNext();
+
+  auto result = emitIsEscapingClosureCall(context, i->getLoc().getSourceLoc());
+  Explosion out;
+  out.add(result);
+  setLoweredExplosion(i, out);
+}
+
 void IRGenSILFunction::emitDebugInfoForAllocStack(AllocStackInst *i,
                                                   const TypeInfo &type,
                                                   llvm::Value *addr) {

lib/ParseSIL/ParseSIL.cpp

@@ -2655,6 +2655,7 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     UNARY_INSTRUCTION(CopyBlock)
     UNARY_INSTRUCTION(IsUnique)
     UNARY_INSTRUCTION(IsUniqueOrPinned)
+    UNARY_INSTRUCTION(IsEscapingClosure)
     UNARY_INSTRUCTION(DestroyAddr)
     UNARY_INSTRUCTION(CopyValue)
     UNARY_INSTRUCTION(CopyUnownedValue)

lib/SIL/InstructionUtils.cpp

@@ -753,6 +753,7 @@ void swift::visitAccessedAddress(SILInstruction *I,
   case SILInstructionKind::FixLifetimeInst:
   case SILInstructionKind::InitExistentialValueInst:
   case SILInstructionKind::IsUniqueInst:
+  case SILInstructionKind::IsEscapingClosureInst:
   case SILInstructionKind::IsUniqueOrPinnedInst:
   case SILInstructionKind::KeyPathInst:
   case SILInstructionKind::OpenExistentialBoxInst:

lib/SIL/SILInstruction.cpp

@@ -1068,6 +1068,7 @@ bool SILInstruction::mayRelease() const {
 bool SILInstruction::mayReleaseOrReadRefCount() const {
   switch (getKind()) {
   case SILInstructionKind::IsUniqueInst:
+  case SILInstructionKind::IsEscapingClosureInst:
   case SILInstructionKind::IsUniqueOrPinnedInst:
     return true;
   default:

lib/SIL/SILOwnershipVerifier.cpp

@@ -450,6 +450,7 @@ NO_OPERAND_INST(Unwind)
     return {compatibleWithOwnership(ValueOwnershipKind::OWNERSHIP),            \
             UseLifetimeConstraint::USE_LIFETIME_CONSTRAINT};                   \
   }
+CONSTANT_OWNERSHIP_INST(Guaranteed, MustBeLive, IsEscapingClosure)
 CONSTANT_OWNERSHIP_INST(Guaranteed, MustBeLive, RefElementAddr)
 CONSTANT_OWNERSHIP_INST(Guaranteed, MustBeLive, OpenExistentialValue)
 CONSTANT_OWNERSHIP_INST(Guaranteed, MustBeLive, OpenExistentialBoxValue)

lib/SIL/SILPrinter.cpp

@@ -1795,6 +1795,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   void visitIsUniqueOrPinnedInst(IsUniqueOrPinnedInst *CUI) {
     *this << getIDAndType(CUI->getOperand());
   }
+  void visitIsEscapingClosureInst(IsEscapingClosureInst *CUI) {
+    *this << getIDAndType(CUI->getOperand());
+  }
   void visitDeallocStackInst(DeallocStackInst *DI) {
     *this << getIDAndType(DI->getOperand());
   }

lib/SIL/SILVerifier.cpp

@@ -4082,6 +4082,16 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "final component should match leaf value type of key path type");
   }
 
+  void checkIsEscapingClosureInst(IsEscapingClosureInst *IEC) {
+    auto fnType = IEC->getOperand()->getType().getAs<SILFunctionType>();
+    require(fnType && fnType->getExtInfo().hasContext() &&
+                !fnType->isNoEscape() &&
+                fnType->getExtInfo().getRepresentation() ==
+                    SILFunctionTypeRepresentation::Thick,
+            "is_escaping_closure must have a thick "
+            "function operand");
+  }
+
   // This verifies that the entry block of a SIL function doesn't have
   // any predecessors and also verifies the entry point arguments.
   void verifyEntryBlock(SILBasicBlock *entry) {

lib/SIL/ValueOwnershipKindClassifier.cpp

@@ -75,6 +75,7 @@ CONSTANT_OWNERSHIP_INST(Trivial, InitExistentialMetatype)
 CONSTANT_OWNERSHIP_INST(Trivial, IntegerLiteral)
 CONSTANT_OWNERSHIP_INST(Trivial, IsUnique)
 CONSTANT_OWNERSHIP_INST(Trivial, IsUniqueOrPinned)
+CONSTANT_OWNERSHIP_INST(Trivial, IsEscapingClosure)
 CONSTANT_OWNERSHIP_INST(Trivial, MarkUninitializedBehavior)
 CONSTANT_OWNERSHIP_INST(Trivial, Metatype)
 CONSTANT_OWNERSHIP_INST(Trivial, ObjCToThickMetatype)

lib/SILGen/SILGenExpr.cpp

@@ -5332,29 +5332,41 @@ RValue RValueEmitter::visitOpenExistentialExpr(OpenExistentialExpr *E,
 }
 
 RValue RValueEmitter::visitMakeTemporarilyEscapableExpr(
-    MakeTemporarilyEscapableExpr *E,
-    SGFContext C) {
+    MakeTemporarilyEscapableExpr *E, SGFContext C) {
   // Emit the non-escaping function value.
   auto functionValue =
     visit(E->getNonescapingClosureValue()).getAsSingleValue(SGF, E);
 
   auto escapingFnTy = SGF.getLoweredType(E->getOpaqueValue()->getType());
 
   // Convert it to an escaping function value.
-  functionValue =
+  auto escapingClosure =
       SGF.createWithoutActuallyEscapingClosure(E, functionValue, escapingFnTy);
 
-  // Bind the opaque value to the escaping function.
-  SILGenFunction::OpaqueValueState opaqueValue{
-    functionValue,
-    /*consumable*/ true,
-    /*hasBeenConsumed*/ false,
-  };
-  SILGenFunction::OpaqueValueRAII pushOpaqueValue(SGF, E->getOpaqueValue(),
-                                                  opaqueValue);
+  RValue rvalue;
+  auto loc = SILLocation(E);
+  auto borrowedClosure = escapingClosure.borrow(SGF, loc);
+  {
+    // Bind the opaque value to the escaping function.
+    SILGenFunction::OpaqueValueState opaqueValue{
+        borrowedClosure,
+        /*consumable*/ false,
+        /*hasBeenConsumed*/ false,
+    };
+    SILGenFunction::OpaqueValueRAII pushOpaqueValue(SGF, E->getOpaqueValue(),
+                                                    opaqueValue);
 
-  // Emit the guarded expression.
-  return visit(E->getSubExpr(), C);
+    // Emit the guarded expression.
+    rvalue = visit(E->getSubExpr(), C);
+  }
+
+  // Now create the verification of the withoutActuallyEscaping operand.
+  // Either we fail the uniquenes check (which means the closure has escaped)
+  // and abort or we continue and destroy the ultimate reference.
+  auto isEscaping =
+      SGF.B.createIsEscapingClosure(loc, borrowedClosure.getValue());
+  SGF.B.createCondFail(loc, isEscaping);
+  return rvalue;
 }
 
 RValue RValueEmitter::visitOpaqueValueExpr(OpaqueValueExpr *E, SGFContext C) {

lib/SILGen/SILGenPoly.cpp

@@ -82,6 +82,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "SILGen.h"
+#include "SILGenFunction.h"
 #include "Scope.h"
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/Decl.h"
@@ -3075,7 +3076,8 @@ static void buildWithoutActuallyEscapingThunkBody(SILGenFunction &SGF) {
   SGF.B.createReturn(loc, result);
 }
 
-ManagedValue SILGenFunction::createWithoutActuallyEscapingClosure(
+ManagedValue
+SILGenFunction::createWithoutActuallyEscapingClosure(
     SILLocation loc, ManagedValue noEscapingFunctionValue, SILType escapingTy) {
 
   auto escapingFnTy = escapingTy.castTo<SILFunctionType>();
@@ -3117,7 +3119,6 @@ ManagedValue SILGenFunction::createWithoutActuallyEscapingClosure(
       loc, thunkValue, SILType::getPrimitiveObjectType(substFnType), subs,
       noEscapeValue,
       SILType::getPrimitiveObjectType(escapingFnTy));
-
   // We need to ensure the 'lifetime' of the trivial values context captures. As
   // long as we rerpresent these captures by the same value the following works.
   thunkedFn = B.createMarkDependence(loc, thunkedFn, noEscapeValue);