Support mark_dependence_addr in SIL passes.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -253,7 +253,7 @@ struct AliasAnalysis {
     case let storeBorrow as StoreBorrowInst:
       return memLoc.mayAlias(with: storeBorrow.destination, self) ? .init(write: true) : .noEffects
 
-    case let mdi as MarkDependenceInst:
+    case let mdi as MarkDependenceInstruction:
       if mdi.base.type.isAddress && memLoc.mayAlias(with: mdi.base, self) {
         return .init(read: true)
       }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -123,7 +123,7 @@ private func analyze(dependence: LifetimeDependence, _ context: FunctionPassCont
   // Check each lifetime-dependent use via a def-use visitor
   var walker = DiagnoseDependenceWalker(diagnostics, context)
   defer { walker.deinitialize() }
-  let result = walker.walkDown(root: dependence.dependentValue)
+  let result = walker.walkDown(dependence: dependence)
   // The walk may abort without a diagnostic error.
   assert(!error || result == .abortWalk)
   return result == .continueWalk
@@ -354,7 +354,7 @@ private struct LifetimeVariable {
 }
 
 /// Walk up an address into which a dependent value has been stored. If any address in the use-def chain is a
-/// mark_dependence, follow the depenedence base rather than the forwarded value. If any of the dependence bases in
+/// mark_dependence, follow the dependence base rather than the forwarded value. If any of the dependence bases in
 /// within the current scope is with (either local checkInoutResult), then storing a value into that address is
 /// nonescaping.
 ///

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift

@@ -286,26 +286,21 @@ private func insertMarkDependencies(value: Value, initializer: Instruction?,
                                     _ context: FunctionPassContext) {
   var currentValue = value
   for base in bases {
-    let markDep = builder.createMarkDependence(
-      value: currentValue, base: base, kind: .Unresolved)
-
     if value.type.isAddress {
       // Address dependencies cannot be represented as SSA values, so it does not make sense to replace any uses of the
       // dependent address.
-      //
-      // TODO: insert a separate mark_dependence_addr instruction with no return value and do not update currentValue.
-    } else {
-      // TODO: implement non-inout parameter dependencies. This assumes that currentValue is the apply immediately
-      // preceeding the mark_dependence.
-      let uses = currentValue.uses.lazy.filter {
-        if $0.isScopeEndingUse {
-          return false
-        }
-        let inst = $0.instruction
-        return inst != markDep && inst != initializer && !(inst is Deallocation)
+      _ = builder.createMarkDependenceAddr(value: currentValue, base: base, kind: .Unresolved)
+      continue
+    }
+    let markDep = builder.createMarkDependence(value: currentValue, base: base, kind: .Unresolved)
+    let uses = currentValue.uses.lazy.filter {
+      if $0.isScopeEndingUse {
+        return false
       }
-      uses.replaceAll(with: markDep, context)
+      let inst = $0.instruction
+      return inst != markDep && inst != initializer && !(inst is Deallocation)
     }
+    uses.replaceAll(with: markDep, context)
     currentValue = markDep
   }
 }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -112,7 +112,7 @@ let lifetimeDependenceScopeFixupPass = FunctionPass(
   let localReachabilityCache = LocalVariableReachabilityCache()
 
   for instruction in function.instructions {
-    guard let markDep = instruction as? MarkDependenceInst else {
+    guard let markDep = instruction as? MarkDependenceInstruction else {
       continue
     }
     guard let innerLifetimeDep = LifetimeDependence(markDep, context) else {
@@ -129,46 +129,71 @@ let lifetimeDependenceScopeFixupPass = FunctionPass(
   }
 }
 
-private extension MarkDependenceInst {
+private extension MarkDependenceInstruction {
   /// Rewrite the mark_dependence base operand to ignore inner borrow scopes (begin_borrow, load_borrow).
   ///
   /// Note: this could be done as a general simplification, e.g. after inlining. But currently this is only relevant for
   /// diagnostics.
   func rewriteSkippingBorrow(scope: LifetimeDependence.Scope, _ context: FunctionPassContext) -> LifetimeDependence {
     guard let newScope = scope.ignoreBorrowScope(context) else {
-      return LifetimeDependence(scope: scope, dependentValue: self)
+      return LifetimeDependence(scope: scope, markDep: self)!
     }
     let newBase = newScope.parentValue
     if newBase != self.baseOperand.value {
       self.baseOperand.set(to: newBase, context)
     }
-    return LifetimeDependence(scope: newScope, dependentValue: self)
+    return LifetimeDependence(scope: newScope, markDep: self)!
   }
 
-  /// Rewrite the mark_dependence base operand, setting it to a function argument.
-  ///
-  /// To handle more than one function argument, new mark_dependence instructions will be chained.
-  /// This is called when the dependent value is returned by the function and the dependence base is in the caller.
   func redirectFunctionReturn(to args: SingleInlineArray<FunctionArgument>, _ context: FunctionPassContext) {
-    var updatedMarkDep: MarkDependenceInst?
+    var updatedMarkDep: MarkDependenceInstruction?
     for arg in args {
       guard let currentMarkDep = updatedMarkDep else {
         self.baseOperand.set(to: arg, context)
         updatedMarkDep = self
         continue
       }
-      let newMarkDep = Builder(after: currentMarkDep, location: currentMarkDep.location, context)
-        .createMarkDependence(value: currentMarkDep, base: arg, kind: .Unresolved)
-      let uses = currentMarkDep.uses.lazy.filter {
-        let inst = $0.instruction
-        return inst != newMarkDep
+      switch currentMarkDep {
+      case let mdi as MarkDependenceInst:
+        updatedMarkDep = mdi.redirectFunctionReturnForward(to: arg, input: mdi, context)
+      case let mdi as MarkDependenceAddrInst:
+        updatedMarkDep = mdi.redirectFunctionReturnAddress(to: arg, context)
+      default:
+        fatalError("unexpected MarkDependenceInstruction")
       }
-      uses.replaceAll(with: newMarkDep, context)
-      updatedMarkDep = newMarkDep
     }
   }
 }
 
+private extension MarkDependenceInst {
+  /// Rewrite the mark_dependence base operand, setting it to a function argument.
+  ///
+  /// This is called when the dependent value is returned by the function and the dependence base is in the caller.
+  func redirectFunctionReturnForward(to arg: FunctionArgument, input: MarkDependenceInst,
+    _ context: FunctionPassContext) -> MarkDependenceInst {
+    // To handle more than one function argument, new mark_dependence instructions will be chained.
+    let newMarkDep = Builder(after: input, location: input.location, context)
+      .createMarkDependence(value: input, base: arg, kind: .Unresolved)
+    let uses = input.uses.lazy.filter {
+      let inst = $0.instruction
+      return inst != newMarkDep
+    }
+    uses.replaceAll(with: newMarkDep, context)
+    return newMarkDep
+  }
+}
+
+private extension MarkDependenceAddrInst {
+  /// Rewrite the mark_dependence_addr base operand, setting it to a function argument.
+  ///
+  /// This is called when the dependent value is returned by the function and the dependence base is in the caller.
+  func redirectFunctionReturnAddress(to arg: FunctionArgument, _ context: FunctionPassContext)
+    -> MarkDependenceAddrInst {
+    return Builder(after: self, location: self.location, context)
+        .createMarkDependenceAddr(value: self.address, base: arg, kind: .Unresolved)
+  }
+}
+
 /// Transitively extend nested scopes that enclose the dependence base.
 ///
 /// If the parent function returns the dependent value, then this returns the function arguments that represent the
@@ -211,8 +236,8 @@ private func extendScopes(dependence: LifetimeDependence,
   var dependsOnArgs = SingleInlineArray<FunctionArgument>()
   for scopeExtension in scopeExtensions {
     var scopeExtension = scopeExtension
-    guard var useRange = computeDependentUseRange(of: dependence.dependentValue, within: &scopeExtension,
-                                                  localReachabilityCache, context) else {
+    guard var useRange = computeDependentUseRange(of: dependence, within: &scopeExtension, localReachabilityCache,
+                                                  context) else {
       continue
     }
 
@@ -463,20 +488,19 @@ extension ScopeExtension {
   }
 }
 
-/// Return an InstructionRange covering all the dependent uses of 'value'.
-private func computeDependentUseRange(of value: Value, within scopeExtension: inout ScopeExtension,
+/// Return an InstructionRange covering all the dependent uses of 'dependence'.
+private func computeDependentUseRange(of dependence: LifetimeDependence, within scopeExtension: inout ScopeExtension,
                                       _ localReachabilityCache: LocalVariableReachabilityCache,
                                       _ context: FunctionPassContext)
   -> InstructionRange? {
-
+  let function = dependence.function
   guard var ownershipRange = scopeExtension.computeRange(localReachabilityCache, context) else {
     return nil
   }
   defer {ownershipRange.deinitialize()}
 
   // The innermost scope that must be extended must dominate all uses.
   var useRange = InstructionRange(begin: scopeExtension.innerScope.extendableBegin!.instruction, context)
-  let function = value.parentFunction
   var walker = LifetimeDependentUseWalker(function, localReachabilityCache, context) {
     // Do not extend the useRange past the ownershipRange.
     let dependentInst = $0.instruction
@@ -487,17 +511,20 @@ private func computeDependentUseRange(of value: Value, within scopeExtension: in
   }
   defer {walker.deinitialize()}
 
-  _ = walker.walkDown(root: value)
+  _ = walker.walkDown(dependence: dependence)
 
   log("Scope fixup for dependent uses:\n\(useRange)")
 
   scopeExtension.dependsOnCaller = walker.dependsOnCaller
 
   // 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
-  // `useRange` will include the function entry.
+  // `useRange` will include the function entry. There is not way to directly check
+  // useRange.isValid. useRange.blockRange.isValid is not a strong enough check because it will always succeed when
+  // useRange.begin == entryBlock even if a use if above useRange.begin.
   let firstInst = function.entryBlock.instructions.first!
   if firstInst != useRange.begin, useRange.contains(firstInst) {
+    useRange.deinitialize()
     return nil
   }
   return useRange

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -305,7 +305,8 @@ private func isValidUseOfObject(_ use: Operand) -> Bool {
        is DeallocStackRefInst,
        is StrongRetainInst,
        is StrongReleaseInst,
-       is FixLifetimeInst:
+       is FixLifetimeInst,
+       is MarkDependenceAddrInst:
     return true
 
   case let mdi as MarkDependenceInst:

SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift

@@ -68,10 +68,14 @@ protocol AddressUseVisitor {
   /// only if its type is escapable.
   mutating func yieldedAddressUse(of operand: Operand) -> WalkResult
 
-  /// A non-address owned `value` whose ownership depends on the in-memory
-  /// value at `address`, such as `mark_dependence %value on %address`.
-  mutating func dependentAddressUse(of operand: Operand, into value: Value)
-    -> WalkResult
+  /// A forwarded `value` whose ownership depends on the in-memory value at the address `operand`.
+  /// `%value` may be an address type, but only uses of this address value are dependent.
+  /// e.g. `%value = mark_dependence %_ on %operand`
+  mutating func dependentAddressUse(of operand: Operand, dependentValue value: Value) -> WalkResult
+
+  /// A dependent `address` whose lifetime depends on the in-memory value at `address`.
+  /// e.g. `mark_dependence_addr %address on %operand`
+  mutating func dependentAddressUse(of operand: Operand, dependentAddress address: Value) -> WalkResult
 
   /// A pointer escape may propagate the address beyond the current instruction.
   mutating func escapingAddressUse(of operand: Operand) -> WalkResult
@@ -91,34 +95,11 @@ extension AddressUseVisitor {
     case is EndAccessInst, is EndApplyInst, is AbortApplyInst, is EndBorrowInst:
       return scopeEndingAddressUse(of: operand)
 
-    case let markDep as MarkDependenceInst:
-      if markDep.valueOperand == operand {
-        return projectedAddressUse(of: operand, into: markDep)
-      }
-      assert(markDep.baseOperand == operand)
-      // If another address depends on the current address,
-      // handle it like a projection.
-      if markDep.type.isAddress {
-        return projectedAddressUse(of: operand, into: markDep)
-      }
-      switch markDep.dependenceKind {
-      case .Unresolved:
-        if LifetimeDependence(markDep, context) == nil {
-          break
-        }
-        fallthrough
-      case .NonEscaping:
-        // Note: This is unreachable from InteriorUseVisitor because the base address of a `mark_dependence
-        // [nonescaping]` must be a `begin_access`, and interior liveness does not check uses of the accessed address.
-        return dependentAddressUse(of: operand, into: markDep)
-      case .Escaping:
-        break
-      }
-      // A potentially escaping value depends on this address.
-      return escapingAddressUse(of: operand)
+    case is MarkDependenceInstruction:
+      return classifyMarkDependence(operand: operand)
 
     case let pai as PartialApplyInst where !pai.mayEscape:
-      return dependentAddressUse(of: operand, into: pai)
+      return dependentAddressUse(of: operand, dependentValue: pai)
 
     case let pai as PartialApplyInst where pai.mayEscape:
       return escapingAddressUse(of: operand)
@@ -198,6 +179,57 @@ extension AddressUseVisitor {
       return unknownAddressUse(of: operand)
     }
   }
+
+  private mutating func classifyMarkDependence(operand: Operand) -> WalkResult {
+    switch operand.instruction {
+    case let markDep as MarkDependenceInst:
+      if markDep.valueOperand == operand {
+        return projectedAddressUse(of: operand, into: markDep)
+      }
+      assert(markDep.baseOperand == operand)
+      // If another address depends on the current address,
+      // handle it like a projection.
+      if markDep.type.isAddress {
+        return projectedAddressUse(of: operand, into: markDep)
+      }
+      switch markDep.dependenceKind {
+      case .Unresolved:
+        if LifetimeDependence(markDep, context) == nil {
+          break
+        }
+        fallthrough
+      case .NonEscaping:
+        // Note: This is unreachable from InteriorUseVisitor because the base address of a `mark_dependence
+        // [nonescaping]` must be a `begin_access`, and interior liveness does not check uses of the accessed address.
+        return dependentAddressUse(of: operand, dependentValue: markDep)
+      case .Escaping:
+        break
+      }
+      // A potentially escaping value depends on this address.
+      return escapingAddressUse(of: operand)
+      
+    case let markDep as MarkDependenceAddrInst:
+      if markDep.addressOperand == operand {
+        return leafAddressUse(of: operand)
+      }
+      switch markDep.dependenceKind {
+      case .Unresolved:
+        if LifetimeDependence(markDep, context) == nil {
+          break
+        }
+        fallthrough
+      case .NonEscaping:
+        return dependentAddressUse(of: operand, dependentAddress: markDep.address)
+      case .Escaping:
+        break
+      }
+      // A potentially escaping value depends on this address.
+      return escapingAddressUse(of: operand)
+
+    default:
+      fatalError("Unexpected MarkDependenceInstruction")
+    }
+  }
 }
 
 extension AccessBase {
@@ -385,8 +417,11 @@ extension AddressInitializationWalker {
     return .continueWalk
   }
 
-  mutating func dependentAddressUse(of operand: Operand, into value: Value)
-    -> WalkResult {
+  mutating func dependentAddressUse(of operand: Operand, dependentValue value: Value) -> WalkResult {
+    return .continueWalk
+  }
+
+  mutating func dependentAddressUse(of operand: Operand, dependentAddress address: Value) -> WalkResult {
     return .continueWalk
   }