Merge pull request #61304 from nate-chandler/transfer-sil-function-argument-attrs

nate-chandler · web-flow · commit 5cf1cb368d9e · 2022-09-27T08:05:19.000-07:00
[SILOptimizer] Preserve arg attrs at cloning.
diff --git a/lib/SIL/IR/SILBasicBlock.cpp b/lib/SIL/IR/SILBasicBlock.cpp
@@ -123,8 +123,10 @@ void SILBasicBlock::cloneArgumentList(SILBasicBlock *Other) {
   if (isEntry()) {
     assert(args_empty() && "Expected to have no arguments");
     for (auto *FuncArg : Other->getSILFunctionArguments()) {
-      createFunctionArgument(FuncArg->getType(),
-                             FuncArg->getDecl());
+      auto *NewArg =
+          createFunctionArgument(FuncArg->getType(), FuncArg->getDecl());
+      NewArg->setNoImplicitCopy(FuncArg->isNoImplicitCopy());
+      NewArg->setLifetimeAnnotation(FuncArg->getLifetimeAnnotation());
     }
     return;
   }
diff --git a/lib/SILOptimizer/FunctionSignatureTransforms/ArgumentExplosionTransform.cpp b/lib/SILOptimizer/FunctionSignatureTransforms/ArgumentExplosionTransform.cpp
@@ -390,9 +390,12 @@ void FunctionSignatureTransform::ArgumentExplosionFinalizeOptimizedFunction() {
 
     for (auto *Node : LeafNodes) {
       auto OwnershipKind = *AD.getTransformedOwnershipKind(Node->getType());
-      LeafValues.push_back(
+      auto *Argument =
           BB->insertFunctionArgument(ArgOffset, Node->getType(), OwnershipKind,
-                                     BB->getArgument(OldArgIndex)->getDecl()));
+                                     BB->getArgument(OldArgIndex)->getDecl());
+      Argument->setNoImplicitCopy(AD.Arg->isNoImplicitCopy());
+      Argument->setLifetimeAnnotation(AD.Arg->getLifetimeAnnotation());
+      LeafValues.push_back(Argument);
       TransformDescriptor.AIM[TotalArgIndex - 1] = AD.Index;
       ++ArgOffset;
       ++TotalArgIndex;
diff --git a/lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp b/lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp
@@ -165,6 +165,8 @@ void ExistentialSpecializerCloner::cloneArguments(
           LoweredTy.getCategoryType(ArgDesc.Arg->getType().getCategory());
       auto *NewArg =
           ClonedEntryBB->createFunctionArgument(MappedTy, ArgDesc.Decl);
+      NewArg->setNoImplicitCopy(ArgDesc.Arg->isNoImplicitCopy());
+      NewArg->setLifetimeAnnotation(ArgDesc.Arg->getLifetimeAnnotation());
       NewArg->setOwnershipKind(ValueOwnershipKind(
           NewF, MappedTy, ArgDesc.Arg->getArgumentConvention()));
       entryArgs.push_back(NewArg);
@@ -180,6 +182,8 @@ void ExistentialSpecializerCloner::cloneArguments(
         GenericSILType, ArgDesc.Decl,
         ValueOwnershipKind(NewF, GenericSILType,
                            ArgDesc.Arg->getArgumentConvention()));
+    NewArg->setNoImplicitCopy(ArgDesc.Arg->isNoImplicitCopy());
+    NewArg->setLifetimeAnnotation(ArgDesc.Arg->getLifetimeAnnotation());
     // Determine the Conformances.
     SILType ExistentialType = ArgDesc.Arg->getType().getObjectType();
     CanType OpenedType = NewArg->getType().getASTType();
@@ -402,7 +406,10 @@ void ExistentialTransform::populateThunkBody() {
   auto *ThunkBody = F->createBasicBlock();
   for (auto &ArgDesc : ArgumentDescList) {
     auto argumentType = ArgDesc.Arg->getType();
-    ThunkBody->createFunctionArgument(argumentType, ArgDesc.Decl);
+    auto *NewArg =
+        ThunkBody->createFunctionArgument(argumentType, ArgDesc.Decl);
+    NewArg->setNoImplicitCopy(ArgDesc.Arg->isNoImplicitCopy());
+    NewArg->setLifetimeAnnotation(ArgDesc.Arg->getLifetimeAnnotation());
   }
 
   /// Builder to add new instructions in the Thunk.
diff --git a/lib/SILOptimizer/FunctionSignatureTransforms/FunctionSignatureOpts.cpp b/lib/SILOptimizer/FunctionSignatureTransforms/FunctionSignatureOpts.cpp
@@ -566,7 +566,10 @@ void FunctionSignatureTransform::createFunctionSignatureOptimizedFunction() {
   F->setInlineStrategy(AlwaysInline);
   SILBasicBlock *ThunkBody = F->createBasicBlock();
   for (auto &ArgDesc : TransformDescriptor.ArgumentDescList) {
-    ThunkBody->createFunctionArgument(ArgDesc.Arg->getType(), ArgDesc.Decl);
+    auto *NewArg =
+        ThunkBody->createFunctionArgument(ArgDesc.Arg->getType(), ArgDesc.Decl);
+    NewArg->setNoImplicitCopy(ArgDesc.Arg->isNoImplicitCopy());
+    NewArg->setLifetimeAnnotation(ArgDesc.Arg->getLifetimeAnnotation());
   }
 
   SILLocation Loc = RegularLocation::getAutoGeneratedLocation();
diff --git a/lib/SILOptimizer/IPO/CapturePropagation.cpp b/lib/SILOptimizer/IPO/CapturePropagation.cpp
@@ -197,8 +197,12 @@ void CapturePropagationCloner::cloneClosure(
 
     SILArgument *Arg = OrigEntryBB->getArgument(ArgIdx);
 
-    SILValue MappedValue = ClonedEntryBB->createFunctionArgument(
+    auto *MappedValue = ClonedEntryBB->createFunctionArgument(
         remapType(Arg->getType()), Arg->getDecl());
+    MappedValue->setNoImplicitCopy(
+        cast<SILFunctionArgument>(Arg)->isNoImplicitCopy());
+    MappedValue->setLifetimeAnnotation(
+        cast<SILFunctionArgument>(Arg)->getLifetimeAnnotation());
     entryArgs.push_back(MappedValue);
   }
   assert(OrigEntryBB->args_size() - ArgIdx == PartialApplyArgs.size()
diff --git a/lib/SILOptimizer/IPO/ClosureSpecializer.cpp b/lib/SILOptimizer/IPO/ClosureSpecializer.cpp
@@ -806,8 +806,12 @@ void ClosureSpecCloner::populateCloned() {
 
     // Otherwise, create a new argument which copies the original argument
     auto typeInContext = Cloned->getLoweredType(Arg->getType());
-    SILValue MappedValue =
+    auto *MappedValue =
         ClonedEntryBB->createFunctionArgument(typeInContext, Arg->getDecl());
+    MappedValue->setNoImplicitCopy(
+        cast<SILFunctionArgument>(Arg)->isNoImplicitCopy());
+    MappedValue->setLifetimeAnnotation(
+        cast<SILFunctionArgument>(Arg)->getLifetimeAnnotation());
     entryArgs.push_back(MappedValue);
   }
 
diff --git a/lib/SILOptimizer/Mandatory/CapturePromotion.cpp b/lib/SILOptimizer/Mandatory/CapturePromotion.cpp
@@ -491,8 +491,12 @@ void ClosureCloner::populateCloned() {
   for (; ai != ae; ++argNo, ++ai) {
     if (!promotableIndices.count(argNo)) {
       // Simply create a new argument which copies the original argument
-      SILValue mappedValue = clonedEntryBB->createFunctionArgument(
+      auto *mappedValue = clonedEntryBB->createFunctionArgument(
           (*ai)->getType(), (*ai)->getDecl());
+      mappedValue->setNoImplicitCopy(
+          cast<SILFunctionArgument>(*ai)->isNoImplicitCopy());
+      mappedValue->setLifetimeAnnotation(
+          cast<SILFunctionArgument>(*ai)->getLifetimeAnnotation());
       entryArgs.push_back(mappedValue);
       continue;
     }
@@ -504,8 +508,13 @@ void ClosureCloner::populateCloned() {
     auto boxedTy = getSILBoxFieldType(TypeExpansionContext(*cloned), boxTy,
                                       cloned->getModule().Types, 0)
                        .getObjectType();
-    SILValue mappedValue =
+    auto *newArg =
         clonedEntryBB->createFunctionArgument(boxedTy, (*ai)->getDecl());
+    newArg->setNoImplicitCopy(
+        cast<SILFunctionArgument>(*ai)->isNoImplicitCopy());
+    newArg->setLifetimeAnnotation(
+        cast<SILFunctionArgument>(*ai)->getLifetimeAnnotation());
+    SILValue mappedValue = newArg;
 
     // If SIL ownership is enabled, we need to perform a borrow here if we have
     // a non-trivial value. We know that our value is not written to and it does
diff --git a/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp b/lib/SILOptimizer/Transforms/AllocBoxToStack.cpp
@@ -799,6 +799,10 @@ PromotedParamCloner::populateCloned() {
                                            Cloned->getModule().Types, 0);
       auto *promotedArg =
           ClonedEntryBB->createFunctionArgument(promotedTy, (*I)->getDecl());
+      promotedArg->setNoImplicitCopy(
+          cast<SILFunctionArgument>(*I)->isNoImplicitCopy());
+      promotedArg->setLifetimeAnnotation(
+          cast<SILFunctionArgument>(*I)->getLifetimeAnnotation());
       OrigPromotedParameters.insert(*I);
 
       NewPromotedArgs[ArgNo] = promotedArg;
@@ -811,8 +815,13 @@ PromotedParamCloner::populateCloned() {
       entryArgs.push_back(SILValue());
     } else {
       // Create a new argument which copies the original argument.
-      entryArgs.push_back(ClonedEntryBB->createFunctionArgument(
-          (*I)->getType(), (*I)->getDecl()));
+      auto *newArg = ClonedEntryBB->createFunctionArgument((*I)->getType(),
+                                                           (*I)->getDecl());
+      newArg->setNoImplicitCopy(
+          cast<SILFunctionArgument>(*I)->isNoImplicitCopy());
+      newArg->setLifetimeAnnotation(
+          cast<SILFunctionArgument>(*I)->getLifetimeAnnotation());
+      entryArgs.push_back(newArg);
     }
     ++ArgNo;
     ++I;
diff --git a/lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp b/lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp
@@ -88,6 +88,10 @@ void MapOpaqueArchetypes::replace() {
     SILType mappedType = remapType(origArg->getType());
     auto *NewArg = clonedEntryBlock->createFunctionArgument(
         mappedType, origArg->getDecl(), true);
+    NewArg->setNoImplicitCopy(
+        cast<SILFunctionArgument>(origArg)->isNoImplicitCopy());
+    NewArg->setLifetimeAnnotation(
+        cast<SILFunctionArgument>(origArg)->getLifetimeAnnotation());
     entryArgs.push_back(NewArg);
   }
 
diff --git a/lib/SILOptimizer/Utils/GenericCloner.cpp b/lib/SILOptimizer/Utils/GenericCloner.cpp
@@ -120,6 +120,10 @@ void GenericCloner::populateCloned() {
           mappedType = mappedType.getObjectType();
           auto *NewArg = ClonedEntryBB->createFunctionArgument(
               mappedType, OrigArg->getDecl());
+          NewArg->setNoImplicitCopy(
+              cast<SILFunctionArgument>(OrigArg)->isNoImplicitCopy());
+          NewArg->setLifetimeAnnotation(
+              cast<SILFunctionArgument>(OrigArg)->getLifetimeAnnotation());
 
           // Try to create a new debug_value from an existing debug_value w/
           // address value for the argument. We do this before storing to
@@ -164,6 +168,10 @@ void GenericCloner::populateCloned() {
     if (!handleConversion()) {
       auto *NewArg =
           ClonedEntryBB->createFunctionArgument(mappedType, OrigArg->getDecl());
+      NewArg->setNoImplicitCopy(
+          cast<SILFunctionArgument>(OrigArg)->isNoImplicitCopy());
+      NewArg->setLifetimeAnnotation(
+          cast<SILFunctionArgument>(OrigArg)->getLifetimeAnnotation());
       entryArgs.push_back(NewArg);
     }
     ++ArgIdx;
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
@@ -2544,8 +2544,12 @@ SILFunction *ReabstractionThunkGenerator::createThunk() {
 
   if (!SILModuleConventions(M).useLoweredAddresses()) {
     for (auto SpecArg : SpecializedFunc->getArguments()) {
-      SILArgument *NewArg = EntryBB->createFunctionArgument(SpecArg->getType(),
-                                                            SpecArg->getDecl());
+      auto *NewArg = EntryBB->createFunctionArgument(SpecArg->getType(),
+                                                     SpecArg->getDecl());
+      NewArg->setNoImplicitCopy(
+          cast<SILFunctionArgument>(SpecArg)->isNoImplicitCopy());
+      NewArg->setLifetimeAnnotation(
+          cast<SILFunctionArgument>(SpecArg)->getLifetimeAnnotation());
       Arguments.push_back(NewArg);
     }
     FullApplySite ApplySite = createReabstractionThunkApply(Builder);
@@ -2642,8 +2646,12 @@ SILArgument *ReabstractionThunkGenerator::convertReabstractionThunkArguments(
   auto cloneSpecializedArgument = [&]() {
     // No change to the argument.
     SILArgument *SpecArg = *SpecArgIter++;
-    SILArgument *NewArg =
+    auto *NewArg =
         EntryBB->createFunctionArgument(SpecArg->getType(), SpecArg->getDecl());
+    NewArg->setNoImplicitCopy(
+        cast<SILFunctionArgument>(SpecArg)->isNoImplicitCopy());
+    NewArg->setLifetimeAnnotation(
+        cast<SILFunctionArgument>(SpecArg)->getLifetimeAnnotation());
     Arguments.push_back(NewArg);
   };
   // ReInfo.NumIndirectResults corresponds to SubstTy's formal indirect
@@ -2685,6 +2693,10 @@ SILArgument *ReabstractionThunkGenerator::convertReabstractionThunkArguments(
       SILArgument *SpecArg = *SpecArgIter++;
       SILFunctionArgument *NewArg =
           EntryBB->createFunctionArgument(ParamTy, SpecArg->getDecl());
+      NewArg->setNoImplicitCopy(
+          cast<SILFunctionArgument>(SpecArg)->isNoImplicitCopy());
+      NewArg->setLifetimeAnnotation(
+          cast<SILFunctionArgument>(SpecArg)->getLifetimeAnnotation());
       if (!NewArg->getArgumentConvention().isGuaranteedConvention()) {
         SILValue argVal = Builder.emitLoadValueOperation(
             Loc, NewArg, LoadOwnershipQualifier::Take);
diff --git a/test/SILOptimizer/Inputs/specialize_opaque_type_archetypes_3.swift b/test/SILOptimizer/Inputs/specialize_opaque_type_archetypes_3.swift
@@ -46,6 +46,22 @@ public struct ResilientContainer {
     let x = computedProperty
     print(x)
   }
+
+  @inlinable
+  @_eagerMove
+  @_specialize(where T == Int)
+  public func genericEagerMoveInlineableContext<T>(_ t: T) {
+    let x = computedProperty
+    print(x)
+    print(t)
+  }
+
+  @inlinable
+  @_eagerMove
+  public func eagerMoveInlineableContext() {
+    let x = computedProperty
+    print(x)
+  }
 }
 
 public struct WrapperP2<Wrapped: ExternalP2>: ExternalP2 {
diff --git a/test/SILOptimizer/allocbox_to_stack_ownership_attrs.sil b/test/SILOptimizer/allocbox_to_stack_ownership_attrs.sil
@@ -0,0 +1,49 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -allocbox-to-stack -enable-copy-propagation=requested-passes-only -enable-lexical-borrow-scopes=false | %FileCheck %s
+
+sil_stage raw
+
+protocol P {}
+
+
+sil [ossa] @callWithAutoclosure_3 : $@convention(thin) <T where T : P> (@in T) -> () {
+bb0(%0 : $*T):
+  debug_value %0 : $*T, expr op_deref
+  %2 = function_ref @mightApply : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned @callee_owned () -> @out τ_0_0) -> ()
+  %3 = function_ref @closure_to_specialize : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+  %4 = alloc_box $<τ_0_0> { var τ_0_0 } <T>
+  %4c = mark_uninitialized [var] %4 : $<τ_0_0> { var τ_0_0 } <T>
+  %4a = project_box %4c : $<τ_0_0> { var τ_0_0 } <T>, 0
+  %4copy = copy_value %4c : $<τ_0_0> { var τ_0_0 } <T>
+  copy_addr %0 to [initialization] %4a : $*T
+  %6 = partial_apply %3<T>(%4copy) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0
+  %7 = apply %2<T>(%6) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned @callee_owned () -> @out τ_0_0) -> ()
+  destroy_addr %0 : $*T
+  destroy_value %4c : $<τ_0_0> { var τ_0_0 } <T>
+  %9 = tuple ()
+  return %9 : $()
+}
+
+// CHECK-LABEL: sil {{.*}}@$s21closure_to_specializeTf0ns_n : {{.*}}{
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @_eagerMove $*T, {{%[^,]+}} : @_eagerMove $
+// CHECK-LABEL: } // end sil function '$s21closure_to_specializeTf0ns_n'
+sil shared [ossa] @closure_to_specialize : $@convention(thin) <T where T : P> (@owned <τ_0_0> { var τ_0_0 } <T>) -> @out T {
+bb0(%0 : @_eagerMove $*T, %1 : @_eagerMove @owned $<τ_0_0> { var τ_0_0 } <T>):
+  %2 = project_box %1 : $<τ_0_0> { var τ_0_0 } <T>, 0
+  copy_addr %2 to [initialization] %0 : $*T
+  destroy_value %1 : $<τ_0_0> { var τ_0_0 } <T>
+  %5 = tuple ()
+  return %5 : $()
+}
+
+sil [transparent] [serialized] [ossa] @mightApply : $@convention(thin) <U where U : P> (@owned @callee_owned () -> @out U) -> () {
+bb0(%0 : @owned $@callee_owned () -> @out U):
+  debug_value %0 : $@callee_owned () -> @out U
+  %1 = copy_value %0 : $@callee_owned () -> @out U
+  %3 = alloc_stack $U
+  %4 = apply %1(%3) : $@callee_owned () -> @out U
+  destroy_addr %3 : $*U
+  dealloc_stack %3 : $*U
+  destroy_value %0 : $@callee_owned () -> @out U
+  %8 = tuple ()
+  return %8 : $()
+}
diff --git a/test/SILOptimizer/capture_promotion_attr.sil b/test/SILOptimizer/capture_promotion_attr.sil
@@ -0,0 +1,62 @@
+// RUN: %target-sil-opt -enable-sil-verify-all %s -capture-prop | %FileCheck %s
+
+sil_stage raw
+
+import Builtin
+import Swift
+
+class C {}
+
+sil [ossa] @getC : $@convention(thin) () -> @owned C
+
+sil [ossa] @test_capture_propagation : $@convention(thin) () -> () {
+bb0:
+  %addr = alloc_stack $C                           
+  %getC = function_ref @getC : $@convention(thin) () -> @owned C
+  %c1 = apply %getC() : $@convention(thin) () -> @owned C
+  store %c1 to [init] %addr : $*C                        
+  
+  %closure = function_ref @closure : $@convention(thin) (@owned C) -> () 
+  %thick_closure = thin_to_thick_function %closure : $@convention(thin) (@owned C) -> () to $@callee_owned (@owned C) -> () 
+  
+  %thunk = function_ref @thunk : $@convention(thin) (@in C, @owned @callee_owned (@owned C) -> ()) -> () 
+  %thunked_closure = partial_apply %thunk(%thick_closure) : $@convention(thin) (@in C, @owned @callee_owned (@owned C) -> ()) -> () 
+  
+  %apply_closure = function_ref @apply_closure : $@convention(thin) (@in C, @owned @callee_owned (@in C) -> ()) -> () 
+  apply %apply_closure(%addr, %thunked_closure) : $@convention(thin) (@in C, @owned @callee_owned (@in C) -> ()) -> ()
+
+  dealloc_stack %addr : $*C       
+  %retval = tuple ()                                  
+  return %retval : $()                                
+}
+
+
+sil [ossa] @closure : $@convention(thin) (@owned C) -> () {
+bb0(%0 : @owned $C):
+  destroy_value %0 : $C
+  %retval = tuple ()                                   
+  return %retval : $()                                 
+}
+
+// CHECK-LABEL: sil {{.*}}@$s5thunk7closureTf3npf_n : {{.*}}{
+// CHECK:       {{bb[0-9]+}}({{%[^,]+}} : @_eagerMove $
+// CHECK-LABEL: } // end sil function '$s5thunk7closureTf3npf_n'
+sil [ossa] [transparent] @thunk : $@convention(thin) (@in C, @owned @callee_owned (@owned C) -> ()) -> () {
+bb0(%addr : @_eagerMove $*C, %closure : @owned $@callee_owned (@owned C) -> ()):
+  %instance = load [take] %addr : $*C                            
+  apply %closure(%instance) : $@callee_owned (@owned C) -> ()  
+  %retval = tuple ()                                   
+  return %retval : $()                                 
+}
+
+
+sil [ossa] [noinline] @apply_closure : $@convention(thin) (@in C, @owned @callee_owned (@in C) -> ()) -> () {
+bb0(%addr : $*C, %closure : @owned $@callee_owned (@in C) -> ()):
+  %stack_addr = alloc_stack $C                           
+  %instance = load [take] %addr : $*C                            
+  store %instance to [init] %stack_addr : $*C                        
+  apply %closure(%stack_addr) : $@callee_owned (@in C) -> ()
+  dealloc_stack %stack_addr : $*C       
+  %retval = tuple ()                                   
+  return %retval : $()                                 
+}
diff --git a/test/SILOptimizer/capture_promotion_attrs.sil b/test/SILOptimizer/capture_promotion_attrs.sil
diff --git a/test/SILOptimizer/closure_specialize_attrs.sil b/test/SILOptimizer/closure_specialize_attrs.sil
diff --git a/test/SILOptimizer/eager_specialize_ossa_attr.sil b/test/SILOptimizer/eager_specialize_ossa_attr.sil
diff --git a/test/SILOptimizer/functionsigopts_attrs.swift b/test/SILOptimizer/functionsigopts_attrs.swift
diff --git a/test/SILOptimizer/specialize_opaque_type_archetypes.swift b/test/SILOptimizer/specialize_opaque_type_archetypes.swift

Original file line number	Diff line number	Diff line change
`@@ -123,8 +123,10 @@ void SILBasicBlock::cloneArgumentList(SILBasicBlock *Other) {`
`123`	`123`	`if (isEntry()) {`
`124`	`124`	`assert(args_empty() && "Expected to have no arguments");`
`125`	`125`	`for (auto *FuncArg : Other->getSILFunctionArguments()) {`
`126`		`- createFunctionArgument(FuncArg->getType(),`
`127`		`- FuncArg->getDecl());`
	`126`	`+ auto *NewArg =`
	`127`	`+ createFunctionArgument(FuncArg->getType(), FuncArg->getDecl());`
	`128`	`+ NewArg->setNoImplicitCopy(FuncArg->isNoImplicitCopy());`
	`129`	`+ NewArg->setLifetimeAnnotation(FuncArg->getLifetimeAnnotation());`
`128`	`130`	`}`
`129`	`131`	`return;`
`130`	`132`	`}`