[sil-opaque-values] Fix FunctionSigOpts for opaque owned-to-guaranteed.

Do not create destroy_addr for opaque values.

Do not create strong_retain/release for opaque types.

Author: atrick

lib/SILOptimizer/Transforms/FunctionSignatureOpts.cpp

@@ -967,18 +967,17 @@ OwnedToGuaranteedFinalizeThunkFunction(SILBuilder &Builder, SILFunction *F) {
 
 static void createArgumentRelease(SILBuilder &Builder, ArgumentDescriptor &AD) {
   auto &F = Builder.getFunction();
-  if (AD.PInfo->getConvention() == ParameterConvention::Direct_Owned) {
-    Builder.createReleaseValue(RegularLocation(SourceLoc()),
-                               F.getArguments()[AD.Index],
-                               Builder.getDefaultAtomicity());
-    return;
-  }
-  if (AD.PInfo->getConvention() == ParameterConvention::Indirect_In) {
+  SILArgument *Arg = F.getArguments()[AD.Index];
+  if (Arg->getType().isAddress()) {
+    assert(AD.PInfo->getConvention() == ParameterConvention::Indirect_In
+           && F.getConventions().useLoweredAddresses());
     Builder.createDestroyAddr(RegularLocation(SourceLoc()),
                               F.getArguments()[AD.Index]);
     return;
   }
-  llvm_unreachable("Parameter convention is not supported");
+  Builder.createReleaseValue(RegularLocation(SourceLoc()),
+                             F.getArguments()[AD.Index],
+                             Builder.getDefaultAtomicity());
 }
 
 /// Set up epilogue work for the thunk arguments based in the given argument.

lib/SILOptimizer/Utils/Local.cpp

@@ -53,7 +53,8 @@ swift::createIncrementBefore(SILValue Ptr, SILInstruction *InsertPt) {
 
   // If Ptr is refcounted itself, create the strong_retain and
   // return.
-  if (Ptr->getType().isReferenceCounted(B.getModule()))
+  auto &TL = B.getModule().getTypeLowering(Ptr->getType());
+  if (!TL.isAddressOnly() && TL.isReferenceCounted())
     return B.createStrongRetain(Loc, Ptr, B.getDefaultAtomicity());
 
   // Otherwise, create the retain_value.
@@ -73,7 +74,8 @@ swift::createDecrementBefore(SILValue Ptr, SILInstruction *InsertPt) {
   auto Loc = RegularLocation(SourceLoc());
 
   // If Ptr has reference semantics itself, create a strong_release.
-  if (Ptr->getType().isReferenceCounted(B.getModule()))
+  auto &TL = B.getModule().getTypeLowering(Ptr->getType());
+  if (!TL.isAddressOnly() && TL.isReferenceCounted())
     return B.createStrongRelease(Loc, Ptr, B.getDefaultAtomicity());
 
   // Otherwise create a release value.

test/SILOptimizer/funcsig_opaque.sil

@@ -0,0 +1,44 @@
+// RUN: %target-sil-opt -enable-sil-opaque-values -assume-parsing-unqualified-ownership-sil -function-signature-opts %s | %FileCheck %s
+
+import Builtin
+
+struct R<T> {
+  var base: T
+}
+
+struct S {
+  var val: Builtin.Int32
+}
+
+sil @testAggregateArgHelper : $@convention(thin) (@owned R<S>) -> ()
+
+// Test owned-to-guaranteed transformation of opaque arguments.
+//
+// CHECK-LABEL: sil [thunk] [always_inline] @testAggregateArg : $@convention(thin) (@in R<S>) -> @out () {
+// CHECK: bb0(%0 : $R<S>):
+// CHECK:   [[F:%.*]] = function_ref @_T016testAggregateArgTf4g_n : $@convention(thin) (@in_guaranteed R<S>) -> @out ()
+// CHECK:   [[CALL:%.*]] = apply [[F]](%0) : $@convention(thin) (@in_guaranteed R<S>) -> @out ()
+// CHECK:   release_value %0 : $R<S>
+// CHECK:   return [[CALL]] : $()
+// CHECK-LABEL: } // end sil function 'testAggregateArg'
+//
+// CHECK-LABEL: sil shared @_T016testAggregateArgTf4g_n : $@convention(thin) (@in_guaranteed R<S>) -> @out () {
+// CHECK: bb0(%0 : $R<S>):
+// CHECK:   [[COPY:%.*]] = copy_value %0 : $R<S>
+// CHECK:   retain_value %0 : $R<S>
+// CHECK:   [[F:%.*]] = function_ref @testAggregateArgHelper : $@convention(thin) (@owned R<S>) -> ()
+// CHECK:   [[CALL:%.*]] = apply [[F]]([[COPY]]) : $@convention(thin) (@owned R<S>) -> ()
+// CHECK:   destroy_value %0 : $R<S>
+// CHECK:   return %{{.*}} : $()
+// CHECK-LABEL: } // end sil function '_T016testAggregateArgTf4g_n'
+sil @testAggregateArg : $@convention(thin) (@in R<S>) -> @out () {
+bb0(%0 : $R<S>):
+  %9 = copy_value %0 : $R<S>
+  retain_value %0 : $R<S>
+  %10 = function_ref @testAggregateArgHelper : $@convention(thin) (@owned R<S>) -> ()
+  %12 = apply %10(%9) : $@convention(thin) (@owned R<S>) -> ()
+  destroy_value %0 : $R<S>
+  release_value %0 : $R<S>
+  %1284 = tuple ()
+  return %1284 : $()
+}