Add new generalized cloner.

Author: MAJKFL

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocBoxToStack.swift

@@ -311,10 +311,9 @@ private struct FunctionSpecializations {
       // This can happen if a previous run of the pass already created this specialization.
       return
     }
-    let cloner = SpecializationCloner(emptySpecializedFunction: specializedFunc, context)
-    cloner.cloneFunctionBody(from: original)
-
     context.buildSpecializedFunction(specializedFunction: specializedFunc) { (specializedFunc, specContext) in
+      cloneFunction(from: original, toEmpty: specializedFunc, specContext)
+
       replaceBoxWithStackArguments(in: specializedFunc, original: original, specContext)
     }
     context.notifyNewFunction(function: specializedFunc, derivedFrom: original)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift

@@ -247,9 +247,10 @@ private func getOrCreateSpecializedFunction(
   context.buildSpecializedFunction(
     specializedFunction: specializedFunction,
     buildFn: { (emptySpecializedFunction, functionPassContext) in
-      let closureSpecCloner = SpecializationCloner(
-        emptySpecializedFunction: emptySpecializedFunction, functionPassContext)
+      var closureSpecCloner = Cloner(
+        cloneToEmptyFunction: emptySpecializedFunction, functionPassContext)
       closureSpecCloner.cloneAndSpecializeFunctionBody(using: pullbackClosureInfo)
+      closureSpecCloner.deinitialize()
     })
 
   return (specializedFunction, false)
@@ -731,15 +732,14 @@ private func markConvertedAndReabstractedClosuresAsUsed(
   }
 }
 
