LifetimeDependenceDiagnostics support for inout reassignment.

This relies on parameter dependence targets.

i.e. dependsOn in parameter position instead of result position.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -131,6 +131,22 @@ private struct DiagnoseDependence {
     reportEscaping(operand: operand)
   }
 
+  func checkInoutResult(argument inoutArg: FunctionArgument, result operand: Operand) -> WalkResult {
+    // Check that the parameter dependence for this inout argument is the same as the current dependence scope.
+    if let sourceArg = dependence.scope.parentValue as? FunctionArgument {
+      // If the inout result is also the inout source, then it's always ok.
+      if inoutArg == sourceArg {
+        return .continueWalk
+      }
+      if function.argumentConventions.getDependence(target: inoutArg.index, source: sourceArg.index) != nil {
+        // The inout result depends on a lifetime that is inherited or borrowed in the caller.
+        return .continueWalk
+      }
+    }
+    reportEscaping(operand: operand)
+    return .abortWalk
+  }
+
   func checkFunctionResult(operand: Operand) -> WalkResult {
 
     if function.hasUnsafeNonEscapableResult {
@@ -151,7 +167,7 @@ private struct DiagnoseDependence {
     if dependence.isUnsafeApplyResult, function.hasResultDependence {
       return .continueWalk
     }
-    // Check that the argument dependence for this result is the same
+    // Check that the parameter dependence for this result is the same
     // as the current dependence scope.
     if let arg = dependence.scope.parentValue as? FunctionArgument,
        function.argumentConventions[resultDependsOn: arg.index] != nil {
@@ -363,12 +379,16 @@ extension DiagnoseDependenceWalker : LifetimeDependenceDefUseWalker {
     return .abortWalk
   }
 
+  mutating func inoutDependence(argument: FunctionArgument, on operand: Operand) -> WalkResult {
+    return diagnostics.checkInoutResult(argument: argument, result: operand)
+  }
+
   mutating func returnedDependence(result: Operand) -> WalkResult {
     return diagnostics.checkFunctionResult(operand: result)
   }
 
   mutating func returnedDependence(address: FunctionArgument,
-                                   using operand: Operand) -> WalkResult {
+                                   on operand: Operand) -> WalkResult {
     return diagnostics.checkFunctionResult(operand: operand)
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -234,13 +234,18 @@ private struct LifetimeDependenceScopeFixupWalker : LifetimeDependenceDefUseWalk
     return .continueWalk
   }
 
+  mutating func inoutDependence(argument: FunctionArgument, on operand: Operand) -> WalkResult {
+    dependsOnCaller = true
+    return visitor(operand)
+  }
+
   mutating func returnedDependence(result operand: Operand) -> WalkResult {
     dependsOnCaller = true
     return visitor(operand)
   }
 
   mutating func returnedDependence(address: FunctionArgument,
-                                   using operand: Operand) -> WalkResult {
+                                   on operand: Operand) -> WalkResult {
     dependsOnCaller = true
     return visitor(operand)
   }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -348,7 +348,7 @@ extension LifetimeDependence.Scope {
       case let .argument(arg):
         if arg.convention.isIndirectIn {
           self = .initialized(initialAddress: arg, initializingStore: nil)
-        } else if arg.convention.isIndirectOut {
+        } else if arg.convention.isIndirectOut || arg.convention.isInout {
           // TODO: verify that @out values are never reassigned.
           self = .caller(arg)
         } else {
@@ -772,8 +772,9 @@ extension LifetimeDependenceUseDefWalker {
 ///   leafUse(of: Operand) -> WalkResult
 ///   deadValue(_ value: Value, using operand: Operand?) -> WalkResult
 ///   escapingDependence(on operand: Operand) -> WalkResult
+///   inoutDependence(argument: FunctionArgument, on: Operand) -> WalkResult
 ///   returnedDependence(result: Operand) -> WalkResult
-///   returnedDependence(address: FunctionArgument, using: Operand) -> WalkResult
+///   returnedDependence(address: FunctionArgument, on: Operand) -> WalkResult
 ///   yieldedDependence(result: Operand) -> WalkResult
 /// Start walking:
 ///   walkDown(root: Value)
@@ -791,9 +792,13 @@ protocol LifetimeDependenceDefUseWalker : ForwardingDefUseWalker,
 
   mutating func escapingDependence(on operand: Operand) -> WalkResult
 
+  // Assignment to an inout argument. This does not include the indirect out result, which is considered a return
+  // value.
+  mutating func inoutDependence(argument: FunctionArgument, on: Operand) -> WalkResult
+
   mutating func returnedDependence(result: Operand) -> WalkResult
 
-  mutating func returnedDependence(address: FunctionArgument, using: Operand) -> WalkResult
+  mutating func returnedDependence(address: FunctionArgument, on: Operand) -> WalkResult
 
   mutating func yieldedDependence(result: Operand) -> WalkResult
 }
@@ -1072,7 +1077,7 @@ extension LifetimeDependenceDefUseWalker {
       if arg.convention.isIndirectIn || arg.convention.isInout {
         allocation = arg
       } else if arg.convention.isIndirectOut, !arg.isEscapable {
-        return returnedDependence(address: arg, using: operand)
+        return returnedDependence(address: arg, on: operand)
       }
       break
     case .global, .class, .tail, .yield, .storeBorrow, .pointer, .unidentified:
@@ -1140,7 +1145,7 @@ extension LifetimeDependenceDefUseWalker {
     case .outgoingArgument:
       let arg = allocation as! FunctionArgument
       assert(arg.type.isAddress, "returned local must be allocated with an indirect argument")
-      return returnedDependence(address: arg, using: initialValue)
+      return inoutDependence(argument: arg, on: initialValue)
     case .incomingArgument:
       fatalError("Incoming arguments are never reachable")
     }
@@ -1253,13 +1258,18 @@ private struct LifetimeDependenceUsePrinter : LifetimeDependenceDefUseWalker {
     return .continueWalk
   }
 
+  mutating func inoutDependence(argument: FunctionArgument, on operand: Operand) -> WalkResult {
+    print("Out use: \(operand) in: \(argument)")
+    return .continueWalk
+  }
+
   mutating func returnedDependence(result: Operand) -> WalkResult {
     print("Returned use: \(result)")
     return .continueWalk
   }
 
   mutating func returnedDependence(address: FunctionArgument,
-                                   using operand: Operand) -> WalkResult {
+                                   on operand: Operand) -> WalkResult {
     print("Returned use: \(operand) in: \(address)")
     return .continueWalk
   }

test/SILOptimizer/lifetime_dependence/inout.swift

@@ -0,0 +1,39 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -o /dev/null \
+// RUN:   -verify \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -enable-experimental-feature NonescapableTypes
+
+// REQUIRES: asserts
+// REQUIRES: swift_in_compiler
+
+struct Span<T>: ~Escapable {
+  private var base: UnsafePointer<T>
+  private var count: Int
+
+  @_unsafeNonescapableResult
+  init(base: UnsafePointer<T>, count: Int) {
+    self.base = base
+    self.count = count
+  }
+
+  init<S>(base: UnsafePointer<T>, count: Int, generic: borrowing S) -> dependsOn(generic) Self {
+    self.base = base
+    self.count = count
+  }
+}
+
+extension Array {
+  // TODO: comment out dependsOn(scoped)
+  borrowing func span() -> /* dependsOn(scoped self) */ Span<Element> {
+    /* not the real implementation */
+    let p = self.withUnsafeBufferPointer { $0.baseAddress! }
+    return Span(base: p, count: 1)
+  }
+}
+
+// Reassign an inout argument to a value that depends on the lifetime of another argument.
+func mayReassign(span: dependsOn(a) inout Span<Int>, to a: Array<Int>) {
+  span = a.span()
+}