[NFC] LifetimeDependence computeAddressRange comments and test case

(cherry picked from commit ac9a5b6d164b3824fdfcbf638af8724ec6e2751c)

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -428,6 +428,10 @@ extension LifetimeDependence.Scope {
   ///
   /// Returns nil if the dependence scope covers the entire function. Returns an empty range for an unknown scope.
   ///
+  /// When this Scope is live on unreachable paths, the returned range may include blocks that are not dominated by the
+  /// scope introducer. Even though 'range.isValid == false' for such a range, it is still valid for checking that
+  /// dependencies are in scope since we already know that the Scope introducer dominates all dependent uses.
+  ///
   /// Ignore the lifetime of temporary trivial values (with .initialized and .unknown scopes). Temporaries have an
   /// unknown Scope, which means that LifetimeDependence.Scope did not recognize a VariableScopeInstruction. This is
   /// important to promote mark_dependence instructions emitted by SILGen to [nonescaping] (e.g. unsafeAddressor). It
@@ -568,11 +572,16 @@ extension LifetimeDependence.Scope {
       var forwardUnreachableWalk = BasicBlockWorklist(context)
       defer { forwardUnreachableWalk.deinitialize() }
 
+      // TODO: ensure complete dealloc_stack on all paths in SIL verification, then assert exitBlock.isEmpty.
       for exitBlock in range.exitBlocks {
         forwardUnreachableWalk.pushIfNotVisited(exitBlock)
       }
       while let b = forwardUnreachableWalk.pop() {
         if let unreachableInst = b.terminator as? UnreachableInst {
+          // Note: 'unreachableInst' is not necessarilly dominated by 'initializingStore'. This marks the range invalid,
+          // but leaves it in a usable state that includes all blocks covered by the temporary allocation. The extra
+          // blocks (backward up to the function entry) are irrelevant becase we already know that 'initializingStore'
+          // dominates dependent uses.
           range.insert(unreachableInst)
         }
         for succBlock in b.successors {

test/SILOptimizer/lifetime_dependence/verify_diagnostics.sil

@@ -381,3 +381,42 @@ bb2(%error : @owned $any Error):
   destroy_value [dead_end] %md
   unreachable
 }
+
+// Test dependence on the temporary stack address of a trivial value. computeAddressableRange must extend the lifetime
+// of %tempAddr into the unreachable.
+//
+// Note that the computed instruction range is marked Invalid because it does not have a single dominating
+// block. Nonetheless, the range still include all blocks in which the stack allocation is live, which is all we care
+// about.
+sil hidden [ossa] @testTempAddressNondominatedUnreachable : $@convention(thin) (@in_guaranteed InlineInt) -> () {
+bb0(%0 : $*InlineInt):
+  cond_br undef, bb1, bb2
+
+bb1:
+  br bb5
+
+bb2:
+  %loadArg = load [trivial] %0
+  %tempAddr = alloc_stack $InlineInt
+  store %loadArg to [trivial] %tempAddr
+
+  %f1 = function_ref @getInlineSpan : $@convention(thin) (@in_guaranteed InlineInt) -> @lifetime(borrow address 0) @owned RawSpan
+  %call = apply %f1(%tempAddr) : $@convention(thin) (@in_guaranteed InlineInt) -> @lifetime(borrow address 0) @owned RawSpan
+  %md = mark_dependence [unresolved] %call on %tempAddr
+
+  %f2 = function_ref @useRawSpan : $@convention(thin) (@guaranteed RawSpan) -> @error any Error
+  try_apply %f2(%md) : $@convention(thin) (@guaranteed RawSpan) -> @error any Error, normal bb3, error bb4
+
+bb3(%void : $()):
+  destroy_value %md
+  dealloc_stack %tempAddr
+  %99 = tuple ()
+  return %99
+
+bb4(%error : @owned $any Error):
+  destroy_value [dead_end] %md
+  br bb5
+
+bb5:
+  unreachable
+}

test/SILOptimizer/lifetime_dependence/verify_diagnostics.swift

@@ -407,7 +407,7 @@ func returnTempBorrow() -> Borrow<Int> {
 //     store %arg to [trivial] temp
 //     apply %get_span(%temp)
 //
-// If we use InlineArray instead, we get a store_borrow, which is a completely different situatio.
+// If we use InlineArray instead, we get a store_borrow, which is a completely different situation.
 func test(inline: InlineInt) {
   inline.span.withUnsafeBytes { _ = $0 }
 }