LifetimeDependenceDefUseWalker: use LocalVariableReachableUses.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -317,13 +317,14 @@ private struct LifetimeVariable {
 private struct DiagnoseDependenceWalker {
   let context: Context
   var diagnostics: DiagnoseDependence
+  let localReachabilityCache = LocalVariableReachabilityCache()
   var visitedValues: ValueSet
 
   var function: Function { diagnostics.function }
 
   init(_ diagnostics: DiagnoseDependence, _ context: Context) {
-    self.diagnostics = diagnostics
     self.context = context
+    self.diagnostics = diagnostics
     self.visitedValues = ValueSet(context)
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -33,47 +33,66 @@ let lifetimeDependenceScopeFixupPass = FunctionPass(
 { (function: Function, context: FunctionPassContext) in
   log(" --- Scope fixup for lifetime dependence in \(function.name)")
 
+  let localReachabilityCache = LocalVariableReachabilityCache()
+
   for instruction in function.instructions {
     guard let markDep = instruction as? MarkDependenceInst else {
       continue
     }
     guard let lifetimeDep = LifetimeDependence(markDep, context) else {
       continue
     }
-    if let arg = extendAccessScopes(dependence: lifetimeDep, context) {
+    if let arg = extendAccessScopes(dependence: lifetimeDep, localReachabilityCache, context) {
       markDep.baseOperand.set(to: arg, context)
     }
   }
 }
 
 /// Extend all access scopes that enclose `dependence`. If dependence is on an access scope in the caller, then return
 /// the function argument that represents the dependence scope.
-private func extendAccessScopes(dependence: LifetimeDependence, _ context: FunctionPassContext) -> FunctionArgument? {
+private func extendAccessScopes(dependence: LifetimeDependence,
+                                _ localReachabilityCache: LocalVariableReachabilityCache,
+                                _ context: FunctionPassContext) -> FunctionArgument? {
   log("Scope fixup for lifetime dependent instructions: \(dependence)")
 
-  guard case .access(let bai) = dependence.scope else {
+  guard case .access(let beginAccess) = dependence.scope else {
+    return nil
+  }
+  let function = beginAccess.parentFunction
+
+  // Get the range accessBase lifetime. The accessRange cannot exceed this without producing invalid SIL.
+  guard var ownershipRange = AddressOwnershipLiveRange.compute(for: beginAccess.address, at: beginAccess,
+                                                               localReachabilityCache, context) else {
     return nil
   }
-  let function = bai.parentFunction
-  var range = InstructionRange(begin: bai, context)
-  var walker = LifetimeDependenceScopeFixupWalker(function, context) {
-    range.insert($0.instruction)
+  defer { ownershipRange.deinitialize() }
+
+  var accessRange = InstructionRange(begin: beginAccess, context)
+  defer {accessRange.deinitialize()}
+
+  var walker = LifetimeDependenceScopeFixupWalker(function, localReachabilityCache, context) {
+    // Do not extend the accessRange past the ownershipRange.
+    let dependentInst = $0.instruction
+    if ownershipRange.coversUse(dependentInst) {
+      accessRange.insert(dependentInst)
+    }
     return .continueWalk
   }
   defer {walker.deinitialize()}
+
   _ = walker.walkDown(root: dependence.dependentValue)
-  defer {range.deinitialize()}
 
-  // Lifetime dependenent uses may no be dominated by the access. The dependent value may be used by a phi or stored
-  // into a memory location. The access may be conditional relative to such uses. If this is the case, then the
-  // instruction range must include the function entry.
+  // Lifetime dependenent uses may not be dominated by the access. The dependent value may be used by a phi or stored
+  // into a memory location. The access may be conditional relative to such uses. If any use was not dominated, then
+  // `accessRange` will include the function entry.
   let firstInst = function.entryBlock.instructions.first!
-  if firstInst != bai, range.contains(firstInst) {
+  if firstInst != beginAccess, accessRange.contains(firstInst) {
     return nil
   }
-  if let arg = extendAccessScope(beginAccess: bai, range: &range, context) {
+  if let arg = extendAccessScope(beginAccess: beginAccess, range: &accessRange, context) {
     // If the dependent value is returned, then return the FunctionArgument that it depends on.
-    return walker.dependsOnCaller ? arg : nil
+    assert(walker.dependsOnCaller)
+    return arg
   }
   return nil
 }
@@ -126,9 +145,20 @@ private func extendAccessScope(beginAccess: BeginAccessInst, range: inout Instru
   assert(!range.ends.isEmpty)
 
   // Create new end_access at the end of extended uses
+  var dependsOnCaller = false
   for end in range.ends {
-    let endBuilder = Builder(after: end, context)
-    endBuilder.createEndAccess(beginAccess: beginAccess)
+    let location = end.location.autoGenerated
+    if end is ReturnInst {
+      dependsOnCaller = true
+      let endAccess = Builder(before: end, location: location, context).createEndAccess(beginAccess: beginAccess)
+      range.insert(endAccess)
+      continue
+    }
+    Builder.insert(after: end, location: location, context) {
+      let endAccess = $0.createEndAccess(beginAccess: beginAccess)
+      // This scope should be nested in any outer scopes.
+      range.insert(endAccess)
+    }
   }
   // Delete original end_access instructions
   for endAccess in endAcceses {
@@ -139,7 +169,7 @@ private func extendAccessScope(beginAccess: BeginAccessInst, range: inout Instru
   case let .scope(enclosingBeginAccess):
     return extendAccessScope(beginAccess: enclosingBeginAccess, range: &range, context)
   case let .base(accessBase):
-    if case let .argument(arg) = accessBase {
+    if case let .argument(arg) = accessBase, dependsOnCaller {
       return arg
     }
     return nil
@@ -150,14 +180,18 @@ private struct LifetimeDependenceScopeFixupWalker : LifetimeDependenceDefUseWalk
   let function: Function
   let context: Context
   let visitor: (Operand) -> WalkResult
+  let localReachabilityCache: LocalVariableReachabilityCache
   var visitedValues: ValueSet
+
   /// Set to true if the dependence is returned from the current function.
   var dependsOnCaller = false
 
-  init(_ function: Function, _ context: Context, visitor: @escaping (Operand) -> WalkResult) {
+  init(_ function: Function, _ localReachabilityCache: LocalVariableReachabilityCache, _ context: Context,
+       visitor: @escaping (Operand) -> WalkResult) {
     self.function = function
     self.context = context
     self.visitor = visitor
+    self.localReachabilityCache = localReachabilityCache
     self.visitedValues = ValueSet(context)
   }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -54,6 +54,14 @@
 
 import SIL
 
+private let verbose = true
+
+private func log(_ message: @autoclosure () -> String) {
+  if verbose {
+    print("### \(message())")
+  }
+}
+
 /// Walk up the value dependence chain to find the best-effort
 /// variable declaration. Typically called while diagnosing an error.
 ///
@@ -351,7 +359,8 @@ extension LifetimeDependence.Scope {
       case let .argument(arg):
         if arg.convention.isIndirectIn {
           self = .initialized(initialAddress: arg, initializingStore: nil)
-        } else if arg.convention.isInout {
+        } else if arg.convention.isIndirectOut {
+          // TODO: verify that @out values are never reassigned.
           self = .caller(arg)
         } else {
           // Note: we do not expect arg.convention.isInout because
@@ -788,18 +797,26 @@ protocol LifetimeDependenceDefUseWalker : ForwardingDefUseWalker,
                                           AddressUseVisitor {
   var function: Function { get }
 
+  /// Dependence tracking through local variables.
+  var localReachabilityCache: LocalVariableReachabilityCache { get }
+
   mutating func leafUse(of operand: Operand) -> WalkResult
 
   mutating func escapingDependence(on operand: Operand) -> WalkResult
 
   mutating func returnedDependence(result: Operand) -> WalkResult
 
-  mutating func returnedDependence(address: FunctionArgument, using: Operand)
-    -> WalkResult
+  mutating func returnedDependence(address: FunctionArgument, using: Operand) -> WalkResult
 
   mutating func yieldedDependence(result: Operand) -> WalkResult
 }
 
+extension LifetimeDependenceDefUseWalker {
+  // Use a distict context name to avoid rdar://123424566 (Unable to open existential)
+  var walkerContext: Context { context }
+}
+
+// Start a forward walk.
 extension LifetimeDependenceDefUseWalker {
   mutating func walkDown(root: Value) -> WalkResult {
     if root.type.isAddress {
@@ -1062,42 +1079,91 @@ extension LifetimeDependenceDefUseWalker {
                                         into address: Value) -> WalkResult {
     assert(address.type.isAddress)
 
-    // TODO_reachingdef: Call reaching-def analysis on the local
-    // variable that defines `address` (the analysis can be limited to
-    // this store). Then find all reachable uses from this store.
+    var allocation: Value?
     switch address.accessBase {
     case let .box(projectBox):
-      if let allocBox = projectBox.box as? AllocBoxInst {
-        if !needWalk(for: allocBox) {
-          return .continueWalk
-        }
-        return walkDownUses(of: allocBox, using: operand)
-      }
-      break
+      allocation = projectBox.box.referenceRoot
     case let .stack(allocStack):
-      if !needWalk(for: allocStack) {
-        return .continueWalk
-      }
-      return walkDownAddressUses(of: allocStack)
+      allocation = allocStack
     case let .argument(arg):
-      if arg.convention.isIndirectIn {
-        if !needWalk(for: arg) {
-          return .continueWalk
-        }
-        return walkDownAddressUses(of: arg)
-      }
-      if arg.convention.isIndirectOut, !arg.type.isEscapable {
+      if arg.convention.isIndirectIn || arg.convention.isInout {
+        allocation = arg
+      } else if arg.convention.isIndirectOut, !arg.type.isEscapable {
         return returnedDependence(address: arg, using: operand)
       }
       break
     case .global, .class, .tail, .yield, .pointer, .unidentified:
       break
     }
+    if let allocation = allocation {
+      if !allocation.type.objectType.isEscapable {
+        return visitLocalStore(allocation: allocation, storedOperand: operand, storeAddress: address)
+      }
+    }
+    if address.type.objectType.isEscapable {
+      return .continueWalk
+    }
     return escapingDependence(on: operand)
   }
 
-  private mutating func visitAppliedUse(of operand: Operand,
-                                        by apply: FullApplySite) -> WalkResult {
+  private mutating func visitLocalStore(allocation: Value, storedOperand: Operand, storeAddress: Value) -> WalkResult {
+    guard let localReachability = localReachabilityCache.reachability(for: allocation, walkerContext) else {
+      return escapingDependence(on: storedOperand)
+    }
+    var accessStack = Stack<LocalVariableAccess>(walkerContext)
+    defer { accessStack.deinitialize() }
+
+    // Get the local variable access that encloses this store.
+    var storeAccess = storedOperand.instruction
+    if case let .scope(beginAccess) = storeAddress.enclosingAccessScope {
+      storeAccess = beginAccess
+    }
+    if !localReachability.gatherAllReachableUses(of: storeAccess, in: &accessStack) {
+      return escapingDependence(on: storedOperand)
+    }
+    for localAccess in accessStack {
+      if visitLocalAccess(allocation: allocation, localAccess: localAccess, initialValue: storedOperand) == .abortWalk {
+        return .abortWalk
+      }
+    }
+    return .continueWalk
+  }
+
+  private mutating func visitLocalAccess(allocation: Value, localAccess: LocalVariableAccess, initialValue: Operand)
+    -> WalkResult {
+    switch localAccess.kind {
+    case .beginAccess:
+      return scopedAddressUse(of: localAccess.operand!)
+    case .load:
+      switch localAccess.instruction! {
+      case let load as LoadInst:
+        return loadedAddressUse(of: localAccess.operand!, into: load)
+      case let load as LoadBorrowInst:
+        return loadedAddressUse(of: localAccess.operand!, into: load)
+      case let copyAddr as SourceDestAddrInstruction:
+        return loadedAddressUse(of: localAccess.operand!, into: copyAddr.destinationOperand)
+      default:
+        return .abortWalk
+      }
+    case .store:
+      let si = localAccess.operand!.instruction as! StoringInstruction
+      assert(si.sourceOperand == initialValue, "the only reachable store should be the current assignment")
+    case .apply:
+      return visitAppliedUse(of: localAccess.operand!, by: localAccess.instruction as! FullApplySite)
+    case .escape:
+      log("Local variable: \(allocation)\n    escapes at: \(localAccess.instruction!)")
+      return escapingDependence(on: localAccess.operand!)
+    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)
+    case .incomingArgument:
+      fatalError("Incoming arguments are never reachable")
+    }
+    return .continueWalk
+  }
+
+  private mutating func visitAppliedUse(of operand: Operand, by apply: FullApplySite) -> WalkResult {
     if let conv = apply.convention(of: operand), conv.isIndirectOut {
       return leafUse(of: operand)
     }
@@ -1169,9 +1235,9 @@ let lifetimeDependenceRootTest = FunctionTest("lifetime_dependence_root") {
 
 private struct LifetimeDependenceUsePrinter : LifetimeDependenceDefUseWalker {
   let context: Context
+  let function: Function
+  let localReachabilityCache = LocalVariableReachabilityCache()
   var visitedValues: ValueSet
-
-  var function: Function
 
   init(function: Function, _ context: Context) {
     self.context = context