Merge pull request #71570 from atrick/lifetime-inherit

LifetimeDependenceInsertion: do not emit inherited dependencies.

Author: atrick

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -114,37 +114,6 @@ public struct StringRef : CustomStringConvertible, NoReflectionChildren {
   public static func ~=(pattern: StaticString, value: StringRef) -> Bool { value == pattern }
 }
 
-//===----------------------------------------------------------------------===//
-//                      Single-Element Inline Array
-//===----------------------------------------------------------------------===//
-
-public struct SingleInlineArray<Element>: RandomAccessCollection {
-  private var singleElement: Element? = nil
-  private var multipleElements: [Element] = []
-
-  public init() {}
-
-  public var startIndex: Int { 0 }
-  public var endIndex: Int {
-    singleElement == nil ? 0 : multipleElements.count + 1
-  }
-
-  public subscript(_ index: Int) -> Element {
-    if index == 0 {
-      return singleElement!
-    }
-    return multipleElements[index - 1]
-  }
-
-  public mutating func push(_ element: Element) {
-    guard singleElement != nil else {
-      singleElement = element
-      return
-    }
-    multipleElements.append(element)
-  }
-}
-
 //===----------------------------------------------------------------------===//
 //                            Bridging Utilities
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -131,6 +131,14 @@ private struct DiagnoseDependence {
     if function.hasUnsafeNonEscapableResult {
       return .continueWalk
     }
+    // FIXME: remove this condition once we have a Builtin.dependence,
+    // which developers should use to model the unsafe
+    // dependence. Builtin.lifetime_dependence will be lowered to
+    // mark_dependence [unresolved], which will be checked
+    // independently. Instead, of this function result check, allow
+    // isUnsafeApplyResult to be used be mark_dependence [unresolved]
+    // without checking its dependents.
+    //
     // Allow returning an apply result (@_unsafeNonescapableResult) if
     // the calling function has a dependence. This implicitly makes
     // the unsafe nonescapable result dependent on the calling

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceInsertion.swift

@@ -102,14 +102,16 @@ extension LifetimeDependentApply {
   }
 }
 