-extension SpecializationCloner {
+extension Cloner where Context == FunctionPassContext {
   fileprivate func cloneAndSpecializeFunctionBody(using pullbackClosureInfo: PullbackClosureInfo) {
     self.cloneEntryBlockArgsWithoutOrigClosures(usingOrigCalleeAt: pullbackClosureInfo)
 
     let (allSpecializedEntryBlockArgs, closureArgIndexToAllClonedReleasableClosures) =
       cloneAllClosures(at: pullbackClosureInfo)
 
-    self.cloneFunctionBody(
-      from: pullbackClosureInfo.pullbackFn, entryBlockArguments: allSpecializedEntryBlockArgs)
+    self.cloneFunctionBody(from: pullbackClosureInfo.pullbackFn, entryBlockArguments: allSpecializedEntryBlockArgs)
 
     self.insertCleanupCodeForClonedReleasableClosures(
       from: pullbackClosureInfo,
@@ -750,8 +750,8 @@ extension SpecializationCloner {
     usingOrigCalleeAt pullbackClosureInfo: PullbackClosureInfo
   ) {
     let originalEntryBlock = pullbackClosureInfo.pullbackFn.entryBlock
-    let clonedFunction = self.cloned
-    let clonedEntryBlock = self.entryBlock
+    let clonedFunction = self.targetFunction
+    let clonedEntryBlock = self.getOrCreateEntryBlock()
 
     originalEntryBlock.arguments
       .enumerated()
@@ -782,7 +782,8 @@ extension SpecializationCloner {
     )
   {
     func entryBlockArgsWithOrigClosuresSkipped() -> [Value?] {
-      var clonedNonClosureEntryBlockArgs = self.entryBlock.arguments.makeIterator()
+      let clonedEntryBlock = self.getOrCreateEntryBlock()
+      var clonedNonClosureEntryBlockArgs = clonedEntryBlock.arguments.makeIterator()
 
       return pullbackClosureInfo.pullbackFn
         .entryBlock
@@ -823,8 +824,8 @@ extension SpecializationCloner {
   {
     let (origToClonedValueMap, capturedArgRange) = self.addEntryBlockArgs(
       forValuesCapturedBy: closureArgDesc)
-    let clonedFunction = self.cloned
-    let clonedEntryBlock = self.entryBlock
+    let clonedFunction = self.targetFunction
+    let clonedEntryBlock = self.getOrCreateEntryBlock()
     let clonedClosureArgs = Array(clonedEntryBlock.arguments[capturedArgRange])
 
     let builder =
@@ -853,8 +854,8 @@ extension SpecializationCloner {
     -> (origToClonedValueMap: [HashableValue: Value], capturedArgRange: Range<Int>)
   {
     var origToClonedValueMap: [HashableValue: Value] = [:]
-    let clonedFunction = self.cloned
-    let clonedEntryBlock = self.entryBlock
+    let clonedFunction = self.targetFunction
+    let clonedEntryBlock = self.getOrCreateEntryBlock()
 
     let capturedArgRangeStart = clonedEntryBlock.arguments.count
 
@@ -908,8 +909,8 @@ extension SpecializationCloner {
       }
     }
 
-    if self.context.needFixStackNesting {
-      self.context.fixStackNesting(in: self.cloned)
+    if (self.context.needFixStackNesting) {
+      self.context.fixStackNesting(in: targetFunction)
     }
   }
 }
@@ -1425,12 +1426,10 @@ private struct PullbackClosureInfo {
   }
 
   func specializedCalleeName(_ context: FunctionPassContext) -> String {
-    let closureArgs = Array(self.closureArgDescriptors.map { $0.closure })
-    let closureIndices = Array(self.closureArgDescriptors.map { $0.closureArgIndex })
-
-    return context.mangle(
-      withClosureArguments: closureArgs, closureArgIndices: closureIndices,
-      from: pullbackFn)
+    let closureArgs = Array(self.closureArgDescriptors.map {
+      (argumentIndex: $0.closureArgIndex, argumentValue: $0.closure)
+    })
+    return context.mangle(withClosureArguments: closureArgs, from: pullbackFn)
   }
 }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -271,7 +271,7 @@ private indirect enum GlobalInitValue {
 
   /// Creates SIL for this global init value in the initializer of the `global`.
   func materialize(into global: GlobalVariable, from function: Function, _ context: FunctionPassContext) {
-    var cloner = StaticInitCloner(cloneTo: global, context)
+    var cloner = Cloner(cloneToGlobal: global, context)
     defer { cloner.deinitialize() }
     let builder = Builder(staticInitializerOf: global, context)
 
@@ -280,7 +280,7 @@ private indirect enum GlobalInitValue {
 
   private func materializeRecursively(
     type: Type,
-    _ cloner: inout StaticInitCloner<FunctionPassContext>,
+    _ cloner: inout Cloner<FunctionPassContext>,
     _ builder: Builder,
     _ function: Function
   ) -> Value {
@@ -289,7 +289,7 @@ private indirect enum GlobalInitValue {
       fatalError("cannot materialize undefined init value")
 
     case .constant(let value):
-      return cloner.clone(value)
+      return cloner.cloneRecursivelyToGlobal(value: value)
 
     case .aggregate(let fields):
       if type.isStruct {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -364,13 +364,13 @@ private func constructObject(of allocRef: AllocRefInstBase,
                              inInitializerOf global: GlobalVariable,
                              _ storesToClassFields: [StoreInst], _ storesToTailElements: [StoreInst],
                              _ context: FunctionPassContext) {
-  var cloner = StaticInitCloner(cloneTo: global, context)
+  var cloner = Cloner(cloneToGlobal: global, context)
   defer { cloner.deinitialize() }
 
   // Create the initializers for the fields
   var objectArgs = [Value]()
   for store in storesToClassFields {
-    objectArgs.append(cloner.clone(store.source as! SingleValueInstruction))
+    objectArgs.append(cloner.cloneRecursivelyToGlobal(value: store.source as! SingleValueInstruction))
   }
   let globalBuilder = Builder(staticInitializerOf: global, context)
 
@@ -382,15 +382,15 @@ private func constructObject(of allocRef: AllocRefInstBase,
       for elementIdx in 0..<allocRef.numTailElements! {
         let tupleElems = (0..<numTailTupleElems).map { tupleIdx in
             let store = storesToTailElements[elementIdx * numTailTupleElems + tupleIdx]
-            return cloner.clone(store.source as! SingleValueInstruction)
+            return cloner.cloneRecursivelyToGlobal(value: store.source as! SingleValueInstruction)
         }
         let tuple = globalBuilder.createTuple(type: allocRef.tailAllocatedTypes[0], elements: tupleElems)
         objectArgs.append(tuple)
       }
     } else {
       // The non-tuple element case.
       for store in storesToTailElements {
-        objectArgs.append(cloner.clone(store.source as! SingleValueInstruction))
+        objectArgs.append(cloner.cloneRecursivelyToGlobal(value: store.source as! SingleValueInstruction))
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyLoad.swift

@@ -104,10 +104,10 @@ extension LoadInst : OnoneSimplifiable, SILCombineSimplifiable {
     if !globalInitVal.canBeCopied(into: parentFunction, context) {
       return false
     }
-    var cloner = StaticInitCloner(cloneBefore: self, context)
+    var cloner = Cloner(cloneBefore: self, context)
     defer { cloner.deinitialize() }
 
-    let initVal = cloner.clone(globalInitVal)
+    let initVal = cloner.cloneRecursivelyToGlobal(value: globalInitVal)
 
     uses.replaceAll(with: initVal, context)
     // Also erases a builtin "once" on which the global_addr depends on. This is fine
@@ -323,7 +323,7 @@ private extension Value {
         return false
       }
       if let fri = value as? FunctionRefInst {
-        if function.isAnySerialized, 
+        if function.isAnySerialized,
            !fri.referencedFunction.hasValidLinkageForFragileRef(function.serializedKind)
         {
           return false
@@ -447,4 +447,3 @@ private func getGlobalInitialization(
   }
   return nil
 }
-

SwiftCompilerSources/Sources/Optimizer/PassManager/ContextCommon.swift

@@ -152,3 +152,28 @@ extension MutatingContext {
     bridgedPassContext.notifyDependencyOnBodyOf(otherFunction.bridged)
   }
 }
+extension Cloner where Context == FunctionPassContext {
+  func getOrCreateEntryBlock() -> BasicBlock {
+    if let entryBlock = targetFunction.blocks.first {
+      return entryBlock
+    }
+    return targetFunction.appendNewBlock(context)
+  }
+
+  func cloneFunctionBody(from originalFunction: Function, entryBlockArguments: [Value]) {
+    entryBlockArguments.withBridgedValues { bridgedEntryBlockArgs in
+      let entryBlock = getOrCreateEntryBlock()
+      bridged.cloneFunctionBody(originalFunction.bridged, entryBlock.bridged, bridgedEntryBlockArgs)
+    }
+  }
+
+  func cloneFunctionBody(from originalFunction: Function) {
+    bridged.cloneFunctionBody(originalFunction.bridged)
+  }
+}
+
+func cloneFunction(from originalFunction: Function, toEmpty targetFunction: Function, _ context: FunctionPassContext) {
+  var cloner = Cloner(cloneToEmptyFunction: targetFunction, context)
+  defer { cloner.deinitialize() }
+  cloner.cloneFunctionBody(from: originalFunction)
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/FunctionPassContext.swift

@@ -92,15 +92,11 @@ struct FunctionPassContext : MutatingContext {
     return String(taking: bridgedPassContext.mangleOutlinedVariable(function.bridged))
   }
 
-  func mangle(withClosureArguments closureArgs: [Value], closureArgIndices: [Int], from applySiteCallee: Function) -> String {
-    closureArgs.withBridgedValues { bridgedClosureArgsRef in
-      closureArgIndices.withBridgedArrayRef{bridgedClosureArgIndicesRef in
-        String(taking: bridgedPassContext.mangleWithClosureArgs(
-          bridgedClosureArgsRef,
-          bridgedClosureArgIndicesRef,
-          applySiteCallee.bridged
-        ))
-      }
+  func mangle(withClosureArguments closureArgs: [(argumentIndex: Int, argumentValue: Value)],
+              from applySiteCallee: Function
+  ) -> String {
+    closureArgs.withBridgedArrayRef{ bridgedClosureArgs in
+      String(taking: bridgedPassContext.mangleWithClosureArgs(bridgedClosureArgs, applySiteCallee.bridged))
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt

@@ -8,7 +8,6 @@
 
 swift_compiler_sources(Optimizer
   AddressUtils.swift
-  SpecializationCloner.swift
   Devirtualization.swift
   EscapeUtils.swift
   FunctionSignatureTransforms.swift
@@ -18,5 +17,4 @@ swift_compiler_sources(Optimizer
   LocalVariableUtils.swift
   OptUtils.swift
   OwnershipLiveness.swift
-  StaticInitCloner.swift
 )