AccessUtils: allow mark_deps to be tracked by the EnclosingScope.

This encourages AccessPathWalker clients to handle enclosing mark_deps. In
some cases, it is necessary. The accessBaseWithScopes API now provides both
nested begin_access and mark_dependence.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -603,7 +603,7 @@ private enum ImmutableScope {
 
   init?(for basedAddress: Value, _ context: FunctionPassContext) {
     switch basedAddress.enclosingAccessScope {
-    case .scope(let beginAccess):
+    case .access(let beginAccess):
       if beginAccess.isUnsafe {
         return nil
       }
@@ -652,6 +652,9 @@ private enum ImmutableScope {
           return nil
         }
       }
+      case .dependence(let markDep):
+        // ignore mark_dependence for the purpose of alias analysis.
+        self.init(for: markDep.value, context)
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -274,7 +274,8 @@ private extension LifetimeDependence.Scope {
     case let .access(beginAccess):
       // Finding the access base also finds all intermediate nested scopes; there is no need to recursively call
       // gatherExtensions().
-      let (accessBase, nestedAccesses) = beginAccess.accessBaseWithScopes
+      let accessBaseAndScopes = beginAccess.accessBaseWithScopes
+      let accessBase = accessBaseAndScopes.base
       let ownerAddress: Value
       var dependsOnArg: FunctionArgument? = nil
       switch accessBase {
@@ -287,13 +288,18 @@ private extension LifetimeDependence.Scope {
            .pointer, .index:
         ownerAddress = accessBase.address!
       }
-      assert(!nestedAccesses.isEmpty)
-      for nestedAccess in nestedAccesses {
-        innerScopes.push(.access(nestedAccess))
+      assert(!accessBaseAndScopes.scopes.isEmpty)
+      for nestedScope in accessBaseAndScopes.scopes {
+        switch nestedScope {
+        case let .access(beginAccess):
+          innerScopes.push(.access(beginAccess))
+        case .dependence, .base:
+          // ignore recursive mark_dependence base for the purpose of extending scopes. This pass will extend the base
+          // of that mark_dependence (if it is unresolved) later as a separate LifetimeDependence.Scope.
+          break
+        }
       }
-      // This is the outermost scope. We only see nested access scopes after inlining.
-      //
-      // TODO: could we have a nested access within an yielded inout address?
+      // TODO: could we have a nested access within an yielded inout address prior to inlining?
       return SingleInlineArray(element: ScopeExtension(owner: ownerAddress, nestedScopes: innerScopes,
                                                        dependsOnArg: dependsOnArg))
     case let .borrowed(beginBorrow):

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -117,7 +117,7 @@ struct LifetimeDependence : CustomStringConvertible {
     case yield(Value)
     /// An owned value whose OSSA lifetime encloses nonescapable values, or a trivial variable introduced by move_value.
     case owned(Value)
-    /// An borrowed value whose OSSA lifetime encloses nonescapable values, or a trivial variable introduced by
+    /// A borrowed value whose OSSA lifetime encloses nonescapable values, or a trivial variable introduced by
     /// begin_borrow.
     case borrowed(BeginBorrowValue)
     /// Singly-initialized addressable storage (likely for an
@@ -313,10 +313,15 @@ extension LifetimeDependence.Scope {
 
   private init(address: Value, _ context: some Context) {
     switch address.enclosingAccessScope {
-    case let .scope(access):
+    case let .access(access):
       self = .access(access)
     case let .base(accessBase):
       self = Self(accessBase: accessBase, address: address, context)
+    case let .dependence(markDep):
+      // The current dependence only represents the forwarded address. If the mark_dependence instruction encoutered
+      // here is [unresolved], then a separate LifetimeDependence.Scope will be created for it, and if it is [escaping],
+      // then it is ignored for the purpose of lifetime dependence.
+      self.init(address: markDep.value, context)
     }
   }
 
@@ -1151,7 +1156,7 @@ extension LifetimeDependenceDefUseWalker {
 
     // Get the local variable access that encloses this store.
     var storeAccess = storedOperand.instruction
-    if case let .scope(beginAccess) = storeAddress.enclosingAccessScope {
+    if case let .access(beginAccess) = storeAddress.enclosingAccessScope {
       storeAccess = beginAccess
     }
     if !localReachability.gatherAllReachableUses(of: storeAccess, in: &accessStack) {

SwiftCompilerSources/Sources/SIL/Utilities/AccessUtils.swift

@@ -477,7 +477,7 @@ private extension PointerToAddressInst {
   }
 }
 
-/// The `EnclosingScope` of an access is the innermost `begin_access`
+/// The `EnclosingAccessScope` of an access is the innermost `begin_access`
 /// instruction that checks for exclusivity of the access.
 /// If there is no `begin_access` instruction found, then the scope is
 /// the base itself.
@@ -497,13 +497,29 @@ private extension PointerToAddressInst {
 /// %l3 = load %a3 : $*Int64
 /// end_access %a3 : $*Int64
 /// ```
-public enum EnclosingScope {
-  case scope(BeginAccessInst)
+public enum EnclosingAccessScope {
+  case access(BeginAccessInst)
   case base(AccessBase)
+  case dependence(MarkDependenceInst)
+}
+
+// An AccessBase with the nested enclosing scopes that contain the original address in bottom-up order.
+public struct AccessBaseAndScopes {
+  public let base: AccessBase
+  public let scopes: SingleInlineArray<EnclosingAccessScope>
+
+  public var innermostAccess: BeginAccessInst? {
+    for scope in scopes {
+      if case let .access(beginAccess) = scope {
+        return beginAccess
+      }
+    }
+    return nil
+  }
 }
 
 private struct EnclosingAccessWalker : AddressUseDefWalker {
-  var enclosingScope: EnclosingScope?
+  var enclosingScope: EnclosingAccessScope?
 
   mutating func walk(startAt address: Value, initialPath: UnusedWalkingPath = UnusedWalkingPath()) {
     if walkUp(address: address, path: UnusedWalkingPath()) == .abortWalk {
@@ -522,19 +538,24 @@ private struct EnclosingAccessWalker : AddressUseDefWalker {
   }
 
   mutating func walkUp(address: Value, path: UnusedWalkingPath) -> WalkResult {
-    if let ba = address as? BeginAccessInst {
-      enclosingScope = .scope(ba)
+    switch address {
+    case let ba as BeginAccessInst:
+      enclosingScope = .access(ba)
       return .continueWalk
+    case let md as MarkDependenceInst:
+      enclosingScope = .dependence(md)
+      return .continueWalk
+    default:
+      return walkUpDefault(address: address, path: path)
     }
-    return walkUpDefault(address: address, path: path)
   }
 }
 
 private struct AccessPathWalker : AddressUseDefWalker {
   var result = AccessPath.unidentified()
 
-  // List of nested BeginAccessInst: inside-out order.
-  var foundBeginAccesses = SingleInlineArray<BeginAccessInst>()
+  // List of nested BeginAccessInst & MarkDependenceInst: inside-out order.
+  var foundEnclosingScopes = SingleInlineArray<EnclosingAccessScope>()
 
   let enforceConstantProjectionPath: Bool
 
@@ -602,7 +623,9 @@ private struct AccessPathWalker : AddressUseDefWalker {
       // projection. Bail out
       return .abortWalk
     } else if let ba = address as? BeginAccessInst {
-      foundBeginAccesses.push(ba)
+      foundEnclosingScopes.push(.access(ba))
+    } else if let md = address as? MarkDependenceInst {
+      foundEnclosingScopes.push(.dependence(md))
     }
     return walkUpDefault(address: address, path: path.with(indexAddr: false))
   }
@@ -655,20 +678,21 @@ extension Value {
   public var accessPathWithScope: (AccessPath, scope: BeginAccessInst?) {
     var walker = AccessPathWalker()
     walker.walk(startAt: self)
-    return (walker.result, walker.foundBeginAccesses.first)
+    let baseAndScopes = AccessBaseAndScopes(base: walker.result.base, scopes: walker.foundEnclosingScopes)
+    return (walker.result, baseAndScopes.innermostAccess)
   }
 
   /// Computes the enclosing access scope of this address value.
-  public var enclosingAccessScope: EnclosingScope {
+  public var enclosingAccessScope: EnclosingAccessScope {
     var walker = EnclosingAccessWalker()
     walker.walk(startAt: self)
     return walker.enclosingScope ?? .base(.unidentified)
   }
 
-  public var accessBaseWithScopes: (AccessBase, SingleInlineArray<BeginAccessInst>) {
+  public var accessBaseWithScopes: AccessBaseAndScopes {
     var walker = AccessPathWalker()
     walker.walk(startAt: self)
-    return (walker.result.base, walker.foundBeginAccesses)
+    return AccessBaseAndScopes(base: walker.result.base, scopes: walker.foundEnclosingScopes)
   }
 
   /// The root definition of a reference, obtained by skipping ownership forwarding and ownership transition.