-/// Replace the each dependent apply result with a chain of
-/// mark_dependence [nonescaping] instructions; one for each base.
+/// If the result of this apply depends on the scope of one or more
+/// arguments, then insert a mark_dependence [unresolved] from the
+/// result on each argument so that the result is recognized as a
+/// dependent value within each scope.
 private func insertDependencies(for apply: LifetimeDependentApply,
   _ context: FunctionPassContext ) {
   precondition(apply.applySite.results.count > 0,
     "a lifetime-dependent instruction must have at least one result")
 
-  let bases = recursivelyFindDependenceBases(of: apply, context)
+  let bases = findDependenceBases(of: apply, context)
   let builder = Builder(after: apply.applySite, context)
   for dependentValue in apply.applySite.resultOrYields {
     insertMarkDependencies(value: dependentValue, initializer: nil,
@@ -138,6 +140,31 @@ private func insertDependencies(for apply: LifetimeDependentApply,
   }
 }
 
+private func findDependenceBases(of apply: LifetimeDependentApply,
+                                 _ context: FunctionPassContext)
+  -> [Value] {
+  log("Creating dependencies for \(apply.applySite)")
+  var bases: [Value] = []
+  for lifetimeArg in apply.getLifetimeArguments() {
+    switch lifetimeArg.convention {
+    case .inherit:
+      continue
+    case .scope:
+      // Create a new dependence on the apply's access to the argument.
+      for varIntoducer in gatherVariableIntroducers(for: lifetimeArg.value,
+                                                    context) {
+        if let scope =
+             LifetimeDependence.Scope(base: varIntoducer, context) {
+          log("Scoped lifetime from \(lifetimeArg.value)")
+          log("  scope: \(scope)")
+          bases.append(scope.parentValue)
+        }
+      }
+    }
+  }
+  return bases
+}
+
 private func insertMarkDependencies(value: Value, initializer: Instruction?,
                                     bases: [Value], builder: Builder,
                                     _ context: FunctionPassContext) {
@@ -155,6 +182,7 @@ private func insertMarkDependencies(value: Value, initializer: Instruction?,
   }
 }
 
+/*
 /// Return base values that this return value depends on.
 ///
 /// For lifetime copies, walk up the dependence chain to find the
@@ -212,3 +240,4 @@ private func recursivelyUpdate(scope: LifetimeDependence.Scope,
   }
   return scope
 }
+*/

SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift

@@ -199,6 +199,9 @@ extension AccessBase {
     case let .stack(allocStack):
       baseAddr = allocStack
     case let .argument(arg):
+      guard arg.convention.isIndirectOut else {
+        return nil
+      }
       baseAddr = arg
     default:
       return nil
@@ -208,7 +211,10 @@ extension AccessBase {
          == .abortWalk {
       return nil
     }
-    return (initialAddress: baseAddr, initializingStore: walker.initializer!)
+    guard let initializingStore = walker.initializingStore else {
+      return nil
+    }
+    return (initialAddress: baseAddr, initializingStore: initializingStore)
   }
 }
 
@@ -241,15 +247,15 @@ struct AddressInitializationWalker: AddressDefUseWalker, AddressUseVisitor {
   var walkDownCache = WalkerCache<SmallProjectionPath>()
 
   var isProjected = false
-  var initializer: Instruction?
+  var initializingStore: Instruction?
 
   private mutating func setInitializer(instruction: Instruction) -> WalkResult {
     // An initializer must be unique and store the full value.
-    if initializer != nil || isProjected {
-      initializer = nil
+    if initializingStore != nil || isProjected {
+      initializingStore = nil
       return .abortWalk
     }
-    initializer = instruction
+    initializingStore = instruction
     return .continueWalk
   }
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -66,11 +66,12 @@ import SIL
 /// Value.enclosingAccess iteratively to find to AccessBase. This
 /// walker is useful for finding the innermost access, which may also
 /// be relevant for diagnostics.
-func gatherVariableIntroducers(for value: Value, _ context: Context) -> [Value]
+func gatherVariableIntroducers(for value: Value, _ context: Context)
+  -> SingleInlineArray<Value>
 {
-  var introducers: [Value] = []
+  var introducers = SingleInlineArray<Value>()
   var useDefVisitor = VariableIntroducerUseDefWalker(context) {
-    introducers.append($0)
+    introducers.push($0)
     return .continueWalk
   }
   defer { useDefVisitor.deinitialize() }
@@ -1052,10 +1053,32 @@ extension LifetimeDependenceDefUseWalker {
     if let conv = apply.convention(of: operand), conv.isIndirectOut {
       return leafUse(of: operand)
     }
-
     if apply.isCallee(operand: operand) {
       return leafUse(of: operand)
     }
+    if let dep = apply.resultDependence(on: operand),
+       dep == .inherit {
+      // Operand is nonescapable and passed as a call argument. If the
+      // result inherits its lifetime, then consider any nonescapable
+      // result value to be a dependent use.
+      //
+      // If the lifetime dependence is scoped, then we can ignore it
+      // because a mark_dependence [nonescaping] represents the
+      // dependence.
+      if let result = apply.singleDirectResult, !result.type.isEscapable {
+        if dependentUse(of: operand, into: result) == .abortWalk {
+          return .abortWalk
+        }
+      }
+      for resultAddr in apply.indirectResultOperands
+          where !resultAddr.value.type.isEscapable {
+        if visitStoredUses(of: operand, into: resultAddr.value) == .abortWalk {
+          return .abortWalk
+        }
+      }
+    }
+    // Regardless of lifetime dependencies, consider the operand to be
+    // use for the duration of the call.
     if apply is BeginApplyInst {
       return scopedAddressUse(of: operand)
     }

SwiftCompilerSources/Sources/SIL/Utilities/SequenceUtilities.swift

@@ -117,3 +117,34 @@ extension LazyMapSequence : CollectionLikeSequence,
 extension LazyFilterSequence : CollectionLikeSequence,
                                FormattedLikeArray, CustomStringConvertible, CustomReflectable
                                where Base: CollectionLikeSequence {}
+
+//===----------------------------------------------------------------------===//
+//                      Single-Element Inline Array
+//===----------------------------------------------------------------------===//
+
+public struct SingleInlineArray<Element>: RandomAccessCollection, FormattedLikeArray {
+  private var singleElement: Element? = nil
+  private var multipleElements: [Element] = []
+
+  public init() {}
+
+  public var startIndex: Int { 0 }
+  public var endIndex: Int {
+    singleElement == nil ? 0 : multipleElements.count + 1
+  }
+
+  public subscript(_ index: Int) -> Element {
+    if index == 0 {
+      return singleElement!
+    }
+    return multipleElements[index - 1]
+  }
+
+  public mutating func push(_ element: Element) {
+    guard singleElement != nil else {
+      singleElement = element
+      return
+    }
+    multipleElements.append(element)
+  }
+}

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -69,6 +69,13 @@ llvm::cl::opt<bool>
     EnableDeinitDevirtualizer("enable-deinit-devirtualizer", llvm::cl::init(false),
                           llvm::cl::desc("Enable the DestroyHoisting pass."));
 
+// Temporary flag until the stdlib builds with ~Escapable
+llvm::cl::opt<bool>
+EnableLifetimeDependenceInsertion(
+  "enable-lifetime-dependence-insertion", llvm::cl::init(false),
+  llvm::cl::desc("Enable lifetime dependence insertion."));
+
+// Temporary flag until the stdlib builds with ~Escapable
 llvm::cl::opt<bool>
 EnableLifetimeDependenceDiagnostics(
   "enable-lifetime-dependence-diagnostics", llvm::cl::init(false),
@@ -291,7 +298,7 @@ SILPassPipelinePlan::getSILGenPassPipeline(const SILOptions &Options) {
   P.startPipeline("SILGen Passes");
 
   P.addSILGenCleanup();
-  if (EnableLifetimeDependenceDiagnostics) {
+  if (EnableLifetimeDependenceDiagnostics || EnableLifetimeDependenceInsertion) {
     P.addLifetimeDependenceInsertion();
   }
   if (SILViewSILGenCFG) {

test/SILOptimizer/lifetime_dependence_diagnostics.swift

@@ -18,14 +18,26 @@ func bv_copy(_ bv: borrowing BV) -> _copy(bv) BV {
   copy bv
 }
 
-// Diagnostics resolves mark_dependence [nonescaping].
+// No mark_dependence is needed for a inherited scope.
 //
-// CHECK-LABEL: sil hidden @$s4test14bv_borrow_copy0B0AA2BVVAE_tF : $@convention(thin) (@guaranteed BV) -> _scope(1) @owned BV {
-// CHECK: bb0(%0 : @noImplicitCopy $BV):
-// CHECK:   [[R:%.*]] = apply %{{.*}}(%0) : $@convention(thin) (@guaranteed BV) -> _inherit(1) @owned BV
-// CHECK:   [[MD:%.*]] = mark_dependence [nonescaping] [[R]] : $BV on %0 : $BV
-// CHECK:   return [[MD]] : $BV
-// CHECK-LABEL: } // end sil function '$s4test14bv_borrow_copy0B0AA2BVVAE_tF'
-func bv_borrow_copy(bv: borrowing BV) -> _borrow(bv) BV {
+// CHECK-LABEL: sil hidden @$s4test14bv_borrow_copyyAA2BVVADF : $@convention(thin) (@guaranteed BV) -> _scope(1) @owned BV {
+// CHECK:      bb0(%0 : @noImplicitCopy $BV):
+// CHECK:        apply %{{.*}}(%0) : $@convention(thin) (@guaranteed BV) -> _inherit(1) @owned BV // user: %4
+// CHECK-NEXT:   return %3 : $BV
+// CHECK-LABEL: } // end sil function '$s4test14bv_borrow_copyyAA2BVVADF'
+func bv_borrow_copy(_ bv: borrowing BV) -> _borrow(bv) BV {
   bv_copy(bv) 
 }
+
+// The mark_dependence for the borrow scope should be marked
+// [nonescaping] after diagnostics.
+//
+// CHECK-LABEL: sil hidden @$s4test010bv_borrow_C00B0AA2BVVAE_tF : $@convention(thin) (@guaranteed BV) -> _scope(1) @owned BV {
+// CHECK:       bb0(%0 : @noImplicitCopy $BV):
+// CHECK:         [[R:%.*]] = apply %{{.*}}(%0) : $@convention(thin) (@guaranteed BV) -> _scope(1) @owned BV
+// CHECK:         %{{.*}} = mark_dependence [nonescaping] [[R]] : $BV on %0 : $BV
+// CHECK-NEXT:    return %{{.*}} : $BV
+// CHECK-LABEL: } // end sil function '$s4test010bv_borrow_C00B0AA2BVVAE_tF'
+func bv_borrow_borrow(bv: borrowing BV) -> _borrow(bv) BV {
+  bv_borrow_copy(bv)
+}

test/SILOptimizer/lifetime_dependence_inherit.swift

@@ -37,3 +37,10 @@ struct NE {
     return self
   }
 }
+
+// Test lifetime inheritance through chained consumes.
+//
+// This requires an inherit_lifetime marker on the argument.
+func bv_derive(bv: consuming BV) -> _consume(bv) BV {
+  bv.derive()
+}

test/SILOptimizer/lifetime_dependence_inherit_fail.swift

@@ -36,10 +36,3 @@ struct NE {
     return self
   }
 }
-
-func bv_derive_local(bv: consuming BV) -> _consume(bv) BV {
-  let bv2 = BV(bv.p, bv.i)
-  return bv2.derive() // expected-error {{lifetime-dependent value escapes its scope}}
-  // expected-note @-2 {{it depends on the lifetime of variable 'bv2'}}
-  // expected-note @-2 {{this use causes the lifetime-dependent value to escape}}
-}