LifetimeDependence: handle dependence on trivial values.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -65,13 +65,16 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
           // but the change won't appear in -sil-print-function. Ideally, we could notify context of a flag change
           // without invalidating analyses.
           lifetimeDep.resolve(context)
+          continue
         }
-      } else {
-        // For now, if the mark_dependence wasn't recognized as a lifetime dependence, conservatively settle it as
-        // escaping. In the future, we should not need this because, for escapable types, mark_dependence [unresolved]
-        // will all be settled during an early LifetimeNormalization pass.
-        markDep.settleToEscaping()
       }
+      // For now, if the mark_dependence wasn't recognized as a lifetime dependency, or if the dependencies uses are not
+      // in scope, conservatively settle it as escaping. For example, it is not uncommon for the pointer value returned
+      // by `unsafeAddress` to outlive its `self` argument. This will not be diagnosed as an error, but the
+      // mark_dependence will hanceforth be treated as an unknown use by the optimizer.  In the future, we should not
+      // need to set this flag during diagnostics because, for escapable types, mark_dependence [unresolved] will all be
+      // settled during an early LifetimeNormalization pass.
+      markDep.settleToEscaping()
       continue
     }
     if let apply = instruction as? FullApplySite {
@@ -97,7 +100,15 @@ let lifetimeDependenceDiagnosticsPass = FunctionPass(
 /// Return true on success.
 private func analyze(dependence: LifetimeDependence, _ context: FunctionPassContext) -> Bool {
   log("Dependence scope:\n\(dependence)")
-    
+
+  // Early versions of Span in the standard library violate trivial lifetimes. Contemporary versions of the compiler
+  // simply ignored dependencies on trivial values.
+  if !context.options.hasFeature(.LifetimeDependenceDiagnoseTrivial) {
+    if dependence.parentValue.type.objectType.isTrivial(in: dependence.function) {
+      return true
+    }
+  }
+
   // Compute this dependence scope.
   var range = dependence.computeRange(context)
   defer { range?.deinitialize() }
@@ -110,8 +121,10 @@ 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() }
-  _ = walker.walkDown(root: dependence.dependentValue)
-  return !error
+  let result = walker.walkDown(root: dependence.dependentValue)
+  // The walk may abort without a diagnostic error.
+  assert(!error || result == .abortWalk)
+  return result == .continueWalk
 }
 
 /// Analyze and diagnose a single LifetimeDependence.
@@ -214,6 +227,10 @@ private struct DiagnoseDependence {
   }
 
   func reportError(operand: Operand, diagID: DiagID) {
+    // If the dependent value is Escapable, then mark_dependence resolution fails, but this is not a diagnostic error.
+    if dependence.dependentValue.isEscapable {
+      return
+    }
     onError()
 
     // Identify the escaping variable.

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift

@@ -218,11 +218,10 @@ private extension LifetimeDependentApply.LifetimeSourceInfo {
     case .result, .inParameter, .inoutParameter:
       // Create a new dependence on the apply's access to the argument.
       for varIntoducer in gatherVariableIntroducers(for: source.value, context) {
-        if let scope = LifetimeDependence.Scope(base: varIntoducer, context) {
-          log("Scoped lifetime from \(source.value)")
-          log("  scope: \(scope)")
-          bases.append(scope.parentValue)
-        }
+        let scope = LifetimeDependence.Scope(base: varIntoducer, context)
+        log("Scoped lifetime from \(source.value)")
+        log("  scope: \(scope)")
+        bases.append(scope.parentValue)
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -299,9 +299,7 @@ private extension LifetimeDependence.Scope {
                                                        dependsOnArg: dependsOnArg))
     case let .borrowed(beginBorrow):
       let borrowedValue = beginBorrow.baseOperand!.value
-      guard let enclosingScope = LifetimeDependence.Scope(base: borrowedValue, context) else {
-        return nil
-      }
+      let enclosingScope = LifetimeDependence.Scope(base: borrowedValue, context)
       innerScopes.push(self)
       var innerBorrowScopes = innerScopes
       innerBorrowScopes.push(enclosingScope)
@@ -323,9 +321,7 @@ private extension LifetimeDependence.Scope {
         guard let dep = applySite.resultDependence(on: operand), dep == .scope else {
           continue
         }
-        guard let enclosingScope = LifetimeDependence.Scope(base: operand.value, context) else {
-          continue
-        }
+        let enclosingScope = LifetimeDependence.Scope(base: operand.value, context)
         if let operandExtensions = enclosingScope.gatherExtensions(innerScopes: innerScopes, context) {
           extensions.append(contentsOf: operandExtensions)
         } else {

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -66,6 +66,8 @@ private func log(prefix: Bool = true, _ message: @autoclosure () -> String) {
 /// Walk up the value dependence chain to find the best-effort
 /// variable declaration. Typically called while diagnosing an error.
 ///
+/// Returns an array with at least one introducer value.
+///
 /// The walk stops at:
 /// - an address
 /// - a variable declaration (begin_borrow [var_decl], move_value [var_decl])
@@ -85,6 +87,7 @@ func gatherVariableIntroducers(for value: Value, _ context: Context)
   }
   defer { useDefVisitor.deinitialize() }
   _ = useDefVisitor.walkUp(valueOrAddress: value)
+  assert(!introducers.isEmpty, "missing variable introducer")
   return introducers
 }
 
@@ -104,7 +107,6 @@ func gatherVariableIntroducers(for value: Value, _ context: Context)
 /// A lifetime dependence identifies its parent value, the kind of
 /// scope that the parent value represents, and a dependent value.
 struct LifetimeDependence : CustomStringConvertible {
-  // TODO: handle trivial values based on variable binding
   enum Scope : CustomStringConvertible {
     /// A guaranteed or inout argument whose scope is provided by the caller
     /// and covers the entire function and any dependent results or yields.
@@ -113,9 +115,10 @@ struct LifetimeDependence : CustomStringConvertible {
     case access(BeginAccessInst)
     /// A coroutine.
     case yield(Value)
-    /// An owned value whose OSSA lifetime encloses nonescapable values
+    /// 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
+    /// An 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
     /// immutable address-only value). The lifetime extends until the
@@ -128,8 +131,7 @@ struct LifetimeDependence : CustomStringConvertible {
     /// If `initializingStore` is nil, then the `initialAddress` is
     /// initialized on function entry.
     case initialized(initialAddress: Value, initializingStore: Instruction?)
-    // TODO: Add SIL verification that no mark_depedence [unresolved] has an unknown LifetimeDependence.
-    // This currently requires stack allocations to be singly initialized.
+    // Unknown includes: escapable values with local var_decl, stack allocations that are not singly initialized.
     case unknown(Value)
 
     var parentValue: Value {
@@ -202,7 +204,7 @@ extension LifetimeDependence {
     if arg.isIndirectResult {
       return nil
     }
-    self.scope = Scope(base: arg, context)!
+    self.scope = Scope(base: arg, context)
     self.dependentValue = arg
   }
 
@@ -219,7 +221,7 @@ extension LifetimeDependence {
       return nil
     }
     assert(value.ownership == .owned, "unsafe apply result must be owned")
-    self.scope = Scope(base: value, context)!
+    self.scope = Scope(base: value, context)
     self.dependentValue = value
   }
 
@@ -238,14 +240,11 @@ extension LifetimeDependence {
   /// For any LifetimeDependence constructed from a mark_dependence, its `dependentValue` will be the result of the
   /// mark_dependence.
   ///
-  /// Returns 'nil' for dependence on a trivial value.
+  /// Returns 'nil' for unknown dependence.
   init?(_ markDep: MarkDependenceInst, _ context: some Context) {
     switch markDep.dependenceKind {
     case .Unresolved, .NonEscaping:
-      guard let scope = Scope(base: markDep.base, context) else {
-        return nil
-      }
-      self.scope = scope
+      self.scope = Scope(base: markDep.base, context)
       self.dependentValue = markDep
     case .Escaping:
       return nil
@@ -294,65 +293,45 @@ extension LifetimeDependence.Scope {
   /// directly defines the parent lifetime. If `base` is guaranteed, then it must have a single borrow introducer, which
   /// defines the parent lifetime. `base` must not be derived from a guaranteed phi or forwarded (via struct/tuple) from
   /// multiple guaranteed values.
-  ///
-  /// Returns 'nil' for dependence on a trivial value.
-  init?(base: Value, _ context: some Context) {
+  init(base: Value, _ context: some Context) {
     if base.type.isAddress {
-      guard let scope = Self(address: base, context) else {
-        return nil
-      }
-      self = scope
+      self = Self(address: base, context)
       return
     }
     switch base.ownership {
     case .owned:
       self = .owned(base)
       return
     case .guaranteed:
-      guard let scope = Self(guaranteed: base, context) else {
-        return nil
-      }
-      self = scope
+      self = Self(guaranteed: base, context)
     case .none:
-      // lifetime dependence requires a nontrivial value
-      return nil
+      self = Self(variable: base, context)
     case .unowned:
       self = .unknown(base)
     }
   }
 
-  /// Returns 'nil' for dependence on a trivial value.
-  private init?(address: Value, _ context: some Context) {
+  private init(address: Value, _ context: some Context) {
     switch address.enclosingAccessScope {
     case let .scope(access):
       self = .access(access)
     case let .base(accessBase):
-      guard let scope = Self(accessBase: accessBase, address: address, context) else {
-        return nil
-      }
-      self = scope
+      self = Self(accessBase: accessBase, address: address, context)
     }
   }
 
-  /// Returns 'nil' for dependence on a trivial value.
-  init?(accessBase: AccessBase, address: Value, _ context: some Context) {
+  init(accessBase: AccessBase, address: Value, _ context: some Context) {
     switch accessBase {
     case let .box(projectBox):
       // Note: the box may be in a borrow scope.
-      guard let scope = Self(base: projectBox.operand.value, context) else {
-        return nil
-      }
-      self = scope
+      self = Self(base: projectBox.operand.value, context)
     case let .stack(allocStack):
       self = Self(allocation: allocStack, context)
     case .global:
       self = .unknown(address)
     case .class, .tail:
       let refElt = address as! UnaryInstruction
-      guard let scope = Self(guaranteed: refElt.operand.value, context) else {
-        return nil
-      }
-      self = scope
+      self = Self(guaranteed: refElt.operand.value, context)
     case let .argument(arg):
       if arg.convention.isIndirectIn {
         self = .initialized(initialAddress: arg, initializingStore: nil)
@@ -368,24 +347,23 @@ extension LifetimeDependence.Scope {
     case let .yield(result):
       self = Self(yield: result)
     case .storeBorrow(let sb):
-      guard let scope = Self(base: sb.source, context) else {
-        return nil
-      }
-      self = scope
+      self = Self(base: sb.source, context)
     case .pointer, .index, .unidentified:
       self = .unknown(address)
     }
   }
 
-  /// Returns 'nil' for dependence on a trivial value.
-  private init?(guaranteed base: Value, _ context: some Context) {
-    // If introducers is empty, then the dependence is on a trivial value, so
-    // there is no dependence scope.
-    //
+  private init(guaranteed base: Value, _ context: some Context) {
     // TODO: Add a SIL verifier check that a mark_dependence [nonescaping]
     // base is never a guaranteed phi.
     var iter = base.getBorrowIntroducers(context).makeIterator()
-    guard let beginBorrow = iter.next() else { return nil }
+    // If no borrow introducer was found, then this is a borrow of a trivial value. Since we can assume a single
+    // introducer here, then this is the only condition under which we have a trivial introducer.
+    guard let beginBorrow = iter.next() else {
+      self = Self(variable: base, context)
+      return
+    }
+    // TODO: will we need to handle tuple/struct with multiple scopes?
     assert(iter.next() == nil,
            "guaranteed phis not allowed when diagnosing lifetime dependence")
     switch beginBorrow {
@@ -400,6 +378,24 @@ extension LifetimeDependence.Scope {
     }
   }
 
+  private init(variable base: Value, _ context: some Context) {
+    guard let introducer = gatherVariableIntroducers(for: base, context).singleElement else {
+      // TODO: do we need to handle multiple introducers in case of a tuple/struct?
+      self = .unknown(base)
+      return
+    }
+    switch introducer {
+    case let arg as FunctionArgument:
+      self = .caller(arg)
+    case let bbi as BeginBorrowInst:
+      self = .borrowed(BeginBorrowValue(bbi)!)
+    case is MoveValueInst:
+      self = .owned(introducer)
+    default:
+      self = .unknown(introducer)
+    }
+  }
+
   private init(yield result: MultipleValueInstructionResult) {
     // Consider an @in yield an .initialized scope. We must find the destroys.
     let apply = result.parentInstruction as! FullApplySite
@@ -431,7 +427,7 @@ extension LifetimeDependence.Scope {
       if bb.isFromVarDecl {
         return self
       }
-      return LifetimeDependence.Scope(base: bb.borrowedValue, context)?.ignoreBorrowScope(context)
+      return LifetimeDependence.Scope(base: bb.borrowedValue, context).ignoreBorrowScope(context)
     case let .loadBorrow(lb):
       return LifetimeDependence.Scope(base: lb.address, context)
     default:
@@ -443,7 +439,7 @@ extension LifetimeDependence.Scope {
 extension LifetimeDependence.Scope {
   /// Compute the range of the dependence scope. 
   ///
-  /// Returns nil if the dependence scope covers the entire function.
+  /// Returns nil if the dependence scope covers the entire function. Returns an empty range for an unknown scope.
   ///
   /// Note: The caller must deinitialize the returned range.
   func computeRange(_ context: Context) -> InstructionRange? {
@@ -480,11 +476,12 @@ extension LifetimeDependence.Scope {
       return InstructionRange(for: value, context)
     }
   }
-  
-  private static func computeInitializedRange(initialAddress: Value,
-                                              initializingStore: Instruction?,
+
+  // !!! - handle allocations of trivial values: no destroy. Use the dealloc in that case?
+  private static func computeInitializedRange(initialAddress: Value, initializingStore: Instruction?,
                                               _ context: Context)
     -> InstructionRange {
+
     assert(initialAddress.type.isAddress)
 
     var range: InstructionRange
@@ -619,7 +616,12 @@ struct VariableIntroducerUseDefWalker : LifetimeDependenceUseDefWalker {
 
   mutating func walkUp(value: Value, _ owner: Value?) -> WalkResult {
     if let inst = value.definingInstruction, VariableScopeInstruction(inst) != nil {
-      return introducer(value, owner)
+      return visitorClosure(value)
+    }
+    // Finding a variable introducer requires following the mark_dependence forwarded value, not the base value like the
+    // default LifetimeDependenceUseDefWalker.
+    if value is MarkDependenceInst {
+      return walkUpDefault(forwarded: value, owner)
     }
     return walkUpDefault(dependent: value, owner: owner)
   }
@@ -685,6 +687,9 @@ struct VariableIntroducerUseDefWalker : LifetimeDependenceUseDefWalker {
 protocol LifetimeDependenceUseDefWalker : ForwardingUseDefWalker where PathContext == Value? {
   var context: Context { get }
 
+  /// 'owner' is the most recently visited suitable base. Generally, this is the most recent owned value. When a
+  /// mark_dependence value operand is forwarded from its base operand, however, the owner is not updated because that
+  /// would could lead to introducing an illegal mark_dependence with the same value for both operands.
   mutating func introducer(_ value: Value, _ owner: Value?) -> WalkResult
 
   // Minimally, check a ValueSet. This walker may traverse chains of
@@ -1239,7 +1244,7 @@ let lifetimeDependenceScopeTest = FunctionTest("lifetime_dependence_scope") {
     function, arguments, context in
   let markDep = arguments.takeValue() as! MarkDependenceInst
   guard let dependence = LifetimeDependence(markDep, context) else {
-    print("Trivial Dependence")
+    print("Invalid Dependence")
     return
   }
   print(dependence)

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -56,8 +56,9 @@ func computeLinearLiveness(for definingValue: Value, _ context: Context)
   -> InstructionRange {
 
   assert(definingValue.ownership == .owned
-    || BeginBorrowValue(definingValue) != nil,
-    "value must define an OSSA lifetime")
+           || BeginBorrowValue(definingValue) != nil
+           || VariableScopeInstruction(definingValue.definingInstruction) != nil,
+         "value must define an OSSA lifetime or variable scope")
 
   // InstructionRange cannot directly represent the beginning of the block
   // so we fake it with getRepresentativeInstruction().