ComputeEscapeEffects: correctly handle "exclusive" argument -> return effects

* Disallow stores in the return -> argument path. When walking up in the EscapeUtils, it's allowed to follow stores. Therefore stores wouldn't be handled correctly.
* Also make sure that there is a return -> argument path at all

Fixes a wrong address-escaping effect in case the called function copies an indirect argument to a newly created object.
rdar://105133434

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -197,25 +197,39 @@ private func isOperandOfRecursiveCall(_ op: Operand) -> Bool {
   return false
 }
 
-/// Returns true if when walking from the `toSelection` to the `fromArgument`,
-/// there are no other arguments or escape points than `fromArgument`. Also, the
-/// path at the `fromArgument` must match with `fromPath`.
+/// Returns true if when walking up from the `returnInst`, the `fromArgument` is the one
+/// and only argument which is reached - with a matching `fromPath`.
 private
 func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjectionPath,
                                toPath: SmallProjectionPath,
                                returnInst: ReturnInst, _ context: FunctionPassContext) -> Bool {
-  struct IsExclusiveReturnEscapeVisitor : EscapeVisitor {
+  struct IsExclusiveReturnEscapeVisitor : EscapeVisitorWithResult {
     let fromArgument: Argument
     let fromPath: SmallProjectionPath
     let toPath: SmallProjectionPath
+    var result = false
 
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-      if operand.instruction is ReturnInst {
+      switch operand.instruction {
+      case is ReturnInst:
         if path.followStores { return .abort }
         if path.projectionPath.matches(pattern: toPath) {
           return .ignore
         }
         return .abort
+      case let si as StoringInstruction:
+        // Don't allow store instructions because this allows the EscapeUtils to walk up
+        // an apply result with `followStores`.
+        if operand == si.destinationOperand {
+          return .abort
+        }
+      case let ca as CopyAddrInst:
+        // `copy_addr` is like a store.
+        if operand == ca.destinationOperand {
+          return .abort
+        }
+      default:
+        break
       }
       return .continueWalk
     }
@@ -226,11 +240,12 @@ func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjection
       }
       if path.followStores { return .abort }
       if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) {
+        result = true
         return .walkDown
       }
       return .abort
     }
   }
   let visitor = IsExclusiveReturnEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath, toPath: toPath)
-  return !returnInst.operand.at(toPath).isEscaping(using: visitor, context)
+  return returnInst.operand.at(toPath).visit(using: visitor, context) ?? false
 }

test/SILOptimizer/escape_effects.sil

@@ -331,7 +331,7 @@ bb0(%0 : $*Z, %1 : $Y):
 }
 
 // CHECK-LABEL: sil @store_to_content
-// CHECK-NEXT:  [%0: escape => %r, escape c*.v** => %r.c*.v**]
+// CHECK-NEXT:  [%0: escape => %r, escape c*.v** -> %r.c*.v**]
 // CHECK-NEXT:  {{^[^[]}}
 sil @store_to_content : $@convention(thin) (@owned Z, @guaranteed Y) -> @owned Z {
 bb0(%0 : $Z, %1 : $Y):
@@ -372,3 +372,15 @@ bb0(%0 : $*Z, %1 : $Y):
   %5 = tuple ()
   return %5 : $()
 }
+
+// CHECK-LABEL: sil @store_to_class_field
+// CHECK-NEXT:  [%0: escape v** -> %r.c0.v**, escape v**.c*.v** -> %r.c0.v**.c*.v**]
+// CHECK-NEXT:  {{^[^[]}}
+sil @store_to_class_field : $@convention(thin) (@in_guaranteed Str) -> @owned Y {
+bb0(%0 : $*Str):
+  %1 = alloc_ref $Y
+  %2 = ref_element_addr %1 : $Y, #Y.s
+  copy_addr %0 to [init] %2 : $*Str
+  return %1 : $Y
+}
+

test/SILOptimizer/release-hoisting.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-frontend -O -module-name=test -emit-sil %s | %FileCheck %s
+
+protocol P {}
+
+public struct S {
+  let p: P // force S to be an address-only type
+  let i: Int
+}
+
+public final class X {
+  let s: S
+
+  init(s: S) {
+    self.s = s
+  }
+}
+
+@inline(never)
+func createX(s: S) -> X {
+  return X(s: s)
+}
+
+// Test that the load is a barrier for release hoisting and that the strong_release is not hoisted above the load.
+
+// CHECK-LABEL: sil @$s4test6testit1sSiAA1SV_tF
+// CHECK:         [[X:%[0-9]+]] = apply
+// CHECK:         [[R:%[0-9]+]] = load
+// CHECK:         strong_release [[X]]
+// CHECK:         return [[R]]
+// CHECK:       } // end sil function '$s4test6testit1sSiAA1SV_tF'
+public func testit(s: S) -> Int {
+  let x = createX(s: s)
+  return x.s.i
+}
+