LifetimeDependenceScopeFixup: handle unsafe addressors

Handle unsafe addressors just like projections of stored properties rather than
as separate variable accesses.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -638,12 +638,34 @@ struct VariableIntroducerUseDefWalker : LifetimeDependenceUseDefWalker {
 
   mutating func walkUp(address: Value) -> WalkResult {
     if let beginAccess = address.definingInstruction as? BeginAccessInst {
+      // Treat calls to unsafe[Mutable]Address like a projection of 'self' rather than a separate variable access.
+      if let addressorSelf = beginAccess.unsafeAddressorSelf {
+        return walkUp(valueOrAddress: addressorSelf)
+      }
       return introducer(beginAccess, nil)
     }
     return walkUpDefault(address: address)
   }
 }
 
+private extension BeginAccessInst {
+  // Recognize an access scope for a unsafe addressor:
+  // %adr = pointer_to_address
+  // %md = mark_dependence %adr
+  // begin_access [unsafe] %md
+  var unsafeAddressorSelf: Value? {
+    guard isUnsafe else {
+      return nil
+    }
+    let accessBaseAndScopes = address.accessBaseWithScopes
+    guard case .pointer = accessBaseAndScopes.base,
+          case let .dependence(markDep) = accessBaseAndScopes.scopes.first else {
+      return nil
+    }
+    return markDep.base
+  }
+}
+
 /// Walk up the lifetime dependence chain.
 ///
 /// This finds the introducers of a dependence chain. which represent the value's "inherited" dependencies. This stops

test/SILOptimizer/lifetime_dependence/semantics.swift

@@ -74,6 +74,34 @@ extension Array {
   }
 }
 
+struct Inner {
+  var p: UnsafePointer<Int>
+
+  @lifetime(borrow self)
+  borrowing func span() -> Span<Int> {
+    Span(base: p, count: 1)
+  }
+}
+
+struct Outer {
+  let inner: Inner
+  let fakePointer: UnsafePointer<Inner>
+
+  var innerAddress: Inner {
+    unsafeAddress {
+      fakePointer
+    }
+  }
+  /* TODO: rdar://137608270 Add Builtin.addressof() support for @addressable arguments
+  @addressableSelf
+  var innerAddress: Inner {
+    unsafeAddress {
+      Builtin.addressof(inner)
+    }
+  }
+  */
+}
+
 func parse(_ span: Span<Int>) {}
 
 // =============================================================================
@@ -172,3 +200,17 @@ func testTrivialScope<T>(a: Array<T>) -> Span<T> {
   // expected-note  @-3{{it depends on the lifetime of variable 'p'}}
   // expected-note  @-3{{this use causes the lifetime-dependent value to escape}}
 }
+
+// =============================================================================
+// Scoped dependence on property access
+// =============================================================================
+
+@lifetime(borrow outer)
+func testBorrowComponent(outer: Outer) -> Span<Int> {
+  outer.inner.span()
+}
+
+@lifetime(borrow outer)
+func testBorrowAddressComponent(outer: Outer) -> Span<Int> {
+  outer.innerAddress.span()
+}