Optimizer: add Context.createSpecializedFunctionDeclaration

Originally this was a "private" utility for the ClosureSpecialization pass.
Now, make it a general utility which can be used for all kind of function specializations.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift

@@ -234,9 +234,9 @@ private func getOrCreateSpecializedFunction(basedOn callSite: CallSite, _ contex
   let specializedParameters = applySiteCallee.convention.getSpecializedParameters(basedOn: callSite)
 
   let specializedFunction = 
-    context.createFunctionForClosureSpecialization(from: applySiteCallee, withName: specializedFunctionName, 
-                                                   withParams: specializedParameters, 
-                                                   withSerialization: applySiteCallee.isSerialized)
+    context.createSpecializedFunctionDeclaration(from: applySiteCallee, withName: specializedFunctionName,
+                                                 withParams: specializedParameters,
+                                                 makeThin: true, makeBare: true)
 
   context.buildSpecializedFunction(specializedFunction: specializedFunction,
                                    buildFn: { (emptySpecializedFunction, functionPassContext) in 

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -419,18 +419,17 @@ struct FunctionPassContext : MutatingContext {
     return gv.globalVar
   }
 
-  func createFunctionForClosureSpecialization(from applySiteCallee: Function, withName specializedFunctionName: String, 
-                                              withParams specializedParameters: [ParameterInfo], 
-                                              withSerialization isSerialized: Bool) -> Function 
+  func createSpecializedFunctionDeclaration(from original: Function, withName specializedFunctionName: String, 
+                                            withParams specializedParameters: [ParameterInfo],
+                                            makeThin: Bool = false,
+                                            makeBare: Bool = false) -> Function
   {
     return specializedFunctionName._withBridgedStringRef { nameRef in
       let bridgedParamInfos = specializedParameters.map { $0._bridged }
 
       return bridgedParamInfos.withUnsafeBufferPointer { paramBuf in
-        _bridged.ClosureSpecializer_createEmptyFunctionWithSpecializedSignature(nameRef, paramBuf.baseAddress, 
-                                                                                paramBuf.count, 
-                                                                                applySiteCallee.bridged, 
-                                                                                isSerialized).function
+        _bridged.createSpecializedFunctionDeclaration(nameRef, paramBuf.baseAddress, paramBuf.count,
+                                                      original.bridged, makeThin, makeBare).function
       }
     }
   }

include/swift/SILOptimizer/OptimizerBridging.h

@@ -392,11 +392,12 @@ struct BridgedPassContext {
   BRIDGED_INLINE bool enableAddressDependencies() const;
 
   // Closure specializer
-  SWIFT_IMPORT_UNSAFE BridgedFunction ClosureSpecializer_createEmptyFunctionWithSpecializedSignature(BridgedStringRef specializedName,
+  SWIFT_IMPORT_UNSAFE BridgedFunction createSpecializedFunctionDeclaration(BridgedStringRef specializedName,
                                                         const BridgedParameterInfo * _Nullable specializedBridgedParams,
                                                         SwiftInt paramCount,
-                                                        BridgedFunction bridgedApplySiteCallee,
-                                                        bool isSerialized) const;
+                                                        BridgedFunction bridgedOriginal,
+                                                        bool makeThin,
+                                                        bool makeBare) const;
 
   bool completeLifetime(BridgedValue value) const;
 };

lib/SILOptimizer/Utils/OptimizerBridging.cpp

@@ -452,13 +452,14 @@ void BridgedPassContext::moveFunctionBody(BridgedFunction sourceFunc, BridgedFun
 }
 
 BridgedFunction BridgedPassContext::
-ClosureSpecializer_createEmptyFunctionWithSpecializedSignature(BridgedStringRef specializedName,
-                                            const BridgedParameterInfo * _Nullable specializedBridgedParams,
-                                            SwiftInt paramCount,
-                                            BridgedFunction bridgedApplySiteCallee,
-                                            bool isSerialized)  const {
-  auto *applySiteCallee = bridgedApplySiteCallee.getFunction();
-  auto applySiteCalleeType = applySiteCallee->getLoweredFunctionType();
+createSpecializedFunctionDeclaration(BridgedStringRef specializedName,
+                                     const BridgedParameterInfo * _Nullable specializedBridgedParams,
+                                     SwiftInt paramCount,
+                                     BridgedFunction bridgedOriginal,
+                                     bool makeThin,
+                                     bool makeBare)  const {
+  auto *original = bridgedOriginal.getFunction();
+  auto originalType = original->getLoweredFunctionType();
 
   llvm::SmallVector<SILParameterInfo> specializedParams;
   for (unsigned idx = 0; idx < paramCount; ++idx) {
@@ -468,18 +469,19 @@ ClosureSpecializer_createEmptyFunctionWithSpecializedSignature(BridgedStringRef
   // The specialized function is always a thin function. This is important
   // because we may add additional parameters after the Self parameter of
   // witness methods. In this case the new function is not a method anymore.
-  auto extInfo = applySiteCalleeType->getExtInfo();
-  extInfo = extInfo.withRepresentation(SILFunctionTypeRepresentation::Thin);
+  auto extInfo = originalType->getExtInfo();
+  if (makeThin)
+    extInfo = extInfo.withRepresentation(SILFunctionTypeRepresentation::Thin);
 
   auto ClonedTy = SILFunctionType::get(
-      applySiteCalleeType->getInvocationGenericSignature(), extInfo,
-      applySiteCalleeType->getCoroutineKind(),
-      applySiteCalleeType->getCalleeConvention(), specializedParams,
-      applySiteCalleeType->getYields(), applySiteCalleeType->getResults(),
-      applySiteCalleeType->getOptionalErrorResult(),
-      applySiteCalleeType->getPatternSubstitutions(),
-      applySiteCalleeType->getInvocationSubstitutions(),
-      applySiteCallee->getModule().getASTContext());
+      originalType->getInvocationGenericSignature(), extInfo,
+      originalType->getCoroutineKind(),
+      originalType->getCalleeConvention(), specializedParams,
+      originalType->getYields(), originalType->getResults(),
+      originalType->getOptionalErrorResult(),
+      originalType->getPatternSubstitutions(),
+      originalType->getInvocationSubstitutions(),
+      original->getModule().getASTContext());
 
   SILOptFunctionBuilder functionBuilder(*invocation->getTransform());
 
@@ -493,23 +495,23 @@ ClosureSpecializer_createEmptyFunctionWithSpecializedSignature(BridgedStringRef
       // It's also important to disconnect this specialized function from any
       // classes (the classSubclassScope), because that may incorrectly
       // influence the linkage.
-      getSpecializedLinkage(applySiteCallee, applySiteCallee->getLinkage()), specializedName.unbridged(),
-      ClonedTy, applySiteCallee->getGenericEnvironment(),
-      applySiteCallee->getLocation(), IsBare, applySiteCallee->isTransparent(),
-      isSerialized ? IsSerialized : IsNotSerialized, IsNotDynamic, IsNotDistributed,
-      IsNotRuntimeAccessible, applySiteCallee->getEntryCount(),
-      applySiteCallee->isThunk(),
+      getSpecializedLinkage(original, original->getLinkage()), specializedName.unbridged(),
+      ClonedTy, original->getGenericEnvironment(),
+      original->getLocation(), makeBare ? IsBare : original->isBare(), original->isTransparent(),
+      original->getSerializedKind(), IsNotDynamic, IsNotDistributed,
+      IsNotRuntimeAccessible, original->getEntryCount(),
+      original->isThunk(),
       /*classSubclassScope=*/SubclassScope::NotApplicable,
-      applySiteCallee->getInlineStrategy(), applySiteCallee->getEffectsKind(),
-      applySiteCallee, applySiteCallee->getDebugScope());
+      original->getInlineStrategy(), original->getEffectsKind(),
+      original, original->getDebugScope());
 
-  if (!applySiteCallee->hasOwnership()) {
+  if (!original->hasOwnership()) {
     specializedApplySiteCallee->setOwnershipEliminated();
   }
 
-  for (auto &Attr : applySiteCallee->getSemanticsAttrs())
+  for (auto &Attr : original->getSemanticsAttrs())
     specializedApplySiteCallee->addSemanticsAttr(Attr);
-  
+
   return {specializedApplySiteCallee};
 }