SIL: Add an is_escaping_closure instruction

Will be used to verify that withoutActuallyEscaping's block does not
escape the closure.

``%escaping = is_escaping_closure %closure`` tests the reference count. If the
closure is not uniquely referenced it prints out and error message and
returns true. Otherwise, it returns false. The returned result can be
used with a ``cond_fail %escaping`` instruction to abort the program.

rdar://35525730

Author: aschwaighofer

docs/SIL.rst

@@ -2848,6 +2848,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/HeapObject.h

@@ -280,6 +280,23 @@ 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 if the closure is escaping but
+/// it will not abort.
+SWIFT_RUNTIME_EXPORT
+bool swift_isEscapingClosure(const struct HeapObject *object);
+
+/// 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,23 @@ FUNCTION(IsUniquelyReferencedOrPinned_nonNull_native,
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind, ZExt))
 
+// bool swift_isEscapingClosure(const struct HeapObject *object);
+FUNCTION(IsEscapingClosure, swift_isEscapingClosure,
+         C_CC,
+         RETURNS(Int1Ty),
+         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())

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

@@ -6197,6 +6197,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) {