LifetimeDependenceDiagnostics: extend temp alloc to unreachable.

When a non-Escapable value depends on the address of a trivial value, we use a
special computeAddressableRange analysis to compute the trivial value's
scope. Extend that analysis to include unreachable paths.

Fixes this pattern:

    inlineStorage.span.withUnsafeBytes

where inlineStorage is a trivial type defined in the user module. This
does not reproduce directly with InlineArray, but it is a problem for
user modules that have their own trivial wrapper around an InlineArray.

Fixes rdar://161630684 (Incorrect diagnostic: lifetime-dependent value escapes its scope)

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -558,10 +558,27 @@ extension LifetimeDependence.Scope {
         }
       }
       guard isAddressable, !deallocInsts.isEmpty else {
+        // Valid on all paths to function exit.
         return nil
       }
       var range = InstructionRange(begin: initializingStore, context)
       range.insert(contentsOf: deallocInsts)
+
+      // Insert unreachable paths with no dealloc_stack.
+      var forwardUnreachableWalk = BasicBlockWorklist(context)
+      defer { forwardUnreachableWalk.deinitialize() }
+
+      for exitBlock in range.exitBlocks {
+        forwardUnreachableWalk.pushIfNotVisited(exitBlock)
+      }
+      while let b = forwardUnreachableWalk.pop() {
+        if let unreachableInst = b.terminator as? UnreachableInst {
+          range.insert(unreachableInst)
+        }
+        for succBlock in b.successors {
+          forwardUnreachableWalk.pushIfNotVisited(succBlock)
+        }
+      }
       return range
     }
   }

test/SILOptimizer/lifetime_dependence/verify_diagnostics.sil

@@ -70,6 +70,9 @@ sil @addressInt : $@convention(thin) (@in_guaranteed InlineInt) -> @lifetime(bor
 sil @addressOfInt : $@convention(thin) (@in_guaranteed Int) -> @lifetime(borrow address 0) @owned Span<Int>
 sil @noAddressInt : $@convention(thin) (@in_guaranteed Int) -> @lifetime(borrow 0) @owned Span<Int>
 sil @useSpan : $@convention(thin) (@guaranteed Span<Int>) -> ()
+sil @useRawSpan : $@convention(thin) (@guaranteed RawSpan) -> @error any Error
+
+sil @getInlineSpan : $@convention(thin) (@in_guaranteed InlineInt) -> @lifetime(borrow address 0) @owned RawSpan
 
 // Test returning a owned dependence on a trivial value
 sil [ossa] @return_trivial_dependence : $@convention(thin) (@guaranteed C) -> @lifetime(borrow 0) @owned NE {
@@ -352,3 +355,29 @@ bb0(%0: $Int):
   %18 = tuple ()
   return %18
 }
+
+// Test dependence on the temporary stack address of a trivial value. computeAddressableRange must extend the lifetime
+// of %tempAddr into the unreachable.
+sil hidden [ossa] @testTempAddressUnreachable : $@convention(thin) (@in_guaranteed InlineInt) -> () {
+bb0(%0 : $*InlineInt):
+  %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 bb1, error bb2
+
+bb1(%void : $()):
+  destroy_value %md
+  dealloc_stack %tempAddr
+  %99 = tuple ()
+  return %99
+
+bb2(%error : @owned $any Error):
+  destroy_value [dead_end] %md
+  unreachable
+}

test/SILOptimizer/lifetime_dependence/verify_diagnostics.swift

@@ -208,6 +208,19 @@ func testClosureCapture1(_ a: HasMethods) {
    */
 }
 
+public struct InlineInt: BitwiseCopyable {
+  var val: UInt64
+
+  var span: RawSpan {
+    @_addressableSelf
+    @_lifetime(borrow self) borrowing get {
+      let buf = UnsafeRawBufferPointer(start: UnsafeRawPointer(Builtin.addressOfBorrow(val)), count: 1)
+      let span = RawSpan(_unsafeBytes: buf)
+      return unsafe _overrideLifetime(span, borrowing: val)
+    }
+  }
+}
+
 // =============================================================================
 // Indirect ~Escapable results
 // =============================================================================
@@ -382,3 +395,17 @@ func returnTempBorrow() -> Borrow<Int> {
   // expected-note@-1{{it depends on the lifetime of this parent value}}
   return span // expected-note{{this use causes the lifetime-dependent value to escape}}
 }
+
+// Test dependence on the temporary stack address of a trivial value. computeAddressableRange must extend the lifetime
+// of 'inline' into the unreachable.
+//
+// This test requires InlineInt to be a trivial value defined in this module so that inline.span generates:
+//
+//     %temp = alloc_stack
+//     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.
+func test(inline: InlineInt) {
+  inline.span.withUnsafeBytes { _ = $0 }
+}