SILGen: Generate closure contexts as guaranteed.

jckarter · jckarter · commit 5e206f35a163 · 2015-12-31T15:10:27.000-08:00
When enabled, generate closure functions with guaranteed conventions as their context parameters, and pass context arguments to them as guaranteed when possible. (When forming a closure by partial_apply, the partial apply still needs to take ownership of the parameters, regardless of their convention.)
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
@@ -420,7 +420,7 @@ enum class CaptureKind {
   /// A local value captured as a single pointer to storage (formed with
   /// @noescape closures).
   StorageAddress,
-  // A local value captures as a constant.
+  /// A local value captured as a constant.
   Constant,
 };
 
diff --git a/lib/IRGen/GenFunc.cpp b/lib/IRGen/GenFunc.cpp
@@ -1366,19 +1366,8 @@ void SignatureExpansion::expand(SILParameterInfo param) {
 
   case ParameterConvention::Direct_Owned:
   case ParameterConvention::Direct_Unowned:
-  case ParameterConvention::Direct_Guaranteed: /*
-    // Go ahead and further decompose tuples.
-    if (auto tuple = dyn_cast<TupleType>(param.getType())) {
-      for (auto elt : tuple.getElementTypes()) {
-        // Propagate the same ownedness down to the element.
-        expand(SILParameterInfo(elt, param.getConvention()));
-      }
-      return;
-    }
-    */
-    SWIFT_FALLTHROUGH;
+  case ParameterConvention::Direct_Guaranteed:
   case ParameterConvention::Direct_Deallocating:
-
     switch (FnType->getLanguage()) {
     case SILFunctionLanguage::C: {
       llvm_unreachable("Unexpected C/ObjC method in parameter expansion!");
diff --git a/lib/SIL/SILFunctionType.cpp b/lib/SIL/SILFunctionType.cpp
@@ -585,27 +585,30 @@ static CanSILFunctionType getSILFunctionType(SILModule &M,
         break;
       case CaptureKind::Constant: {
         // Constants are captured by value.
-        SILParameterInfo param;
+        ParameterConvention convention;
         if (loweredTL.isAddressOnly()) {
-          param = SILParameterInfo(loweredTy.getSwiftRValueType(),
-                                   ParameterConvention::Indirect_In);
-          
+          convention = M.getOptions().EnableGuaranteedClosureContexts
+            ? ParameterConvention::Indirect_In_Guaranteed
+            : ParameterConvention::Indirect_In;
         } else if (loweredTL.isTrivial()) {
-          param = SILParameterInfo(loweredTy.getSwiftRValueType(),
-                                   ParameterConvention::Direct_Unowned);
+          convention = ParameterConvention::Direct_Unowned;
         } else {
-          param = SILParameterInfo(loweredTy.getSwiftRValueType(),
-                                   ParameterConvention::Direct_Owned);
+          convention = M.getOptions().EnableGuaranteedClosureContexts
+            ? ParameterConvention::Direct_Guaranteed
+            : ParameterConvention::Direct_Owned;
         }
+        SILParameterInfo param(loweredTy.getSwiftRValueType(), convention);
         inputs.push_back(param);
         break;
       }
       case CaptureKind::Box: {
         // Lvalues are captured as a box that owns the captured value.
         SILType ty = loweredTy.getAddressType();
         CanType boxTy = SILBoxType::get(ty.getSwiftRValueType());
-        auto param = SILParameterInfo(boxTy,
-                                      ParameterConvention::Direct_Owned);
+        auto convention = M.getOptions().EnableGuaranteedClosureContexts
+          ? ParameterConvention::Direct_Guaranteed
+          : ParameterConvention::Direct_Owned;
+        auto param = SILParameterInfo(boxTy, convention);
         inputs.push_back(param);
         break;
       }
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -1168,7 +1168,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                && "generic local fns not implemented");
         
         SmallVector<ManagedValue, 4> captures;
-        SGF.emitCaptures(e, afd, captures);
+        SGF.emitCaptures(e, afd, CaptureEmission::ImmediateApplication,
+                         captures);
         ApplyCallee->setCaptures(std::move(captures));
       }
       
@@ -1214,7 +1215,8 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     // If the closure requires captures, emit them.
     if (e->getCaptureInfo().hasLocalCaptures()) {
       SmallVector<ManagedValue, 4> captures;
-      SGF.emitCaptures(e, e, captures);
+      SGF.emitCaptures(e, e, CaptureEmission::ImmediateApplication,
+                       captures);
       ApplyCallee->setCaptures(std::move(captures));
     }
     // If there are substitutions, add them, always at depth 0.
@@ -3840,7 +3842,8 @@ emitSpecializedAccessorFunctionRef(SILGenFunction &gen,
   if (accessorFn->getCaptureInfo().hasLocalCaptures()) {
     assert(!selfValue && "local property has self param?!");
     SmallVector<ManagedValue, 4> captures;
-    gen.emitCaptures(loc, accessorFn, captures);
+    gen.emitCaptures(loc, accessorFn, CaptureEmission::ImmediateApplication,
+                     captures);
     callee.setCaptures(std::move(captures));
   }
 
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
@@ -220,12 +220,28 @@ ManagedValue SILGenFunction::emitFunctionRef(SILLocation loc,
 
 void SILGenFunction::emitCaptures(SILLocation loc,
                                   AnyFunctionRef TheClosure,
+                                  CaptureEmission purpose,
                                   SmallVectorImpl<ManagedValue> &capturedArgs) {
   auto captureInfo = SGM.Types.getLoweredLocalCaptures(TheClosure);
   // For boxed captures, we need to mark the contained variables as having
   // escaped for DI diagnostics.
   SmallVector<SILValue, 2> escapesToMark;
   
+  // Partial applications take ownership of the context parameters, so we'll
+  // need to pass ownership rather than merely guaranteeing parameters.
+  bool canGuarantee;
+  switch (purpose) {
+  case CaptureEmission::PartialApplication:
+    canGuarantee = false;
+    break;
+  case CaptureEmission::ImmediateApplication:
+    canGuarantee = true;
+    break;
+  }
+  // TODO: Or we always retain them when guaranteed contexts aren't enabled.
+  if (!SGM.M.getOptions().EnableGuaranteedClosureContexts)
+    canGuarantee = false;
+  
   for (auto capture : captureInfo.getCaptures()) {
     auto *vd = capture.getDecl();
 
@@ -237,11 +253,18 @@ void SILGenFunction::emitCaptures(SILLocation loc,
       // let declarations.
       auto Entry = VarLocs[vd];
 
-      // Non-address-only constants are passed at +1.
       auto &tl = getTypeLowering(vd->getType()->getReferenceStorageReferent());
       SILValue Val = Entry.value;
 
       if (!Val.getType().isAddress()) {
+        // Our 'let' binding can guarantee the lifetime for the callee,
+        // if we don't need to do anything more to it.
+        if (canGuarantee && !vd->getType()->is<ReferenceStorageType>()) {
+          auto guaranteed = ManagedValue::forUnmanaged(Val);
+          capturedArgs.push_back(guaranteed);
+          break;
+        }
+      
         // Just retain a by-val let.
         B.emitRetainValueOperation(loc, Val);
       } else {
@@ -281,15 +304,25 @@ void SILGenFunction::emitCaptures(SILLocation loc,
 
       // If this is a boxed variable, we can use it directly.
       if (vl.box) {
-        B.createStrongRetain(loc, vl.box);
-        capturedArgs.push_back(emitManagedRValueWithCleanup(vl.box));
+        // We can guarantee our own box to the callee.
+        if (canGuarantee) {
+          capturedArgs.push_back(ManagedValue::forUnmanaged(vl.box));
+        } else {
+          B.createStrongRetain(loc, vl.box);
+          capturedArgs.push_back(emitManagedRValueWithCleanup(vl.box));
+        }
         escapesToMark.push_back(vl.value);
       } else {
         // Address only 'let' values are passed by box.  This isn't great, in
         // that a variable captured by multiple closures will be boxed for each
         // one.  This could be improved by doing an "isCaptured" analysis when
         // emitting address-only let constants, and emit them into an alloc_box
         // like a variable instead of into an alloc_stack.
+        //
+        // TODO: This might not be profitable anymore with guaranteed captures,
+        // since we could conceivably forward the copied value into the
+        // closure context and pass it down to the partially applied function
+        // in-place.
         AllocBoxInst *allocBox =
           B.createAllocBox(loc, vl.value.getType().getObjectType());
         auto boxAddress = SILValue(allocBox, 1);
@@ -348,10 +381,10 @@ SILGenFunction::emitClosureValue(SILLocation loc, SILDeclRef constant,
   }
 
   SmallVector<ManagedValue, 4> capturedArgs;
-  emitCaptures(loc, TheClosure, capturedArgs);
+  emitCaptures(loc, TheClosure, CaptureEmission::PartialApplication,
+               capturedArgs);
 
-  // Currently all capture arguments are captured at +1.
-  // TODO: Ideally this would be +0.
+  // The partial application takes ownership of the context parameters.
   SmallVector<SILValue, 4> forwardedArgs;
   for (auto capture : capturedArgs)
     forwardedArgs.push_back(capture.forward(*this));
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -257,6 +257,16 @@ class SILGenBuilder : public SILBuilder {
                                  ArrayRef<ProtocolConformance *> Conformances);
 };
 
+/// Parameter to \c SILGenFunction::emitCaptures that indicates what the
+/// capture parameters are being emitted for.
+enum class CaptureEmission {
+  /// Captures are being emitted for immediate application to a local function.
+  ImmediateApplication,
+  /// Captures are being emitted for partial application to form a closure
+  /// value.
+  PartialApplication,
+};
+
 /// SILGenFunction - an ASTVisitor for producing SIL from function bodies.
 class LLVM_LIBRARY_VISIBILITY SILGenFunction
   : public ASTVisitor<SILGenFunction>
@@ -1031,6 +1041,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   void emitCaptures(SILLocation loc,
                     AnyFunctionRef TheClosure,
+                    CaptureEmission purpose,
                     SmallVectorImpl<ManagedValue> &captures);
 
   ManagedValue emitClosureValue(SILLocation loc,
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -420,27 +420,6 @@ void SILGenFunction::bindParametersForForwarding(Pattern *pattern,
   ArgumentForwardVisitor(*this, parameters).visit(pattern);
 }
 
-/// Tuple values captured by a closure are passed as individual arguments to the
-/// SILFunction since SILFunctionType canonicalizes away tuple types.
-static SILValue
-emitReconstitutedConstantCaptureArguments(SILType ty,
-                                          ValueDecl *capture,
-                                          SILGenFunction &gen) {
-  auto TT = ty.getAs<TupleType>();
-  if (!TT)
-    return new (gen.SGM.M) SILArgument(gen.F.begin(), ty, capture);
-
-  SmallVector<SILValue, 4> Elts;
-  for (unsigned i = 0, e = TT->getNumElements(); i != e; ++i) {
-    auto EltTy = ty.getTupleElementType(i);
-    auto EV =
-      emitReconstitutedConstantCaptureArguments(EltTy, capture, gen);
-    Elts.push_back(EV);
-  }
-
-  return gen.B.createTuple(capture, ty, Elts);
-}
-
 static void emitCaptureArguments(SILGenFunction &gen, CapturedValue capture,
                                  unsigned ArgNo) {
   auto *VD = capture.getDecl();
@@ -472,7 +451,10 @@ static void emitCaptureArguments(SILGenFunction &gen, CapturedValue capture,
       AllocStack->setArgNo(ArgNo);
     else 
       gen.B.createDebugValue(Loc, val, {/*Constant*/true, ArgNo});
-    if (!lowering.isTrivial())
+
+    // TODO: Closure contexts should always be guaranteed.
+    if (!gen.SGM.M.getOptions().EnableGuaranteedClosureContexts
+        && !lowering.isTrivial())
       gen.enterDestroyCleanup(val);
     break;
   }
@@ -487,7 +469,8 @@ static void emitCaptureArguments(SILGenFunction &gen, CapturedValue capture,
     SILValue addr = gen.B.createProjectBox(VD, box);
     gen.VarLocs[VD] = SILGenFunction::VarLoc::get(addr, box);
     gen.B.createDebugValueAddr(Loc, addr, {/*Constant*/false, ArgNo});
-    gen.Cleanups.pushCleanup<StrongReleaseCleanup>(box);
+    if (!gen.SGM.M.getOptions().EnableGuaranteedClosureContexts)
+      gen.Cleanups.pushCleanup<StrongReleaseCleanup>(box);
     break;
   }
   case CaptureKind::StorageAddress: {
diff --git a/test/SILGen/guaranteed_closure_context.swift b/test/SILGen/guaranteed_closure_context.swift
@@ -0,0 +1,69 @@
+// RUN: %target-swift-frontend -parse-as-library -emit-silgen -enable-guaranteed-closure-contexts %s | FileCheck %s
+
+func use<T>(_: T) {}
+
+func escape(f: () -> ()) {}
+
+protocol P {}
+class C: P {}
+struct S {}
+
+// CHECK-LABEL: sil hidden @_TF26guaranteed_closure_context19guaranteed_capturesFT_T_
+func guaranteed_captures() {
+  // CHECK: [[MUTABLE_TRIVIAL_BOX:%.*]] = alloc_box $S
+  var mutableTrivial = S()
+  // CHECK: [[MUTABLE_RETAINABLE_BOX:%.*]] = alloc_box $C
+  var mutableRetainable = C()
+  // CHECK: [[MUTABLE_ADDRESS_ONLY_BOX:%.*]] = alloc_box $P
+  var mutableAddressOnly: P = C()
+
+  // CHECK: [[IMMUTABLE_TRIVIAL:%.*]] = apply {{.*}} -> S
+  let immutableTrivial = S()
+  // CHECK: [[IMMUTABLE_RETAINABLE:%.*]] = apply {{.*}} -> @owned C
+  let immutableRetainable = C()
+  // CHECK: [[IMMUTABLE_ADDRESS_ONLY:%.*]] = alloc_stack $P
+  let immutableAddressOnly: P = C()
+
+  func captureEverything() {
+    use((mutableTrivial, mutableRetainable, mutableAddressOnly,
+         immutableTrivial, immutableRetainable, immutableAddressOnly))
+  }
+
+  // CHECK-NOT: strong_retain [[MUTABLE_TRIVIAL_BOX]]
+  // CHECK-NOT: strong_retain [[MUTABLE_RETAINABLE_BOX]]
+  // CHECK-NOT: strong_retain [[MUTABLE_ADDRESS_ONLY_BOX]]
+  // CHECK-NOT: strong_retain [[IMMUTABLE_RETAINABLE]]
+  // CHECK:     [[IMMUTABLE_AO_BOX:%.*]] = alloc_box $P
+
+  // CHECK: [[FN:%.*]] = function_ref [[FN_NAME:@_TFF26guaranteed_closure_context19guaranteed_capturesFT_T_L_17captureEverythingfT_T_]]
+  // CHECK: apply [[FN]]([[MUTABLE_TRIVIAL_BOX]]#0, [[MUTABLE_RETAINABLE_BOX]]#0, [[MUTABLE_ADDRESS_ONLY_BOX]]#0, [[IMMUTABLE_TRIVIAL]], [[IMMUTABLE_RETAINABLE]], [[IMMUTABLE_AO_BOX]]#0)
+  captureEverything()
+
+  // CHECK: strong_release [[IMMUTABLE_AO_BOX]]
+
+  // CHECK-NOT: strong_retain [[MUTABLE_TRIVIAL_BOX]]
+  // CHECK-NOT: strong_retain [[MUTABLE_RETAINABLE_BOX]]
+  // CHECK-NOT: strong_retain [[MUTABLE_ADDRESS_ONLY_BOX]]
+  // CHECK-NOT: strong_retain [[IMMUTABLE_RETAINABLE]]
+
+  // -- partial_apply still takes ownership of its arguments.
+  // CHECK: [[FN:%.*]] = function_ref [[FN_NAME]]
+  // CHECK: strong_retain [[MUTABLE_TRIVIAL_BOX]]
+  // CHECK: strong_retain [[MUTABLE_RETAINABLE_BOX]]
+  // CHECK: strong_retain [[MUTABLE_ADDRESS_ONLY_BOX]]
+  // CHECK: strong_retain [[IMMUTABLE_RETAINABLE]]
+  // CHECK: [[IMMUTABLE_AO_BOX:%.*]] = alloc_box $P
+  // CHECK: [[CLOSURE:%.*]] = partial_apply {{.*}}([[MUTABLE_TRIVIAL_BOX]]#0, [[MUTABLE_RETAINABLE_BOX]]#0, [[MUTABLE_ADDRESS_ONLY_BOX]]#0, [[IMMUTABLE_TRIVIAL]], [[IMMUTABLE_RETAINABLE]], [[IMMUTABLE_AO_BOX]]#0)
+  // CHECK: apply {{.*}}[[CLOSURE]]
+
+  // CHECK-NOT: strong_retain [[MUTABLE_TRIVIAL_BOX]]
+  // CHECK-NOT: strong_retain [[MUTABLE_RETAINABLE_BOX]]
+  // CHECK-NOT: strong_retain [[MUTABLE_ADDRESS_ONLY_BOX]]
+  // CHECK-NOT: strong_retain [[IMMUTABLE_RETAINABLE]]
+  // CHECK-NOT: strong_release [[IMMUTABLE_AO_BOX]]
+
+  escape(captureEverything)
+
+}
+
+// CHECK: sil shared [[FN_NAME]] : $@convention(thin) (@guaranteed @box S, @guaranteed @box C, @guaranteed @box P, S, @guaranteed C, @guaranteed @box P)
