LifetimeDependenceDiagnostics: immortal dependence on global 'let'

Author: atrick

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -200,6 +200,10 @@ private struct DiagnoseDependence {
     if function.hasUnsafeNonEscapableResult {
       return .continueWalk
     }
+    // If the dependence scope is global, then it has immortal lifetime.
+    if case .global = dependence.scope {
+      return .continueWalk
+    }
     // Check that the parameter dependence for this result is the same
     // as the current dependence scope.
     if let arg = dependence.scope.parentValue as? FunctionArgument,

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -66,6 +66,8 @@ struct LifetimeDependence : CustomStringConvertible {
     /// A local variable scope without ownership. The scope must be introduced by either move_value or
     /// 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)
     /// 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
@@ -82,6 +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 .initialized(initializer): return initializer.initialAddress
       case let .unknown(value): return value
       }
@@ -91,7 +94,7 @@ struct LifetimeDependence : CustomStringConvertible {
       switch self {
       case let .caller(argument):
         precondition(argument.ownership != .owned, "only guaranteed or inout arguments have a caller scope")
-      case .access, .local, .unknown:
+      case .access, .local, .global, .unknown:
         break        
       case let .yield(value):
         precondition(value.definingInstruction is BeginApplyInst)
@@ -119,6 +122,7 @@ struct LifetimeDependence : CustomStringConvertible {
         case .owned: return "Owned: "
         case .borrowed: return "Borrowed: "
         case .local: return "Local: "
+        case .global: return "Global: "
         case .initialized: return "Initialized: "
         case .unknown: return "Unknown: "
         }
@@ -254,8 +258,15 @@ extension LifetimeDependence.Scope {
     case let .box(projectBox):
       // Note: the box may be in a borrow scope.
       self.init(base: projectBox.operand.value, context)
-    case .stack, .global, .class, .tail, .pointer, .index, .unidentified:
-      self = .unknown(accessBase.address ?? address)
+    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 {
+        self = .global(ga)
+      } else {
+        self = .unknown(accessBase.address!)
+      }
     case let .argument(arg):
       if arg.convention.isIndirectIn {
         if arg.convention.isGuaranteed {
@@ -321,6 +332,8 @@ extension LifetimeDependence.Scope {
       self = .caller(arg)
     } else if let varScope = VariableScopeInstruction(value.definingInstruction) {
       self = .local(varScope)
+    } else if let ga = value as? GlobalAddrInst {
+      self = .global(ga)
     } else {
       self = .unknown(value)
     }
@@ -365,7 +378,7 @@ extension LifetimeDependence.Scope {
   /// Note: The caller must deinitialize the returned range.
   func computeRange(_ context: Context) -> InstructionRange? {
     switch self {
-    case .caller:
+    case .caller, .global:
       return nil
     case let .access(beginAccess):
       var range = InstructionRange(begin: beginAccess, context)

test/SILOptimizer/lifetime_dependence/semantics.swift

@@ -39,25 +39,25 @@ internal func _overrideLifetime<
 
 // Lifetime dependence semantics by example.
 public struct Span<T>: ~Escapable {
-  private var base: UnsafePointer<T>
+  private var base: UnsafePointer<T>?
   private var count: Int
 
   @lifetime(borrow base)
-  init(base: UnsafePointer<T>, count: Int) {
+  init(base: UnsafePointer<T>?, count: Int) {
     self.base = base
     self.count = count
   }
 
   @lifetime(borrow generic)
-  init<S>(base: UnsafePointer<T>, count: Int, generic: borrowing S) {
+  init<S>(base: UnsafePointer<T>?, count: Int, generic: borrowing S) {
     self.base = base
     self.count = count
   }
 }
 
 extension Span {
   consuming func dropFirst() -> Span<T> {
-    let nextPointer = self.base + 1
+    let nextPointer = self.base.flatMap { $0 + 1 }
     let local = Span(base: nextPointer, count: self.count - 1)
     return _overrideLifetime(local, copying: self)
   }
@@ -67,8 +67,10 @@ extension Span {
   mutating func droppingPrefix(length: Int) -> /* */ Span<T> {
     let oldBase = base
     let result = Span(base: oldBase, count: length)
-    self.base += length
-    self.count -= length
+    if let base = self.base {
+      self.base = base + length
+      self.count -= length
+    }
     return _overrideLifetime(result, copying: self)
   }
 }
@@ -314,6 +316,28 @@ public func testTrivialInoutBorrow(p: inout UnsafePointer<Int>) -> Span<Int> {
   return Span(base: p, count: 1)
 }
 
+// =============================================================================
+// Scoped dependence on global values
+// =============================================================================
+
+private let immortalInt = 0
+
+private let immortalString = ""
+
+@lifetime(immortal)
+func testImmortalInt() -> Span<Int> {
+  let nilBasedBuffer = UnsafeBufferPointer<Int>(start: nil, count: 0)
+  let span = Span(base: nilBasedBuffer.baseAddress, count: nilBasedBuffer.count)
+  return _overrideLifetime(span, borrowing: immortalInt)
+}
+
+@lifetime(immortal)
+func testImmortalString() -> Span<String> {
+  let nilBasedBuffer = UnsafeBufferPointer<String>(start: nil, count: 0)
+  let span = Span(base: nilBasedBuffer.baseAddress, count: nilBasedBuffer.count)
+  return _overrideLifetime(span, borrowing: immortalString)
+}
+
 // =============================================================================
 // Scoped dependence on mutable values
 // =============================================================================