Merge pull request #34415 from gottesmm/pr-7013fe1c78c3e6068b82f7095479d50054110652

gottesmm · web-flow · commit 40ce7f6e24be · 2020-10-23T21:51:54.000-07:00
[ownership] Change thin_to_thick function to always produce a none value
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -4787,13 +4787,14 @@ class Name##ToRefInst \
 class ThinToThickFunctionInst final
     : public UnaryInstructionWithTypeDependentOperandsBase<
           SILInstructionKind::ThinToThickFunctionInst, ThinToThickFunctionInst,
-          ConversionInst> {
+          OwnershipForwardingConversionInst> {
   friend SILBuilder;
 
   ThinToThickFunctionInst(SILDebugLocation DebugLoc, SILValue Operand,
                           ArrayRef<SILValue> TypeDependentOperands, SILType Ty)
       : UnaryInstructionWithTypeDependentOperandsBase(
-            DebugLoc, Operand, TypeDependentOperands, Ty) {}
+            DebugLoc, Operand, TypeDependentOperands, Ty,
+            Operand.getOwnershipKind()) {}
 
   static ThinToThickFunctionInst *
   create(SILDebugLocation DebugLoc, SILValue Operand, SILType Ty,
diff --git a/lib/SIL/IR/ValueOwnership.cpp b/lib/SIL/IR/ValueOwnership.cpp
@@ -150,6 +150,7 @@ CONSTANT_OWNERSHIP_INST(Unowned, ObjCProtocol)
 CONSTANT_OWNERSHIP_INST(Unowned, ValueToBridgeObject)
 CONSTANT_OWNERSHIP_INST(None, GetAsyncContinuation)
 CONSTANT_OWNERSHIP_INST(Unowned, GetAsyncContinuationAddr)
+CONSTANT_OWNERSHIP_INST(None, ThinToThickFunction)
 #undef CONSTANT_OWNERSHIP_INST
 
 #define CONSTANT_OR_NONE_OWNERSHIP_INST(OWNERSHIP, INST)                       \
@@ -206,9 +207,6 @@ CONSTANT_OR_NONE_OWNERSHIP_INST(Owned, MarkUninitialized)
 // a performance perspective.
 CONSTANT_OR_NONE_OWNERSHIP_INST(Unowned, UncheckedBitwiseCast)
 
-// A thin_to_thick instruction can return a trivial (@noescape) type.
-CONSTANT_OR_NONE_OWNERSHIP_INST(Owned, ThinToThickFunction)
-
 #undef CONSTANT_OR_NONE_OWNERSHIP_INST
 
 // For a forwarding instruction, we loop over all operands and make sure that
diff --git a/lib/SILOptimizer/Mandatory/Differentiation.cpp b/lib/SILOptimizer/Mandatory/Differentiation.cpp
@@ -323,7 +323,9 @@ static void copyParameterArgumentsForApply(
     // Copy the argument if it's to be owned by the newly created closure.
     // Objects are to be retained.
     if (arg->getType().isObject()) {
-      auto newArg = copyBuilder.emitCopyValueOperation(loc, arg);
+      auto newArg = arg;
+      if (newArg.getOwnershipKind() != ValueOwnershipKind::None)
+        newArg = copyBuilder.emitCopyValueOperation(loc, arg);
       collectNewArg(newArg);
       continue;
     }
@@ -498,8 +500,9 @@ emitDerivativeFunctionReference(
           builder.emitBeginBorrowOperation(original.getLoc(), original);
       SILValue derivativeFn = builder.createDifferentiableFunctionExtract(
           borrowedDiffFunc.getLoc(), kind, borrowedDiffFunc);
-      derivativeFn =
-          builder.emitCopyValueOperation(original.getLoc(), derivativeFn);
+      if (derivativeFn.getOwnershipKind() != ValueOwnershipKind::None)
+        derivativeFn =
+            builder.emitCopyValueOperation(original.getLoc(), derivativeFn);
       builder.emitEndBorrowOperation(original.getLoc(), borrowedDiffFunc);
       return std::make_pair(derivativeFn, desiredIndices);
     }
@@ -1208,9 +1211,11 @@ SILValue DifferentiationTransformer::promoteToDifferentiableFunction(
   for (auto *buf : llvm::reverse(newBuffersToDealloc))
     builder.createDeallocStack(loc, buf);
 
-  auto origFnCopy = builder.emitCopyValueOperation(loc, origFnOperand);
+  // If our original copy does not have none ownership, copy it.
+  if (origFnOperand.getOwnershipKind() != ValueOwnershipKind::None)
+    origFnOperand = builder.emitCopyValueOperation(loc, origFnOperand);
   auto *newDiffFn = context.createDifferentiableFunction(
-      builder, loc, parameterIndices, resultIndices, origFnCopy,
+      builder, loc, parameterIndices, resultIndices, origFnOperand,
       std::make_pair(derivativeFns[0], derivativeFns[1]));
   context.getDifferentiableFunctionInstWorklist().push_back(dfi);
   return newDiffFn;
@@ -1223,7 +1228,8 @@ SILValue DifferentiationTransformer::promoteToLinearFunction(
   // with an undef transpose function operand. Eventually, a legitimate
   // transpose function operand should be created and used.
   auto origFnOperand = lfi->getOriginalFunction();
-  auto origFnCopy = builder.emitCopyValueOperation(loc, origFnOperand);
+  if (origFnOperand.getOwnershipKind() != ValueOwnershipKind::None)
+    origFnOperand = builder.emitCopyValueOperation(loc, origFnOperand);
   auto *parameterIndices = lfi->getParameterIndices();
   auto originalType = origFnOperand->getType().castTo<SILFunctionType>();
   auto transposeFnType = originalType->getAutoDiffTransposeFunctionType(
@@ -1232,7 +1238,7 @@ SILValue DifferentiationTransformer::promoteToLinearFunction(
   auto transposeType = SILType::getPrimitiveObjectType(transposeFnType);
   auto transposeFn = SILUndef::get(transposeType, builder.getFunction());
   auto *newLinearFn = context.createLinearFunction(
-      builder, loc, parameterIndices, origFnCopy, SILValue(transposeFn));
+      builder, loc, parameterIndices, origFnOperand, SILValue(transposeFn));
   context.getLinearFunctionInstWorklist().push_back(lfi);
   return newLinearFn;
 }
diff --git a/test/AutoDiff/SILGen/autodiff_builtins.swift b/test/AutoDiff/SILGen/autodiff_builtins.swift
@@ -98,14 +98,15 @@ func applyTranspose_f_direct_arity1(_ x: Float) -> Float {
 // CHECK:   [[NOESC_LINEAR:%.*]] = convert_escape_to_noescape [not_guaranteed] [[LINEAR]] : $@differentiable(linear) @callee_guaranteed (Float) -> Float to $@differentiable(linear) @noescape @callee_guaranteed (Float) -> Float
 // CHECK:   [[TRANS:%.*]] = linear_function_extract [transpose] [[NOESC_LINEAR]] : $@differentiable(linear) @noescape @callee_guaranteed (Float) -> Float
 // CHECK:   [[RESULT:%.*]] = apply [[TRANS]]([[X]]) : $@noescape @callee_guaranteed (Float) -> Float
-// CHECK:   destroy_value [[LINEAR]] : $@differentiable(linear) @callee_guaranteed (Float) -> Float
 // CHECK:   return [[RESULT]] : $Float
+// CHECK: } // end sil function 'applyTranspose_f_direct_arity1'
 
 @_silgen_name("applyTranspose_f_direct_arity2")
 func applyTranspose_f_direct_arity2(_ x: Float) -> (Float, Float) {
   return Builtin.applyTranspose_arity2(f_direct_arity2, x)
 }
-// CHECK-LABEL: sil{{.*}}@applyTranspose_f_direct_arity2
+
+// CHECK-LABEL: sil{{.*}}@applyTranspose_f_direct_arity2 :
 // CHECK: bb0([[X:%.*]] : $Float)
 // CHECK:   [[ORIG:%.*]] = function_ref @f_direct_arity2 : $@convention(thin) (Float, Float) -> Float
 // CHECK:   [[THICK_ORIG:%.*]] = thin_to_thick_function [[ORIG]] : $@convention(thin) (Float, Float) -> Float to $@callee_guaranteed (Float, Float) -> Float
@@ -114,9 +115,9 @@ func applyTranspose_f_direct_arity2(_ x: Float) -> (Float, Float) {
 // CHECK:   [[TRANS:%.*]] = linear_function_extract [transpose] [[NOESC_LINEAR]] : $@differentiable(linear) @noescape @callee_guaranteed (Float, Float) -> Float
 // CHECK:   [[RESULT:%.*]] = apply [[TRANS]]([[X]]) : $@noescape @callee_guaranteed (Float) -> (Float, Float)
 // CHECK:   ([[RES1:%.*]], [[RES2:%.*]]) = destructure_tuple [[RESULT]] : $(Float, Float)
-// CHECK:   destroy_value [[LINEAR]] : $@differentiable(linear) @callee_guaranteed (Float, Float) -> Float
 // CHECK:   [[RESULT:%.*]] = tuple ([[RES1]] : $Float, [[RES2]] : $Float)
 // CHECK:   return [[RESULT]] : $(Float, Float)
+// CHECK: } // end sil function 'applyTranspose_f_direct_arity2'
 
 @_silgen_name("applyTranspose_f_indirect_arity1")
 func applyTranspose_f_indirect_arity1<T: AdditiveArithmetic & Differentiable>(_ x: T) -> T {
diff --git a/test/AutoDiff/SILGen/reabstraction.swift b/test/AutoDiff/SILGen/reabstraction.swift
@@ -21,18 +21,17 @@ func makeSignatureAbstract() {
 
 // CHECK-LABEL: sil{{.*}}@makeSignatureAbstract
 // CHECK:   [[BEFORE:%.*]] = differentiable_function [parameters 0] [results 0]
-// CHECK:   [[BEFORE_BORROWED:%.*]] = begin_borrow [[BEFORE]]
-// CHECK:   [[ORIG_0:%.*]] = differentiable_function_extract [original] [[BEFORE_BORROWED]]
+// CHECK:   [[ORIG_0:%.*]] = differentiable_function_extract [original] [[BEFORE]]
 // CHECK:   [[ORIG_1:%.*]] = copy_value [[ORIG_0]]
 // CHECK:   [[ORIG_THUNK:%.*]] = function_ref {{.*}} : $@convention(thin) (@in_guaranteed Float, @guaranteed @callee_guaranteed (Float) -> Float) -> @out Float
 // CHECK:   [[ORIG_2:%.*]] = partial_apply [callee_guaranteed] [[ORIG_THUNK]]([[ORIG_1]])
 // CHECK:   [[ORIG_3:%.*]] = convert_function [[ORIG_2]]
-// CHECK:   [[JVP_0:%.*]] = differentiable_function_extract [jvp] [[BEFORE_BORROWED]]
+// CHECK:   [[JVP_0:%.*]] = differentiable_function_extract [jvp] [[BEFORE]]
 // CHECK:   [[JVP_1:%.*]] = copy_value [[JVP_0]]
 // CHECK:   [[JVP_THUNK:%.*]] = function_ref {{.*}} : $@convention(thin) (@in_guaranteed Float, @guaranteed @callee_guaranteed (Float) -> (Float, @owned @callee_guaranteed (Float) -> Float)) -> (@out Float, @owned @callee_guaranteed @substituted <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0) -> @out τ_0_1 for <Float, Float>)
 // CHECK:   [[JVP_2:%.*]] = partial_apply [callee_guaranteed] [[JVP_THUNK]]([[JVP_1]])
 // CHECK:   [[JVP_3:%.*]] = convert_function [[JVP_2]]
-// CHECK:   [[VJP_0:%.*]] = differentiable_function_extract [vjp] [[BEFORE_BORROWED]]
+// CHECK:   [[VJP_0:%.*]] = differentiable_function_extract [vjp] [[BEFORE]]
 // CHECK:   [[VJP_1:%.*]] = copy_value [[VJP_0]]
 // CHECK:   [[VJP_THUNK:%.*]] = function_ref {{.*}} : $@convention(thin) (@in_guaranteed Float, @guaranteed @callee_guaranteed (Float) -> (Float, @owned @callee_guaranteed (Float) -> Float)) -> (@out Float, @owned @callee_guaranteed @substituted <τ_0_0, τ_0_1> (@in_guaranteed τ_0_0) -> @out τ_0_1 for <Float, Float>)
 // CHECK:   [[VJP_2:%.*]] = partial_apply [callee_guaranteed] [[VJP_THUNK]]([[VJP_1]])
diff --git a/test/DebugInfo/mandatoryinlining-wrongdebugscope.swift b/test/DebugInfo/mandatoryinlining-wrongdebugscope.swift
diff --git a/test/SIL/ownership-verifier/use_verifier.sil b/test/SIL/ownership-verifier/use_verifier.sil
@@ -1328,3 +1328,92 @@ bb0(%0 : @guaranteed $GenericS<T>):
   %2 = copy_value %1 : $GenericS<AnyObject>
   return %2 : $GenericS<AnyObject>
 }
+
+/////////////////////////////
+// Thin To Thick Ownership //
+/////////////////////////////
+
+// Make sure that we always have thin_to_thick_function produce any ownership
+// and that ownership phis propagate things correctly.
+
+sil @thin_to_thick_function_callee : $@convention(thin) () -> ()
+
+sil [ossa] @thin_to_thick_function_noneownership_test_1 : $@convention(thin) () -> () {
+bb0:
+  %f1 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  %f2 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  cond_br undef, bb1, bb2
+
+bb1:
+  %f1thick = thin_to_thick_function %f1 : $@convention(thin) () -> () to $@callee_owned () -> ()
+  br bb3(%f1thick : $@callee_owned () -> ())
+
+bb2:
+  %f2thick = thin_to_thick_function %f2 : $@convention(thin) () -> () to $@callee_owned () -> ()
+  br bb3(%f2thick : $@callee_owned () -> ())
+
+bb3(%fUnknown : @owned $@callee_owned () -> ()):
+  destroy_value %fUnknown : $@callee_owned () -> ()
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+sil [ossa] @thin_to_thick_function_noneownership_test_2 : $@convention(thin) () -> () {
+bb0:
+  %f1 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  %f2 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  cond_br undef, bb1, bb2
+
+bb1:
+  %f1thick = thin_to_thick_function %f1 : $@convention(thin) () -> () to $@callee_owned () -> ()
+  br bb3(%f1thick : $@callee_owned () -> ())
+
+bb2:
+  %f2thick = thin_to_thick_function %f2 : $@convention(thin) () -> () to $@callee_owned () -> ()
+  br bb3(%f2thick : $@callee_owned () -> ())
+
+bb3(%fUnknown : $@callee_owned () -> ()):
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+sil [ossa] @thin_to_thick_function_noneownership_test_3 : $@convention(thin) () -> () {
+bb0:
+  %f1 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  %f2 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  cond_br undef, bb1, bb2
+
+bb1:
+  %f1thick = thin_to_thick_function %f1 : $@convention(thin) () -> () to $@callee_owned () -> ()
+  br bb3(%f1thick : $@callee_owned () -> ())
+
+bb2:
+  %f2thick = thin_to_thick_function %f2 : $@convention(thin) () -> () to $@callee_owned () -> ()
+  br bb3(%f2thick : $@callee_owned () -> ())
+
+bb3(%fUnknown : @guaranteed $@callee_owned () -> ()):
+  end_borrow %fUnknown : $@callee_owned () -> ()
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+sil [ossa] @thin_to_thick_function_noneownership_test_4 : $@convention(thin) () -> () {
+bb0:
+  %f1 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  %f2 = function_ref @thin_to_thick_function_callee : $@convention(thin) () -> ()
+  cond_br undef, bb1, bb2
+
+bb1:
+  %f1thick = thin_to_thick_function %f1 : $@convention(thin) () -> () to $@callee_owned () -> ()
+  br bb3(%f1thick : $@callee_owned () -> ())
+
+bb2:
+  %f2thick = partial_apply %f2() : $@convention(thin) () -> ()
+  br bb3(%f2thick : $@callee_owned () -> ())
+
+// This case we can only pass owned b/c of the partial apply.
+bb3(%fUnknown : @owned $@callee_owned () -> ()):
+  destroy_value %fUnknown : $@callee_owned () -> ()
+  %9999 = tuple()
+  return %9999 : $()
+}
diff --git a/test/SILGen/cf_members.swift b/test/SILGen/cf_members.swift
@@ -39,12 +39,12 @@ public func foo(_ x: Double) {
   // CHECK: [[FN:%.*]] = function_ref @$s10cf_members3fooyySdFSo10IAMStruct1VSdcfu_ : $@convention(thin) (Double) -> Struct1
   // CHECK: [[A:%.*]] = thin_to_thick_function [[FN]]
   // CHECK: [[BORROWED_A:%.*]] = begin_borrow [[A]]
-  // CHECK: [[A_COPY:%.*]] = copy_value [[BORROWED_A]]
-  // CHECK: [[BORROWED_A2:%.*]] = begin_borrow [[A_COPY]]
   let a: (Double) -> Struct1 = Struct1.init(value:)
-  // CHECK: apply [[BORROWED_A2]]([[X]])
-  // CHECK: destroy_value [[A_COPY]]
+  // CHECK: [[NEW_Z_VALUE:%.*]] = apply [[BORROWED_A]]([[X]])
   // CHECK: end_borrow [[BORROWED_A]]
+  // CHECK: [[WRITE:%.*]] = begin_access [modify] [unknown] [[Z]]
+  // CHECK: assign [[NEW_Z_VALUE]] to [[WRITE]]
+  // CHECK: end_access [[WRITE]]
   z = a(x)
 
   // TODO: Support @convention(c) references that only capture thin metatype
@@ -77,14 +77,12 @@ public func foo(_ x: Double) {
   z = c(x)
   // CHECK: [[THUNK:%.*]] = function_ref @$s10cf_members3fooyySdFSo10IAMStruct1VSdcADcfu2_ : $@convention(thin) (Struct1) -> @owned @callee_guaranteed (Double) -> Struct1
   // CHECK: [[THICK:%.*]] = thin_to_thick_function [[THUNK]]
-  // CHECK: [[BORROW:%.*]] = begin_borrow [[THICK]]
-  // CHECK: [[COPY:%.*]] = copy_value [[BORROW]]
   let d: (Struct1) -> (Double) -> Struct1 = Struct1.translate(radians:)
   // CHECK: [[READ:%.*]] = begin_access [read] [unknown] [[Z]] : $*Struct1
   // CHECK: [[ZVAL:%.*]] = load [trivial] [[READ]]
-  // CHECK: [[BORROW_COPY:%.*]] = begin_borrow [[COPY]]
-  // CHECK: apply [[BORROW_COPY]]([[ZVAL]])
-  // CHECK: destroy_value [[COPY]]
+  // CHECK: [[THICK_BORROW:%.*]] = begin_borrow [[THICK]]
+  // CHECK: apply [[THICK_BORROW]]([[ZVAL]])
+  // CHECK: end_borrow [[THICK_BORROW]]
   z = d(z)(x)
 
   // TODO: If we implement SE-0042, this should thunk the value Struct1 param
diff --git a/test/SILGen/generic_closures.swift b/test/SILGen/generic_closures.swift
@@ -74,7 +74,6 @@ func generic_nocapture_existential<T>(_ x: T, y: Concept) -> Bool {
 
   // CHECK: [[FOO:%.*]] = function_ref @$s16generic_closures0A22_nocapture_existential{{.*}} : $@convention(thin) (@in_guaranteed Concept) -> Bool
   // CHECK: [[FOO_CLOSURE:%.*]] = thin_to_thick_function [[FOO]]
-  // CHECK: destroy_value [[FOO_CLOSURE]]
   let _ = foo
 
   // CHECK: [[FOO:%.*]] = function_ref @$s16generic_closures0A22_nocapture_existential{{.*}} : $@convention(thin) (@in_guaranteed Concept) -> Bool
diff --git a/test/SILGen/implicitly_unwrapped_optional.swift b/test/SILGen/implicitly_unwrapped_optional.swift
@@ -70,13 +70,8 @@ func sr3758() {
   // CHECK: [[CLOSURE:%.+]] = function_ref @$s29implicitly_unwrapped_optional6sr3758yyFyypSgcfU_ : $@convention(thin) (@in_guaranteed Optional<Any>) -> ()
   // CHECK: [[F:%.+]] = thin_to_thick_function [[CLOSURE]] : $@convention(thin) (@in_guaranteed Optional<Any>) -> () to $@callee_guaranteed (@in_guaranteed Optional<Any>) -> ()
   // CHECK: [[BORROWED_F:%.*]] = begin_borrow [[F]]
-  // CHECK: [[CALLEE:%.+]] = copy_value [[BORROWED_F]] : $@callee_guaranteed (@in_guaranteed Optional<Any>) -> ()
-  // CHECK: [[BORROWED_CALLEE:%.*]] = begin_borrow [[CALLEE]]
-  // CHECK: = apply [[BORROWED_CALLEE]]({{%.+}}) : $@callee_guaranteed (@in_guaranteed Optional<Any>) -> ()
-  // CHECK: end_borrow [[BORROWED_CALLEE]]
-  // destroy_value [[CALLEE]]
+  // CHECK: = apply [[BORROWED_F]]({{%.+}}) : $@callee_guaranteed (@in_guaranteed Optional<Any>) -> ()
   // CHECK: end_borrow [[BORROWED_F]]
-  // CHECK: destroy_value [[F]]
   let f: ((Any?) -> Void) = { (arg: Any!) in }
   f(nil)
 } // CHECK: end sil function '$s29implicitly_unwrapped_optional6sr3758yyF'
diff --git a/test/SILGen/reabstract.swift b/test/SILGen/reabstract.swift
@@ -21,7 +21,6 @@ func test0() {
 // CHECK-NEXT: [[T5:%.*]] = convert_function [[T4]]
 // CHECK-NEXT: [[CVT:%.*]] = convert_escape_to_noescape [not_guaranteed] [[T5]]
 // CHECK: destroy_value [[T5]]
-// CHECK-NEXT: destroy_value [[T2]]
 // CHECK:      [[T0:%.*]] = function_ref @$s10reabstract6takeFn{{[_0-9a-zA-Z]*}}F
 // CHECK-NEXT: apply [[T0]]<Int>([[CVT]])
 // CHECK-NEXT: tuple ()
@@ -34,6 +33,7 @@ func test0() {
 // MANDATORY:      reabstract.liftOptional
 // MANDATORY-NEXT: [[T1:%.*]] = function_ref @$s10reabstract12liftOptional{{[_0-9a-zA-Z]*}}F
 // MANDATORY-NEXT: [[T2:%.*]] = thin_to_thick_function [[T1]]
+// MANDATORY-NEXT: strong_retain [[T2]]
 // MANDATORY-NEXT: [[CVT:%.*]] = convert_escape_to_noescape [[T2]]
 // MANDATORY-NEXT: //{{.*}}reabstraction thunk
 // MANDATORY-NEXT: [[T3:%.*]] = function_ref [[THUNK:@.*]] :
diff --git a/test/SILGen/rethrows.swift b/test/SILGen/rethrows.swift
@@ -15,14 +15,10 @@ func nonthrower() -> Int { return 0 }
 // CHECK:       [[RETHROWER:%.*]] = function_ref @$s8rethrows9rethroweryS2iyKXEKF : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error)
 // CHECK:       try_apply [[RETHROWER]]([[CVT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
 // CHECK:     [[NORMAL]]([[RESULT_T0:%.*]] : $Int):
-// FIXME - SR-6979: We should be able to eliminate this strong_release.
-// CHECK-NEXT:  strong_release [[T0]]
 // CHECK-NEXT:  strong_release [[T0]]
 // CHECK-NEXT:  [[T1:%.*]] = tuple ()
 // CHECK-NEXT:  return [[T1]]
 // CHECK:     [[ERROR]]([[RESULT_T0:%.*]] : $Error):
-// FIXME - SR-6979: We should be able to eliminate this strong_release.
-// CHECK-NEXT:  strong_release [[T0]]
 // CHECK-NEXT:  strong_release [[T0]]
 // CHECK-NEXT:  throw [[RESULT_T0]]
 func test0() throws {
@@ -49,11 +45,9 @@ func test0() throws {
 // CHECK:       try_apply [[RETHROWER]]([[CVT]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
 // CHECK:     [[NORMAL]]([[RESULT:%.*]] : $Int):
 // CHECK-NEXT:  strong_release [[T0]]
-// CHECK-NEXT:  strong_release [[T0]]
 // CHECK-NEXT:  return [[RESULT]]
 // CHECK:     [[ERROR]]([[ERROR:%.*]] : $Error):
 // CHECK-NEXT:  strong_release [[T0]]
-// CHECK-NEXT:  strong_release [[T0]]
 // CHECK-NEXT:  throw [[ERROR]]
 func test1() throws {
   try rethrower { try rethrower(thrower) }
@@ -68,7 +62,6 @@ func test1() throws {
 // CHECK:       try_apply [[RETHROWER]]([[T2]]) : $@convention(thin) (@noescape @callee_guaranteed () -> (Int, @error Error)) -> (Int, @error Error), normal [[NORMAL:bb1]], error [[ERROR:bb2]]
 // CHECK:     [[NORMAL]]([[T0:%.*]] : $Int):
 // CHECK-NEXT:  strong_release [[T1]]
-// CHECK-NEXT:  strong_release [[T1]]
 // CHECK-NEXT:  [[RESULT:%.*]] = tuple ()
 // CHECK-NEXT:  return [[RESULT]]
 // CHECK:     [[ERROR]]([[T0:%.*]] : $Error):
