LifetimeDependence.Scope add global variable support.

This fixes functions that return @Lifetime(immortal).

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -67,7 +67,7 @@ struct LifetimeDependence : CustomStringConvertible {
     /// begin_borrow. LinearLiveness computes the scope boundary.
     case local(VariableScopeInstruction)
     /// A directly accessed global variable without exclusivity. Presumably immutable and therefore immortal.
-    case global(GlobalAddrInst)
+    case global(GlobalAccessBase)
     /// Singly-initialized addressable storage (likely for an immutable address-only value). The lifetime extends until
     /// the memory is destroyed. e.g. A value produced by an @in FunctionArgument, an @out apply, or an @inout
     /// FunctionArgument that is never modified inside the callee. Modified @inout FunctionArguments have caller scoped
@@ -84,7 +84,7 @@ struct LifetimeDependence : CustomStringConvertible {
       case let .owned(value): return value
       case let .borrowed(beginBorrow): return beginBorrow.value
       case let .local(varScope): return varScope.scopeBegin
-      case let .global(ga): return ga
+      case let .global(ga): return ga.address
       case let .initialized(initializer): return initializer.initialAddress
       case let .unknown(value): return value
       }
@@ -261,11 +261,12 @@ extension LifetimeDependence.Scope {
     case .stack, .class, .tail, .pointer, .index, .unidentified:
       self = .unknown(accessBase.address!)
     case .global:
-      // TODO: When AccessBase stores global_addr, we don't need a check here and don't need to pass 'address' in.
-      if let ga = address as? GlobalAddrInst {
+      // TODO: When AccessBase directly stores GlobalAccessBase, we don't need a check here and don't need to pass
+      // 'address' in to this function.
+      if let ga = GlobalAccessBase(address: address) {
         self = .global(ga)
       } else {
-        self = .unknown(accessBase.address!)
+        self = .unknown(accessBase.address ?? address)
       }
     case let .argument(arg):
       if arg.convention.isIndirectIn {
@@ -332,7 +333,7 @@ extension LifetimeDependence.Scope {
       self = .caller(arg)
     } else if let varScope = VariableScopeInstruction(value.definingInstruction) {
       self = .local(varScope)
-    } else if let ga = value as? GlobalAddrInst {
+    } else if let ga = GlobalAccessBase(address: value) {
       self = .global(ga)
     } else {
       self = .unknown(value)

SwiftCompilerSources/Sources/SIL/Utilities/AccessUtils.swift

@@ -428,7 +428,7 @@ private func canBeOperandOfIndexAddr(_ value: Value) -> Bool {
 /// %ptr = address_to_pointer %orig_addr
 /// %addr = pointer_to_address %ptr
 /// ```
-private extension PointerToAddressInst {
+public extension PointerToAddressInst {
   var originatingAddress: Value? {
 
     struct Walker : ValueUseDefWalker {
@@ -481,6 +481,33 @@ private extension PointerToAddressInst {
   }
 }
 
+/// TODO: migrate AccessBase to use this instead of GlobalVariable because many utilities need to get back to a
+/// representative SIL Value.
+public enum GlobalAccessBase {
+  case global(GlobalAddrInst)
+  case initializer(PointerToAddressInst)
+
+  public init?(address: Value) {
+    switch address {
+    case let ga as GlobalAddrInst:
+      self = .global(ga)
+    case let p2a as PointerToAddressInst where p2a.resultOfGlobalAddressorCall != nil:
+      self = .initializer(p2a)
+    default:
+      return nil
+    }
+  }
+
+  public var address: Value {
+    switch self {
+      case let .global(ga):
+        return ga
+      case let .initializer(p2a):
+        return p2a
+    }
+  }
+}
+
 /// The `EnclosingAccessScope` of an access is the innermost `begin_access`
 /// instruction that checks for exclusivity of the access.
 /// If there is no `begin_access` instruction found, then the scope is

test/SILOptimizer/lifetime_dependence/lifetime_dependence_borrow_fail.swift

@@ -80,14 +80,6 @@ func bv_incorrect_annotation2(_ w1: borrowing Wrapper, _ w2: borrowing Wrapper)
   return w1.bv                                                                                        // expected-note @-1{{it depends on the lifetime of argument 'w1'}}
 }                                                                                                     // expected-note @-1{{this use causes the lifetime-dependent value to escape}}
 
-let ptr = UnsafeRawPointer(bitPattern: 1)!
-let nc = NC(ptr, 0)
-
-func bv_global(dummy: BV) -> BV {
-  nc.getBV()  // expected-error {{lifetime-dependent value escapes its scope}}
-  // expected-note @-4{{it depends on the lifetime of variable 'nc'}}
-} // expected-note {{this use causes the lifetime-dependent value to escape}}
-
 func testEmpty(nc: consuming NC) {
   var e: Empty // expected-error {{lifetime-dependent variable 'e' escapes its scope}}
   do {

test/SILOptimizer/lifetime_dependence/semantics.swift

@@ -338,6 +338,15 @@ func testImmortalString() -> Span<String> {
   return _overrideLifetime(span, borrowing: immortalString)
 }
 
+let ptr = UnsafePointer<Int>(bitPattern: 1)!
+let globalTrivial = InnerTrivial(p: ptr)
+
+// An immortal span can depend on a caller's local borrow scope even though the callee sees no such dependency.
+@lifetime(borrow local)
+func testGlobal(local: InnerTrivial) -> Span<Int> {
+  globalTrivial.span()
+}
+
 // =============================================================================
 // Scoped dependence on mutable values
 // =============================================================================