Swift SIL/Optimizer: implement cloning of static init values of globals in Swift

* add the StaticInitCloner utility
* remove bridging of `copyStaticInitializer` and `createStaticInitializer`
* add `Context.mangleOutlinedVariable` and `Context.createGlobalVariable`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -56,8 +56,11 @@ let initializeStaticGlobalsPass = FunctionPass(name: "initialize-static-globals"
     return
   }
 
-  context.createStaticInitializer(for: allocInst.global,
-                                  initValue: storeToGlobal.source as! SingleValueInstruction)
+  var cloner = StaticInitCloner(cloneTo: allocInst.global, context)
+  defer { cloner.deinitialize() }
+
+  _ = cloner.clone(storeToGlobal.source)
+
   context.erase(instruction: allocInst)
   context.erase(instruction: storeToGlobal)
 }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift

@@ -21,10 +21,14 @@ extension LoadInst : OnoneSimplifyable {
     guard let globalInitVal = getGlobalInitValue(address: address) else {
       return
     }
-    let builder = Builder(before: self, context)
-    guard let initVal = context.copyStaticInitializer(fromInitValue: globalInitVal, to: builder) else {
+    if !globalInitVal.canBeCopied(into: parentFunction, context) {
       return
     }
+    var cloner = StaticInitCloner(cloneBefore: self, context)
+    defer { cloner.deinitialize() }
+
+    let initVal = cloner.clone(globalInitVal)
+
     uses.replaceAll(with: initVal, context)
     transitivelyErase(load: self, context)
   }
@@ -77,3 +81,36 @@ private func transitivelyErase(load: LoadInst, _ context: SimplifyContext) {
     inst = operandInst
   }
 }
+
+private extension Value {
+  func canBeCopied(into function: Function, _ context: SimplifyContext) -> Bool {
+    if !function.isSerialized {
+      return true
+    }
+
+    // Can't use `ValueSet` because the this value is inside a global initializer and
+    // not inside a function.
+    var worklist = Stack<Value>(context)
+    defer { worklist.deinitialize() }
+
+    var handled = Set<ObjectIdentifier>()
+
+    worklist.push(self)
+    handled.insert(ObjectIdentifier(self))
+
+    while let value = worklist.pop() {
+      if let fri = value as? FunctionRefInst {
+        if !fri.referencedFunction.hasValidLinkageForFragileRef {
+          return false
+        }
+      }
+      for op in value.definingInstruction!.operands {
+        if handled.insert(ObjectIdentifier(op.value)).inserted {
+          worklist.push(op.value)
+        }
+      }
+    }
+    return true
+  }
+}
+

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -127,19 +127,6 @@ extension MutatingContext {
     }
   }
 
