Swift Optimizer: add APIs to copy from or to a global static initializer

* `Context.copyStaticInitializer(fromInitValue:, to:)`
* `FunctionPassContext.createStaticInitializer(for:,initValue:)`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -71,6 +71,33 @@ extension MutatingContext {
     erase(instruction: inst)
   }
 
+  /// 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 {
+      if !inst.isDeleted {
+        notifyInstructionChanged(inst)
+      }
+      if let next = inst.next {
+        inst = next
+      } else {
+        inst = inst.parentBlock.next!.instructions.first!
+      }
+    }
+  }
+
   func tryDeleteDeadClosure(closure: SingleValueInstruction) -> Bool {
     _bridged.tryDeleteDeadClosure(closure.bridged)
   }
@@ -148,6 +175,12 @@ struct FunctionPassContext : MutatingContext {
   fileprivate func notifyEffectsChanged() {
     _bridged.asNotificationHandler().notifyChanges(.effectsChanged)
   }
+
+  /// 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)
+  }
 }
 
 struct SimplifyContext : MutatingContext {

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -26,7 +26,7 @@ public struct Builder {
   private let notificationHandler: BridgedChangeNotificationHandler
   private let notifyNewInstruction: (Instruction) -> ()
 
-  private var bridged: BridgedBuilder {
+  public var bridged: BridgedBuilder {
     switch insertAt {
     case .before(let inst):
       return BridgedBuilder(insertBefore: inst.bridged.optional,

include/swift/SILOptimizer/OptimizerBridging.h

@@ -207,6 +207,16 @@ struct BridgedPassContext {
   SWIFT_IMPORT_UNSAFE
   OptionalBridgedValue constantFoldBuiltin(BridgedInstruction builtin) const;
 
+  void createStaticInitializer(BridgedGlobalVar global, BridgedInstruction initValue) const;
+
+  struct StaticInitCloneResult {
+    OptionalBridgedInstruction firstClonedInst;
+    OptionalBridgedValue clonedInitValue;
+  };
+
+  SWIFT_IMPORT_UNSAFE
+  StaticInitCloneResult copyStaticInitializer(BridgedValue initValue, BridgedBuilder b) const;
+
   SWIFT_IMPORT_UNSAFE
   BridgedValue getSILUndef(swift::SILType type) const {
     return {swift::SILUndef::get(type, *invocation->getFunction())};

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -357,30 +357,43 @@ class StaticInitCloner : public SILCloner<StaticInitCloner> {
   /// don't have any operands).
   llvm::SmallVector<SILInstruction *, 8> readyToClone;
 
-  SILInstruction *insertionPoint = nullptr;
+  SILDebugLocation insertLoc;
+
+  SILInstruction *firstClonedInst = nullptr;
 
 public:
   StaticInitCloner(SILGlobalVariable *gVar)
-      : SILCloner<StaticInitCloner>(gVar) {}
+      : SILCloner<StaticInitCloner>(gVar),
+        insertLoc(ArtificialUnreachableLocation(), nullptr) {}
 
   StaticInitCloner(SILInstruction *insertionPoint)
       : SILCloner<StaticInitCloner>(*insertionPoint->getFunction()),
-        insertionPoint(insertionPoint) {
+        insertLoc(insertionPoint->getDebugLocation()) {
     Builder.setInsertionPoint(insertionPoint);
   }
 
+  StaticInitCloner(const SILBuilder &builder)
+    : SILCloner<StaticInitCloner>(builder.getFunction()),
+      insertLoc(ArtificialUnreachableLocation(), nullptr) {
+    Builder.setInsertionPoint(builder.getInsertionBB(), builder.getInsertionPoint());
+    if (builder.getInsertionPoint() != builder.getInsertionBB()->end())
+      insertLoc = builder.getInsertionPoint()->getDebugLocation();
+  }
+
   /// Add \p InitVal and all its operands (transitively) for cloning.
   ///
   /// Note: all init values must are added, before calling clone().
   /// Returns false if cloning is not possible, e.g. if we would end up cloning
   /// a reference to a private function into a function which is serialized.
-  bool add(SILInstruction *initVal);
+  bool add(SILValue initVal);
 
   /// Clone \p InitVal and all its operands into the initializer of the
   /// SILGlobalVariable.
   ///
   /// \return Returns the cloned instruction in the SILGlobalVariable.
-  SingleValueInstruction *clone(SingleValueInstruction *initVal);
+  SILValue clone(SILValue initVal);
+
+  SILInstruction *getFirstClonedInst() const { return firstClonedInst; }
 
   /// Convenience function to clone a single \p InitVal.
   static void appendToInitializer(SILGlobalVariable *gVar,
@@ -393,16 +406,19 @@ class StaticInitCloner : public SILCloner<StaticInitCloner> {
   }
 
 protected:
+
+  void postProcess(SILInstruction *Orig, SILInstruction *Cloned) {
+    if (!firstClonedInst)
+      firstClonedInst = Cloned;
+    SILCloner<StaticInitCloner>::postProcess(Orig, Cloned);
+  }
+
   SILLocation remapLocation(SILLocation loc) {
-    if (insertionPoint)
-      return insertionPoint->getLoc();
-    return ArtificialUnreachableLocation();
+    return insertLoc.getLocation();
   }
 
   const SILDebugScope *remapScope(const SILDebugScope *DS) {
-    if (insertionPoint)
-      return insertionPoint->getDebugScope();
-    return nullptr;
+    return insertLoc.getScope();
   }
 };
 

lib/SILOptimizer/IPO/GlobalOpt.cpp

@@ -348,7 +348,7 @@ static void replaceLoadsFromGlobal(SILValue addr,
   for (Operand *use : addr->getUses()) {
     SILInstruction *user = use->getUser();
     if (auto *load = dyn_cast<LoadInst>(user)) {
-      SingleValueInstruction *clonedInitVal = cloner.clone(initVal);
+      SingleValueInstruction *clonedInitVal = cast<SingleValueInstruction>(cloner.clone(initVal));
       load->replaceAllUsesWith(clonedInitVal);
       continue;
     }

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -27,6 +27,7 @@
 #include "swift/SILOptimizer/OptimizerBridging.h"
 #include "swift/SILOptimizer/PassManager/PrettyStackTrace.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "swift/SILOptimizer/Utils/BasicBlockOptUtils.h"
 #include "swift/SILOptimizer/Utils/ConstantFolding.h"
 #include "swift/SILOptimizer/Utils/CFGOptUtils.h"
 #include "swift/SILOptimizer/Utils/OptimizerStatsUtils.h"
@@ -1436,6 +1437,21 @@ OptionalBridgedValue BridgedPassContext::constantFoldBuiltin(BridgedInstruction
   return {::constantFoldBuiltin(bi, resultsInError)};
 }
 
+void BridgedPassContext::createStaticInitializer(BridgedGlobalVar global, BridgedInstruction initValue) const {
+  StaticInitCloner::appendToInitializer(global.getGlobal(), initValue.getAs<SingleValueInstruction>());
+}
+
+BridgedPassContext::StaticInitCloneResult BridgedPassContext::
+copyStaticInitializer(BridgedValue initValue, BridgedBuilder b) const {
+  swift::SILBuilder builder(b.insertBefore.getInst(), b.insertAtEnd.getBlock(), b.loc.getScope());
+  StaticInitCloner cloner(builder);
+  if (!cloner.add(initValue.getSILValue())) {
+    return {{nullptr}, {nullptr}};
+  }
+  SILValue result = cloner.clone(initValue.getSILValue());
+  return {{cloner.getFirstClonedInst()->asSILNode()}, {result}};
+}
+
 void BridgedPassContext::fixStackNesting(BridgedFunction function) const {
   switch (StackNesting::fixNesting(function.getFunction())) {
     case StackNesting::Changes::None:

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -996,7 +996,7 @@ SILInstruction *SILCombiner::visitLoadInst(LoadInst *LI) {
   if (SingleValueInstruction *initVal = getValueFromStaticLet(LI->getOperand())) {
     StaticInitCloner cloner(LI);
     if (cloner.add(initVal)) {
-      return cloner.clone(initVal);
+      return cloner.clone(initVal).getDefiningInstruction();
     }
   }
 

lib/SILOptimizer/Utils/BasicBlockOptUtils.cpp

@@ -310,9 +310,11 @@ bool SinkAddressProjections::cloneProjections() {
   return true;
 }
 
-bool StaticInitCloner::add(SILInstruction *initVal) {
+bool StaticInitCloner::add(SILValue initVal) {
+  SILInstruction *initInst = initVal->getDefiningInstruction();
+
   // Don't schedule an instruction twice for cloning.
-  if (numOpsToClone.count(initVal) != 0)
+  if (numOpsToClone.count(initInst) != 0)
     return true;
 
   if (auto *funcRef = dyn_cast<FunctionRefInst>(initVal)) {
@@ -324,25 +326,25 @@ bool StaticInitCloner::add(SILInstruction *initVal) {
     }
   }
 
-  ArrayRef<Operand> operands = initVal->getAllOperands();
-  numOpsToClone[initVal] = operands.size();
+  ArrayRef<Operand> operands = initInst->getAllOperands();
+  numOpsToClone[initInst] = operands.size();
   if (operands.empty()) {
     // It's an instruction without operands, e.g. a literal. It's ready to be
     // cloned first.
-    readyToClone.push_back(initVal);
+    readyToClone.push_back(initInst);
   } else {
     // Recursively add all operands.
     for (const Operand &operand : operands) {
-      if (!add(cast<SingleValueInstruction>(operand.get())))
+      if (!add(operand.get()))
         return false;
     }
   }
   return true;
 }
 
-SingleValueInstruction *
-StaticInitCloner::clone(SingleValueInstruction *initVal) {
-  assert(numOpsToClone.count(initVal) != 0 && "initVal was not added");
+SILValue StaticInitCloner::clone(SILValue initVal) {
+  SILInstruction *initInst = initVal->getDefiningInstruction();
+  assert(numOpsToClone.count(initInst) != 0 && "initVal was not added");
 
   if (!isValueCloned(initVal)) {
     // Find the right order to clone: all operands of an instruction must be
@@ -361,9 +363,9 @@ StaticInitCloner::clone(SingleValueInstruction *initVal) {
             readyToClone.push_back(user);
         }
       }
-      if (inst == initVal)
+      if (inst == initInst)
         break;
     }
   }
-  return cast<SingleValueInstruction>(getMappedValue(initVal));
+  return getMappedValue(initVal);
 }