Merge pull request #67829 from eeckstein/global-addr-in-initializer

Optimizer: support statically initialized globals which contain pointers to other globals

Author: swift-ci

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -65,6 +65,12 @@ let initializeStaticGlobalsPass = FunctionPass(name: "initialize-static-globals"
 
   _ = cloner.clone(storeToGlobal.source)
 
+  // The initial value can contain a `begin_access` if it references another global variable by address, e.g.
+  //   var p = Point(x: 10, y: 20)
+  //   let o = UnsafePointer(&p)
+  //
+  allocInst.global.stripAccessInstructionFromInitializer(context)
+
   context.erase(instruction: allocInst)
   context.erase(instruction: storeToGlobal)
   context.removeTriviallyDeadInstructionsIgnoringDebugUses(in: function)
@@ -94,21 +100,19 @@ private func getGlobalInitialization(of function: Function) -> (allocInst: Alloc
     switch inst {
     case is ReturnInst,
          is DebugValueInst,
-         is DebugStepInst:
+         is DebugStepInst,
+         is BeginAccessInst,
+         is EndAccessInst:
       break
     case let agi as AllocGlobalInst:
       if allocInst != nil {
         return nil
       }
       allocInst = agi
     case let ga as GlobalAddrInst:
-      if globalAddr != nil {
-        return nil
-      }
-      guard let agi = allocInst, agi.global == ga.global else {
-        return nil
+      if let agi = allocInst, agi.global == ga.global {
+        globalAddr = ga
       }
-      globalAddr = ga
     case let si as StoreInst:
       if store != nil {
         return nil

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -302,6 +302,12 @@ private func constructObject(of allocRef: AllocRefInstBase,
     }
   }
   globalBuilder.createObject(type: allocRef.type, arguments: objectArgs, numBaseElements: storesToClassFields.count)
+
+  // The initial value can contain a `begin_access` if it references another global variable by address, e.g.
+  //   var p = Point(x: 10, y: 20)
+  //   let a = [UnsafePointer(&p)]
+  //
+  global.stripAccessInstructionFromInitializer(context)
 }
 
 private func replace(object allocRef: AllocRefInstBase,
@@ -339,6 +345,9 @@ private extension Value {
     guard let svi = self as? SingleValueInstruction else {
       return false
     }
+    if let beginAccess = svi as? BeginAccessInst {
+      return beginAccess.address.isValidGlobalInitValue
+    }
     if !svi.isValidInStaticInitializerOfGlobal {
       return false
     }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -19,6 +19,7 @@ swift_compiler_sources(Optimizer
   SimplifyInitEnumDataAddr.swift
   SimplifyLoad.swift
   SimplifyPartialApply.swift
+  SimplifyPointerToAddress.swift
   SimplifyRefCasts.swift
   SimplifyRetainReleaseValue.swift
   SimplifyStrongRetainRelease.swift

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyPointerToAddress.swift

@@ -0,0 +1,41 @@
+//===--- SimplifyPointerToAddress.swift -----------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+extension PointerToAddressInst : OnoneSimplifyable {
+
+  /// For a redundant pair of pointer-address conversions, e.g.
+  ///
+  ///   %2 = address_to_pointer %1
+  ///   %3 = pointer_to_address %2 [strict]
+  ///
+  /// replace all uses of %3 with %1.
+  ///
+  func simplify(_ context: SimplifyContext) {
+    if let atp = self.pointer as? AddressToPointerInst,
+       atp.address.type == self.type,
+       self.isStrict,
+
+       // If the pointer is within an ownership scope, the transformation can break ownership rules, e.g.
+       //   %2 = begin_borrow %1
+       //   %3 = ref_tail_addr %2
+       //   %4 = address_to_pointer %3
+       //   end_borrow %2
+       //   %5 = pointer_to_address %4             <- cannot replace %5 with %3!
+       //
+       !atp.address.accessBase.hasLocalOwnershipLifetime
+    {
+      self.uses.replaceAll(with: atp.address, context)
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -225,7 +225,7 @@ private extension Value {
     var singleUseValue: any Value = self
     var path = SmallProjectionPath()
     while true {
-      guard let use = singleUseValue.uses.singleNonDebugUse else {
+      guard let use = singleUseValue.uses.singleRelevantUse else {
         return nil
       }
 
@@ -247,6 +247,8 @@ private extension Value {
         default:
           return nil
         }
+      case is PointerToAddressInst, is AddressToPointerInst, is BeginAccessInst:
+        break
       default:
         return nil
       }
@@ -334,3 +336,27 @@ fileprivate struct FunctionWorklist {
     }
   }
 }
+
+private extension UseList {
+  var singleRelevantUse: Operand? {
+    var singleUse: Operand?
+    for use in self {
+      switch use.instruction {
+      case is DebugValueInst,
+           // The initializer value of a global can contain access instructions if it references another
+           // global variable by address, e.g.
+           //   var p = Point(x: 10, y: 20)
+           //   let o = UnsafePointer(&p)
+           // Therefore ignore the `end_access` use of a `begin_access`.
+           is EndAccessInst:
+        continue
+      default:
+        if singleUse != nil {
+          return nil
+        }
+        singleUse = use
+      }
+    }
+    return singleUse
+  }
+}

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -131,6 +131,25 @@ enum AccessBase : CustomStringConvertible, Hashable {
         return nil
     }
   }
+
+  /// True if this access base may be derived from a reference that is only valid within a locally
+  /// scoped OSSA lifetime. For example:
+  ///
+  ///   %reference = begin_borrow %1
+  ///   %base = ref_tail_addr %reference     <- %base must not be used outside the borrow scope
+  ///   end_borrow %reference
+  ///
+  /// This is not true for scoped storage such as alloc_stack and @in arguments.
+  ///
+  var hasLocalOwnershipLifetime: Bool {
+    if let reference = reference {
+      // Conservatively assume that everything which is a ref-counted object is within an ownership scope.
+      // TODO: we could e.g. exclude guaranteed function arguments.
+      return reference.ownership != .none
+    }
+    return false
+  }
+
   /// True, if the baseAddress is of an immutable property or global variable
   var isLet: Bool {
     switch self {

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -431,3 +431,31 @@ extension FullApplySite {
     return false
   }
 }
+
+extension GlobalVariable {
+  /// Removes all `begin_access` and `end_access` instructions from the initializer.
+  ///
+  /// Access instructions are not allowed in the initializer, because the initializer must not contain
+  /// instructions with side effects (initializer instructions are not executed).
+  /// Exclusivity checking does not make sense in the initializer.
+  ///
+  /// The initializer functions of globals, which reference other globals by address, contain access
+  /// instructions. After the initializing code is copied to the global's initializer, those access
+  /// instructions must be stripped.
+  func stripAccessInstructionFromInitializer(_ context: FunctionPassContext) {
+    guard let initInsts = staticInitializerInstructions else {
+      return
+    }
+    for initInst in initInsts {
+      switch initInst {
+      case let beginAccess as BeginAccessInst:
+        beginAccess.uses.replaceAll(with: beginAccess.address, context)
+        context.erase(instruction: beginAccess)
+      case let endAccess as EndAccessInst:
+        context.erase(instruction: endAccess)
+      default:
+        break
+      }
+    }
+  }
+}

SwiftCompilerSources/Sources/SIL/BasicBlock.swift

@@ -97,7 +97,7 @@ public struct InstructionList : CollectionLikeSequence, IteratorProtocol {
 
   public func reversed() -> ReverseInstructionList {
     if let inst = currentInstruction {
-      let lastInst = inst.parentBlock.bridged.getLastInst().instruction
+      let lastInst = inst.bridged.getLastInstOfParent().instruction
       return ReverseInstructionList(first: lastInst)
     }
     return ReverseInstructionList(first: nil)

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -43,8 +43,18 @@ final public class GlobalVariable : CustomStringConvertible, HasShortDescription
     return bridged.isAvailableExternally()
   }
 
+  public var staticInitializerInstructions: InstructionList? {
+    if let firstStaticInitInst = bridged.getFirstStaticInitInst().instruction {
+      return InstructionList(first: firstStaticInitInst)
+    }
+    return nil
+  }
+
   public var staticInitValue: SingleValueInstruction? {
-    bridged.getStaticInitializerValue().instruction as? SingleValueInstruction
+    if let staticInitInsts = staticInitializerInstructions {
+      return staticInitInsts.reversed().first! as? SingleValueInstruction
+    }
+    return nil
   }
 
   /// True if the global's linkage and resilience expansion allow the global
@@ -135,7 +145,9 @@ extension Instruction {
          is ObjectInst,
          is ValueToBridgeObjectInst,
          is ConvertFunctionInst,
-         is ThinToThickFunctionInst:
+         is ThinToThickFunctionInst,
+         is AddressToPointerInst,
+         is GlobalAddrInst:
       return true
     default:
       return false

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -457,6 +457,7 @@ class AddressToPointerInst : SingleValueInstruction, UnaryInstruction {
 final public
 class PointerToAddressInst : SingleValueInstruction, UnaryInstruction {
   public var pointer: Value { operand.value }
+  public var isStrict: Bool { bridged.PointerToAddressInst_isStrict() }
 }
 
 final public