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

include/swift/SIL/SILBridging.h

@@ -367,7 +367,7 @@ struct BridgedGlobalVar {
   }
 
   SWIFT_IMPORT_UNSAFE
-  inline OptionalBridgedInstruction getStaticInitializerValue() const;
+  inline OptionalBridgedInstruction getFirstStaticInitInst() const;
 
   bool canBeInitializedStatically() const;
 
@@ -467,6 +467,9 @@ struct BridgedInstruction {
   SWIFT_IMPORT_UNSAFE
   inline BridgedBasicBlock getParent() const;
 
+  SWIFT_IMPORT_UNSAFE
+  inline BridgedInstruction getLastInstOfParent() const;
+
   bool isDeleted() const {
     return getInst()->isDeleted();
   }
@@ -546,6 +549,9 @@ struct BridgedInstruction {
     return getAs<swift::BuiltinInst>()->getSubstitutions();
   }
 
+  bool PointerToAddressInst_isStrict() const {
+    return getAs<swift::PointerToAddressInst>()->isStrict();
+  }
 
   bool AddressToPointerInst_needsStackProtection() const {
     return getAs<swift::AddressToPointerInst>()->needsStackProtection();
@@ -1413,11 +1419,12 @@ OptionalBridgedBasicBlock BridgedFunction::getLastBlock() const {
   return {getFunction()->empty() ? nullptr : &*getFunction()->rbegin()};
 }
 
-OptionalBridgedInstruction BridgedGlobalVar::getStaticInitializerValue() const {
-  if (swift::SILInstruction *inst = getGlobal()->getStaticInitializerValue()) {
-    return {inst->asSILNode()};
+OptionalBridgedInstruction BridgedGlobalVar::getFirstStaticInitInst() const {
+  if (getGlobal()->begin() == getGlobal()->end()) {
+    return {nullptr};
   }
-  return {nullptr};
+  swift::SILInstruction *firstInst = &*getGlobal()->begin();
+  return {firstInst->asSILNode()};
 }
 
 BridgedInstruction BridgedMultiValueResult::getParent() const {
@@ -1430,6 +1437,10 @@ BridgedBasicBlock BridgedInstruction::getParent() const {
   return {getInst()->getParent()};
 }
 
+inline BridgedInstruction BridgedInstruction::getLastInstOfParent() const {
+  return {getInst()->getParent()->back().asSILNode()};
+}
+
 BridgedSuccessorArray BridgedInstruction::TermInst_getSuccessors() const {
   auto successors = getAs<swift::TermInst>()->getSuccessors();
   return {{successors.data()}, (SwiftInt)successors.size()};

include/swift/SIL/SILGlobalVariable.h

@@ -42,6 +42,7 @@ class SILGlobalVariable
   static SwiftMetatype registeredMetatype;
 
 public:
+  using iterator = SILBasicBlock::iterator;
   using const_iterator = SILBasicBlock::const_iterator;
 
 private:
@@ -182,6 +183,8 @@ class SILGlobalVariable
 
   const_iterator begin() const { return StaticInitializerBlock.begin(); }
   const_iterator end() const { return StaticInitializerBlock.end(); }
+  iterator begin() { return StaticInitializerBlock.begin(); }
+  iterator end() { return StaticInitializerBlock.end(); }
 
   void dropAllReferences() {
     StaticInitializerBlock.dropAllReferences();

lib/IRGen/GenConstant.cpp

@@ -379,6 +379,20 @@ Explosion irgen::emitConstantValue(IRGenModule &IGM, SILValue operand,
     llvm::Type *ty = IGM.getTypeInfo(FRI->getType()).getStorageType();
     fnPtr = llvm::ConstantExpr::getBitCast(fnPtr, ty);
     return fnPtr;
+  } else if (auto *gAddr = dyn_cast<GlobalAddrInst>(operand)) {
+    SILGlobalVariable *var = gAddr->getReferencedGlobal();
+    auto &ti = IGM.getTypeInfo(var->getLoweredType());
+    auto expansion = IGM.getResilienceExpansionForLayout(var);
+    assert(ti.isFixedSize(expansion));
+    if (ti.isKnownEmpty(expansion)) {
+      return llvm::ConstantPointerNull::get(IGM.OpaquePtrTy);
+    }
+
+    Address addr = IGM.getAddrOfSILGlobalVariable(var, ti, NotForDefinition);
+    return addr.getAddress();
+  } else if (auto *atp = dyn_cast<AddressToPointerInst>(operand)) {
+    auto *val = emitConstantValue(IGM, atp->getOperand()).claimNextConstant();
+    return val;
   } else {
     llvm_unreachable("Unsupported SILInstruction in static initializer!");
   }

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -617,6 +617,10 @@ void SwiftPassInvocation::eraseInstruction(SILInstruction *inst) {
   if (silCombiner) {
     silCombiner->eraseInstFromFunction(*inst);
   } else {
-    inst->eraseFromParent();
+    if (inst->isStaticInitializerInst()) {
+      inst->getParent()->erase(inst, *getPassManager()->getModule());
+    } else {
+      inst->eraseFromParent();
+    }
   }
 }

test/SILOptimizer/global_init_with_empty.swift

@@ -19,6 +19,9 @@ struct Mystruct {
   static var structglobal = Mystruct(a: 3, b: Empty(), c: 4)
   // CHECK: @{{[^ ]*tupleglobal[^ ]*}} = hidden global <{ %TSi, %TSi }> <{ %TSi <{ i{{[0-9]+}} 5 }>, %TSi <{ i{{[0-9]+}} 6 }> }>
   static var tupleglobal = (a: 5, b: Empty(), c: 6)
+
+  static var empty: () = ()
+  static var ptrToEmpty = UnsafePointer(&empty)
 }
 
 // CHECK-OUTPUT:      3
@@ -33,3 +36,6 @@ print(Mystruct.tupleglobal.a)
 print(Mystruct.tupleglobal.b)
 // CHECK-OUTPUT-NEXT: 6
 print(Mystruct.tupleglobal.c)
+// CHECK-OUTPUT-NEXT: {{0x0+$}}
+print(Mystruct.ptrToEmpty)
+