Merge pull request #77400 from eeckstein/fix-specialize-attr

SIL: avoid creating SIL functions for not used imported specialization attributes

Author: eeckstein

include/swift/SIL/SILModule.h

@@ -399,6 +399,10 @@ class SILModule {
 
   BasicBlockNameMapType basicBlockNames;
 
+  // Specialization attributes which need to be added to a function once it is created.
+  // The key of this map is the function name.
+  llvm::StringMap<std::vector<SILSpecializeAttr *>> pendingSpecializeAttrs;
+
   SILModule(llvm::PointerUnion<FileUnit *, ModuleDecl *> context,
             Lowering::TypeConverter &TC, const SILOptions &Options,
             const IRGenOptions *irgenOptions = nullptr);
@@ -1081,6 +1085,10 @@ class SILModule {
   /// Gather prespecialized from extensions.
   void performOnceForPrespecializedImportedExtensions(
       llvm::function_ref<void(AbstractFunctionDecl *)> action);
+
+  void addPendingSpecializeAttr(StringRef functionName, SILSpecializeAttr *attr) {
+    pendingSpecializeAttrs[functionName].push_back(attr);
+  }
 };
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const SILModule &M){

lib/SIL/IR/SILFunction.cpp

@@ -194,6 +194,14 @@ SILFunction *SILFunction::create(
   else
     M.functions.push_back(fn);
 
+  auto iter = M.pendingSpecializeAttrs.find(name);
+  if (iter != M.pendingSpecializeAttrs.end()) {
+    for (auto *attr : iter->second) {
+      fn->addSpecializeAttr(attr);
+    }
+    M.pendingSpecializeAttrs.erase(iter);
+  }
+
   return fn;
 }
 

lib/SILOptimizer/Transforms/GenericSpecializer.cpp

@@ -51,12 +51,6 @@ static void transferSpecializeAttributeTargets(SILModule &M,
       }
     }
     if (auto *targetFunctionDecl = SA->getTargetFunctionDecl(vd)) {
-      auto target = SILDeclRef(targetFunctionDecl);
-      auto targetSILFunction = builder.getOrCreateFunction(
-          SILLocation(vd), target, NotForDefinition,
-          [&builder](SILLocation loc, SILDeclRef constant) -> SILFunction * {
-            return builder.getOrCreateFunction(loc, constant, NotForDefinition);
-          });
       auto kind = SA->getSpecializationKind() ==
                           SpecializeAttr::SpecializationKind::Full
                       ? SILSpecializeAttr::SpecializationKind::Full
@@ -68,10 +62,18 @@ static void transferSpecializeAttributeTargets(SILModule &M,
       auto availability = AvailabilityInference::annotatedAvailableRangeForAttr(
           SA, M.getSwiftModule()->getASTContext());
 
-      targetSILFunction->addSpecializeAttr(SILSpecializeAttr::create(
+      auto *attr = SILSpecializeAttr::create(
           M, SA->getSpecializedSignature(vd), SA->getTypeErasedParams(),
           SA->isExported(), kind, nullptr,
-          spiGroupIdent, vd->getModuleContext(), availability));
+          spiGroupIdent, vd->getModuleContext(), availability);
+
+      auto target = SILDeclRef(targetFunctionDecl);
+      std::string targetName = target.mangle();
+      if (SILFunction *targetSILFunction = M.lookUpFunction(targetName)) {
+        targetSILFunction->addSpecializeAttr(attr);
+      } else {
+        M.addPendingSpecializeAttr(targetName, attr);
+      }
     }
   }
 }

test/SILOptimizer/implicit_imports.swift

@@ -0,0 +1,13 @@
+// RUN: %target-swift-frontend  -primary-file %s -O -emit-sil | %FileCheck %s
+
+// Check that no Array code is de-serialized due to specialization attributes
+
+// CHECK-NOT: Array
+
+@inline(never)
+func foo<T>(_ x: T) {
+}
+
+public func test() {
+  foo(27)
+}