-  /// Copies all instructions of a static init value of a global to the insertion point of `builder`.
-  func copyStaticInitializer(fromInitValue: Value, to builder: Builder) -> Value? {
-    let range = _bridged.copyStaticInitializer(fromInitValue.bridged, builder.bridged)
-    guard let result = range.clonedInitValue.value,
-          let firstClonedInst = range.firstClonedInst.instruction else {
-      return nil
-    }
-    let resultInst = result.definingInstruction!
-    notifyNewInstructions(from: firstClonedInst, to: resultInst)
-    notifyInstructionChanged(resultInst)
-    return result
-  }
-
   private func notifyNewInstructions(from: Instruction, to: Instruction) {
     var inst = from
     while inst != to {
@@ -262,10 +249,16 @@ struct FunctionPassContext : MutatingContext {
     return false
   }
 
-  /// Copies `initValue` (including all operand instructions, transitively) to the
-  /// static init value of `global`.
-  func createStaticInitializer(for global: GlobalVariable, initValue: SingleValueInstruction) {
-    _bridged.createStaticInitializer(global.bridged, initValue.bridged)
+  func mangleOutlinedVariable(from function: Function) -> String {
+    let stdString = _bridged.mangleOutlinedVariable(function.bridged)
+    return String(_cxxString: stdString)
+  }
+
+  func createGlobalVariable(name: String, type: Type, isPrivate: Bool) -> GlobalVariable {
+    let gv = name._withStringRef {
+      _bridged.createGlobalVariable($0, type.bridged, isPrivate)
+    }
+    return gv.globalVar
   }
 }
 
@@ -328,6 +321,12 @@ extension Builder {
     self.init(insertAt: .before(firstInst), location: firstInst.location,
               context.notifyInstructionChanged, context._bridged.asNotificationHandler())
   }
+
+  init(staticInitializerOf global: GlobalVariable, _ context: some MutatingContext) {
+    self.init(insertAt: .staticInitializer(global),
+              location: Location.artificialUnreachableLocation,
+              { _ in }, context._bridged.asNotificationHandler())
+  }
 }
 
 //===----------------------------------------------------------------------===//

SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt

@@ -11,4 +11,5 @@ swift_compiler_sources(Optimizer
   OptUtils.swift
   WalkUtils.swift
   AccessUtils.swift
+  StaticInitCloner.swift
 )

SwiftCompilerSources/Sources/Optimizer/Utilities/StaticInitCloner.swift

@@ -0,0 +1,69 @@
+//===--- StaticInitCloner.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
+import OptimizerBridging
+
+/// Clones the initializer value of a GlobalVariable.
+///
+/// Used to transitively clone "constant" instructions, including their operands,
+/// from or to the static initializer value of a GlobalVariable.
+///
+struct StaticInitCloner<Context: MutatingContext> {
+  private var bridged: BridgedCloner
+  private let context: Context
+  private let cloningIntoFunction: Bool
+
+  init(cloneTo global: GlobalVariable, _ context: Context) {
+    self.bridged = BridgedCloner(global.bridged, context._bridged)
+    self.context = context
+    self.cloningIntoFunction = false
+  }
+
+  init(cloneBefore inst: Instruction, _ context: Context) {
+    self.bridged = BridgedCloner(inst.bridged, context._bridged)
+    self.context = context
+    self.cloningIntoFunction = true
+  }
+
+  mutating func deinitialize() {
+    bridged.destroy(context._bridged)
+  }
+
+  /// Transitively clones `value` including its defining instruction's operands.
+  mutating func clone(_ value: Value) -> Value {
+
+    if isCloned(value: value) {
+      return getClonedValue(of: value)
+    }
+
+    let inst = value.definingInstruction!
+    for op in inst.operands {
+      _ = clone(op.value)
+    }
+
+    bridged.clone(inst.bridged)
+    let clonedValue = getClonedValue(of: value)
+    if cloningIntoFunction {
+      context.notifyInstructionChanged(clonedValue.definingInstruction!)
+    }
+    return clonedValue
+  }
+
+  mutating func getClonedValue(of value: Value) -> Value {
+    bridged.getClonedValue(value.bridged).value
+  }
+
+  func isCloned(value: Value) -> Bool {
+    bridged.isValueCloned(value.bridged)
+  }
+}

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -66,14 +66,100 @@ final public class GlobalVariable : CustomStringConvertible, HasShortDescription
 
 extension Instruction {
   public var isValidInStaticInitializerOfGlobal: Bool {
-    return BridgedGlobalVar.isValidStaticInitializer(bridged)
+    // Rule out SILUndef and SILArgument.
+    if operands.contains(where: { $0.value.definingInstruction == nil }) {
+      return false
+    }
+    switch self {
+    case let bi as BuiltinInst:
+      switch bi.id {
+      case .ZeroInitializer:
+        let type = bi.type.isBuiltinVector ? bi.type.builtinVectorElementType : bi.type
+        return type.isBuiltinInteger || type.isBuiltinFloat
+      case .PtrToInt:
+        return bi.operands[0].value is StringLiteralInst
+      case .StringObjectOr:
+        // The first operand can be a string literal (i.e. a pointer), but the
+        // second operand must be a constant. This enables creating a
+        // a pointer+offset relocation.
+        // Note that StringObjectOr requires the or'd bits in the first
+        // operand to be 0, so the operation is equivalent to an addition.
+        return bi.operands[1].value is IntegerLiteralInst
+      case .ZExtOrBitCast:
+        return true;
+      case .USubOver:
+        // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
+        // This pattern appears in UTF8 String literal construction.
+        if let tei = bi.uses.getSingleUser(ofType: TupleExtractInst.self),
+           tei.isResultOfOffsetSubtract {
+          return true
+        }
+        return false
+      case .OnFastPath:
+        return true
+      default:
+        return false
+      }
+    case let tei as TupleExtractInst:
+      // Handle StringObjectOr(tuple_extract(usub_with_overflow(x, offset)), bits)
+      // This pattern appears in UTF8 String literal construction.
+      if tei.isResultOfOffsetSubtract,
+         let bi = tei.uses.getSingleUser(ofType: BuiltinInst.self),
+         bi.id == .StringObjectOr {
+        return true
+      }
+      return false
+    case let sli as StringLiteralInst:
+      switch sli.encoding {
+      case .Bytes, .UTF8:
+        return true
+      case .ObjCSelector:
+        // Objective-C selector string literals cannot be used in static
+        // initializers.
+        return false
+      }
+    case let fri as FunctionRefInst:
+      // TODO: support async function pointers in static globals.
+      return !fri.referencedFunction.isAsync
+    case is StructInst,
+         is TupleInst,
+         is IntegerLiteralInst,
+         is FloatLiteralInst,
+         is ObjectInst,
+         is ValueToBridgeObjectInst,
+         is ConvertFunctionInst,
+         is ThinToThickFunctionInst:
+      return true
+    default:
+      return false
+    }
+  }
+}
+
+// Match the pattern:
+// tuple_extract(usub_with_overflow(x, integer_literal, integer_literal 0), 0)
+private extension TupleExtractInst {
+  var isResultOfOffsetSubtract: Bool {
+    if fieldIndex == 0,
+       let bi = tuple as? BuiltinInst,
+       bi.id == .USubOver,
+       bi.operands[1].value is IntegerLiteralInst,
+       let overFlowFlag = bi.operands[2].value as? IntegerLiteralInst,
+       overFlowFlag.value.isNullValue() {
+      return true
+    }
+    return false
   }
 }
 
 // Bridging utilities
 
 extension BridgedGlobalVar {
-  var globalVar: GlobalVariable { obj.getAs(GlobalVariable.self) }
+  public var globalVar: GlobalVariable { obj.getAs(GlobalVariable.self) }
+
+  public var optional: OptionalBridgedGlobalVar {
+    OptionalBridgedGlobalVar(obj: self.obj)
+  }
 }
 
 extension OptionalBridgedGlobalVar {

include/swift/SIL/SILBridging.h

@@ -363,8 +363,6 @@ struct BridgedGlobalVar {
   inline OptionalBridgedInstruction getStaticInitializerValue() const;
 
   bool canBeInitializedStatically() const;
-
-  static inline bool isValidStaticInitializer(BridgedInstruction inst);
 };
 
 struct OptionalBridgedGlobalVar {
@@ -1285,11 +1283,6 @@ OptionalBridgedInstruction BridgedGlobalVar::getStaticInitializerValue() const {
   return {nullptr};
 }
 
-bool BridgedGlobalVar::isValidStaticInitializer(BridgedInstruction inst) {
-  swift::SILInstruction *i = inst.getInst();
-  return swift::SILGlobalVariable::isValidStaticInitializerInst(i, i->getModule());
-}
-
 BridgedInstruction BridgedMultiValueResult::getParent() const {
   return {getMVResult()->getParent()};
 }

include/swift/SILOptimizer/OptimizerBridging.h

@@ -139,6 +139,27 @@ struct BridgedNodeSet {
   }
 };
 
+namespace swift {
+class ClonerWithFixedLocation;
+}
+
+struct BridgedCloner {
+  swift::ClonerWithFixedLocation * _Nonnull cloner;
+
+  BridgedCloner(BridgedGlobalVar var, BridgedPassContext context);
+
+  BridgedCloner(BridgedInstruction inst, BridgedPassContext context);
+
+  void destroy(BridgedPassContext context);
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedValue getClonedValue(BridgedValue v);
+
+  bool isValueCloned(BridgedValue v) const;
+
+  void clone(BridgedInstruction inst);
+};
+
 struct BridgedPostDomTree {
   swift::PostDominanceInfo * _Nonnull pdi;
 
@@ -220,15 +241,10 @@ struct BridgedPassContext {
 
   bool specializeAppliesInFunction(BridgedFunction function, bool isMandatory) const;
 
-  void createStaticInitializer(BridgedGlobalVar global, BridgedInstruction initValue) const;
-
-  struct StaticInitCloneResult {
-    OptionalBridgedInstruction firstClonedInst;
-    OptionalBridgedValue clonedInitValue;
-  };
+  std::string mangleOutlinedVariable(BridgedFunction function) const;
 
   SWIFT_IMPORT_UNSAFE
-  StaticInitCloneResult copyStaticInitializer(BridgedValue initValue, BridgedBuilder b) const;
+  BridgedGlobalVar createGlobalVariable(llvm::StringRef name, swift::SILType type, bool isPrivate) const;
 
   void inlineFunction(BridgedInstruction apply, bool mandatoryInline) const;
 

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -78,6 +78,8 @@ class SwiftPassInvocation {
   bool aliveNodeSets[NodeSetCapacity];
   int numNodeSetsAllocated = 0;
 
+  int numClonersAllocated = 0;
+
   bool needFixStackNesting = false;
 
   void endPassRunChecks();
@@ -136,6 +138,9 @@ class SwiftPassInvocation {
 
   void endTransformFunction();
 
+  void notifyNewCloner() { numClonersAllocated++; }
+  void notifyClonerDestroyed() { numClonersAllocated--; }
+
   void setNeedFixStackNesting(bool newValue) { needFixStackNesting = newValue; }
   bool getNeedFixStackNesting() const { return needFixStackNesting; }
 };