LifetimeDependenceScopeFixup: handle nested access

After extending access scopes, rewrite the mark_depenendence to be on
the outermost scope.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -37,18 +37,26 @@ let lifetimeDependenceScopeFixupPass = FunctionPass(
     guard let markDep = instruction as? MarkDependenceInst else {
       continue
     }
-    if let lifetimeDep = LifetimeDependence(markDep, context) {
-      fixup(dependence: lifetimeDep, context)
+    guard let lifetimeDep = LifetimeDependence(markDep, context) else {
+      continue
+    }
+    guard let beginAccess = extendAccessScopes(dependence: lifetimeDep,
+                                               context) else {
+      continue
     }
+    extendDependenceBase(dependenceInstruction: markDep,
+                         beginAccess: beginAccess, context)
   }
 }
 
-private func fixup(dependence: LifetimeDependence,
-  _ context: FunctionPassContext) {
+// Extend all access scopes that enclose `dependence` and return the
+// outermost access.
+private func extendAccessScopes(dependence: LifetimeDependence,
+  _ context: FunctionPassContext) -> BeginAccessInst? {
   log("Scope fixup for lifetime dependent instructions: \(dependence)")
 
   guard case .access(let bai) = dependence.scope else {
-    return
+    return nil
   }
   var range = InstructionRange(begin: bai, context)
   var walker = LifetimeDependenceScopeFixupWalker(bai.parentFunction, context) {
@@ -89,6 +97,29 @@ private func fixup(dependence: LifetimeDependence,
     }
     beginAccess = enclosingBeginAccess
   }
+  return beginAccess
+}
+
+/// Rewrite the mark_dependence to depend on the outermost access
+/// scope now that the nested scopes have all been extended.
+private func extendDependenceBase(dependenceInstruction: MarkDependenceInst,
+                                  beginAccess: BeginAccessInst,
+                                  _ context: FunctionPassContext) {
+  guard case let .base(accessBase) = beginAccess.address.enclosingAccessScope
+  else {
+    fatalError("this must be the outer-most access scope")
+  }
+  // If the outermost access is in the caller, then depende on the
+  // address argument.
+  let baseAddress: Value
+  switch accessBase {
+  case let .argument(arg):
+    assert(arg.type.isAddress)
+    baseAddress = arg
+  default:
+    baseAddress = beginAccess
+  }
+  dependenceInstruction.baseOperand.set(to: baseAddress, context)
 }
 
 private struct LifetimeDependenceScopeFixupWalker : LifetimeDependenceDefUseWalker {

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -233,6 +233,9 @@ extension LifetimeDependence {
 
   /// Construct LifetimeDependence from mark_dependence [unresolved]
   ///
+  /// For any LifetimeDependence constructed from a mark_dependence,
+  /// its `dependentValue` will be the result of the mark_dependence.
+  ///
   /// TODO: Add SIL verification that all mark_depedence [unresolved]
   /// have a valid LifetimeDependence.
   init?(_ markDep: MarkDependenceInst, _ context: some Context) {

test/SILOptimizer/lifetime_dependence_borrow.swift

@@ -42,3 +42,8 @@ func bv_get_borrow(container: borrowing NC) -> _borrow(container) BV {
 func bv_get_copy(container: borrowing NC) -> _copy(container) BV {
   return container.getBV()
 }
+
+// Recognize nested accesses as part of the same dependence scope.
+func bv_get_mutate(container: inout NC) -> _mutate(container) BV {
+  container.getBV()
+}

test/SILOptimizer/lifetime_dependence_inherit.swift

@@ -39,8 +39,6 @@ struct NE {
 }
 
 // Test lifetime inheritance through chained consumes.
-//
-// This requires an inherit_lifetime marker on the argument.
 func bv_derive(bv: consuming BV) -> _consume(bv) BV {
   bv.derive()
 }

test/SILOptimizer/lifetime_dependence_scope.swift

@@ -0,0 +1,48 @@
+// RUN: %target-swift-frontend %s -emit-sil \
+// RUN:   -sil-verify-all \
+// RUN:   -module-name test \
+// RUN:   -disable-experimental-parser-round-trip \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -Xllvm -enable-lifetime-dependence-diagnostics \
+// RUN:   2>&1 | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+// Test LifetimeDependenceScopeFixup.
+
+@_nonescapable
+struct BV {
+  let p: UnsafeRawPointer
+  let c: Int
+
+  public var isEmpty: Bool { c == 0 }
+
+  @_unsafeNonescapableResult
+  init(_ p: UnsafeRawPointer, _ c: Int) {
+    self.p = p
+    self.c = c
+  }
+}
+
+struct NC : ~Copyable {
+  let p: UnsafeRawPointer
+  let c: Int
+
+  // Requires a borrow.
+  borrowing func getBV() -> _borrow(self) BV {
+    BV(p, c)
+  }
+}
+
+// Rewrite the mark_dependence to depende on the incoming argument rather than the nested access.
+//
+// CHECK-LABEL: sil hidden @$s4test13bv_get_mutate9containerAA2BVVAA2NCVz_tF : $@convention(thin) (@inout NC) -> _scope(1) @owned BV {
+// CHECK: bb0(%0 : $*NC):
+// CHECK:   [[A:%.*]] = begin_access [read] [static] %0 : $*NC
+// CHECK:   [[L:%.*]] = load [[A]] : $*NC
+// CHECK:   [[R:%.*]] = apply %{{.*}}([[L]]) : $@convention(method) (@guaranteed NC) -> _scope(0) @owned BV
+// CHECK:   [[M:%.*]] = mark_dependence [nonescaping] [[R]] : $BV on %0 : $*NC
+// CHECK-LABEL: } // end sil function '$s4test13bv_get_mutate9containerAA2BVVAA2NCVz_tF'
+func bv_get_mutate(container: inout NC) -> _mutate(container) BV {
+  container.getBV()
+}

test/SILOptimizer/lifetime_dependence_todo.swift

@@ -11,18 +11,11 @@
 // REQUIRES: disabled
 
 
-// =============================================================================
-// Diagnostics that should not fail.
-
-// Recognize nested accesses as part of the same dependence scope.
-func bv_get_mutate(container: inout NC) -> _mutate(container) BV {
-  container.getBV()
-}
-
 // =============================================================================
 // Diagnostics that should fail.
 
-// Test that an unsafe dependence requires Builtin.lifetime_dependence.
+// @_unsafeResultDependsOn: Test that an unsafe dependence requires
+// Builtin.lifetime_dependence.
 //
 func bv_derive_local(bv: consuming BV) -> _consume(bv) BV {
   let bv2 = BV(bv.p, bv.i)