EscapeUtils: don't follow the result of a partial_apply for not captured address operands.

A partial_apply copies the values from indirect-in arguments, but does not capture the address.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -546,7 +546,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       // We need to follow the partial_apply value for two reasons:
       // 1. the closure (with the captured values) itself can escape
       // 2. something can escape in a destructor when the context is destroyed
-      return walkDownUses(ofValue: pai, path: path.with(knownType: nil))
+      if followLoads(at: path) || pai.capturesAddress(of: operand) {
+        return walkDownUses(ofValue: pai, path: path.with(knownType: nil))
+      }
     case is LoadInst, is LoadWeakInst, is LoadUnownedInst, is LoadBorrowInst:
       if !followLoads(at: path) {
         return .continueWalk
@@ -966,3 +968,23 @@ private extension SmallProjectionPath {
     EscapeUtilityTypes.EscapePath(projectionPath: self, followStores: false, addressIsStored: false, knownType: nil)
   }
 }
+
+private extension PartialApplyInst {
+  func capturesAddress(of operand: Operand) -> Bool {
+    assert(operand.value.type.isAddress)
+    guard let conv = convention(of: operand) else {
+      fatalError("callee operand of partial_apply cannot have address type")
+    }
+    switch conv {
+    case .indirectIn, .indirectInGuaranteed:
+      // A partial_apply copies the values from indirect-in arguments, but does not capture the address.
+      return false
+    case .indirectInout, .indirectInoutAliasable, .packInout:
+      return true
+    case .directOwned, .directUnowned, .directGuaranteed, .packOwned, .packGuaranteed:
+      fatalError("invalid convention for address operand")
+    case .indirectOut, .packOut, .indirectInCXX:
+      fatalError("invalid convention for partial_apply")
+    }
+  }
+}

test/SILOptimizer/mem-behavior.sil

@@ -1656,6 +1656,25 @@ bb0(%0 :  $*X):
   return %3 : $()
 }
 
+// CHECK-LABEL: @test_non_escaping_applied
+// CHECK:       PAIR #0.
+// CHECK-NEXT:      %2 = partial_apply [on_stack] %1(%0) : $@convention(thin) (@in_guaranteed X) -> ()
+// CHECK-NEXT:    %0 = argument of bb0 : $*X
+// CHECK-NEXT:    r=1,w=0
+// CHECK:       PAIR #1.
+// CHECK-NEXT:      %3 = apply %2() : $@noescape @callee_owned () -> ()
+// CHECK-NEXT:    %0 = argument of bb0 : $*X
+// CHECK-NEXT:    r=0,w=0
+sil [ossa] @test_non_escaping_applied : $@convention(thin) (@in X) -> () {
+bb0(%0 :  $*X):
+  %1 = function_ref @indirect_X : $@convention(thin) (@in_guaranteed X) -> ()
+  %2 = partial_apply [on_stack] %1(%0) : $@convention(thin) (@in_guaranteed X) -> ()
+  %3 = apply %2() : $@noescape @callee_owned () -> ()
+  destroy_addr %0
+  %6 = tuple ()
+  return %6 : $()
+}
+
 sil @closure : $@convention(thin) (@inout_aliasable Int) -> ()
 sil @closure2 : $@convention(thin) (Int, @inout_aliasable Int) -> ()