More fixes for pre-specializations

Since the bodies of pre-specializaitons are not serialized, do not use the `[serialized]` attribute for them.

Author: swiftix

lib/SILOptimizer/IPO/DeadFunctionElimination.cpp

@@ -113,7 +113,6 @@ class FunctionLivenessComputation {
     // a pipeline, as it may break some optimizations.
     if (F->isKeepAsPublic()) {
       F->setLinkage(SILLinkage::Public);
-      F->setSerialized(IsSerialized);
       DEBUG(llvm::dbgs() << "DFE: Preserve the specialization "
                          << F->getName() << '\n');
       return true;

lib/SILOptimizer/IPO/UsePrespecialized.cpp

@@ -99,9 +99,10 @@ bool UsePrespecialized::replaceByPrespecialized(SILFunction &F) {
     if (SpecType->hasArchetype())
       continue;
 
-    // Create a name of the specialization.
+    // Create a name of the specialization. All external pre-specializations
+    // are serialized without bodies. Thus use IsNotSerialized here.
     Mangle::GenericSpecializationMangler NewGenericMangler(ReferencedF,
-                                              Subs, ReferencedF->isSerialized(),
+                                              Subs, IsNotSerialized,
                                               /*isReAbstracted*/ true);
     std::string ClonedName = NewGenericMangler.mangle();
 

lib/SILOptimizer/Utils/Generics.cpp

@@ -2274,11 +2274,12 @@ void swift::trySpecializeApplyOfGeneric(
   if (F->isSerialized() && RefF->isSerialized())
     Serialized = IsSerializable;
 
-  // If it is OnoneSupport consider all specializations as serialized.
+  // If it is OnoneSupport consider all specializations as non-serialized
+  // as we do not SIL serialize their bodies.
   // It is important to set this flag here, because it affects the
   // mangling of the specialization's name.
   if (Apply.getModule().isOptimizedOnoneSupportModule())
-    Serialized = IsSerialized;
+    Serialized = IsNotSerialized;
 
   ReabstractionInfo ReInfo(Apply, RefF, Apply.getSubstitutions());
   if (!ReInfo.canBeSpecialized())

test/SILOptimizer/eager_specialize.sil

@@ -581,7 +581,7 @@ bb0(%0 : $*T):
 
 // Check that a public specialization for Int64 was produced.
 // specialized exportSpecializations<A> (A) -> ()
-// CHECK-DEADFUNCELIM-LABEL: sil [serialized] @_T016eager_specialize21exportSpecializationsyxlFs5Int64V_Tg5 : $@convention(thin) (Int64) -> ()
+// CHECK-DEADFUNCELIM-LABEL: sil @_T016eager_specialize21exportSpecializationsyxlFs5Int64V_Tg5 : $@convention(thin) (Int64) -> ()
 
 ////////////////////////////////////////////////////////////////////
 // Check the ability to produce explicit partial specializations.

test/SILOptimizer/prespecialize.swift

@@ -11,13 +11,13 @@
 // CHECK-LABEL: sil [noinline] @_T013prespecialize4testySaySiGz_Si4sizetF 
 //
 // function_ref specialized Collection<A where ...>.makeIterator() -> IndexingIterator<A>
-// CHECK: function_ref @_T0s10CollectionPssAARzs16IndexingIteratorVyxG0C0RtzlE04makeC0AEyFs14CountableRangeVySiG_Tgq5
+// CHECK: function_ref @_T0s10CollectionPssAARzs16IndexingIteratorVyxG0C0RtzlE04makeC0AEyFs14CountableRangeVySiG_Tg5
 //
 // function_ref specialized IndexingIterator.next() -> A.Element?
-// CHECK: function_ref @_T0s16IndexingIteratorV4next7ElementQzSgyFs14CountableRangeVySiG_Tgq5
+// CHECK: function_ref @_T0s16IndexingIteratorV4next7ElementQzSgyFs14CountableRangeVySiG_Tg5
 //
 // Look for generic specialization <Swift.Int> of Swift.Array.subscript.getter : (Swift.Int) -> A
-// CHECK: function_ref {{@_T0SaxSicigSi_Tgq5|@_TTSg5Si___TFSaap9subscriptFSix}}
+// CHECK: function_ref {{@_T0SaxSicigSi_Tg5|@_TTSg5Si___TFSaap9subscriptFSix}}
 // CHECK: return
 @inline(never)
 public func test(_ a: inout [Int], size: Int) {
@@ -30,7 +30,7 @@ public func test(_ a: inout [Int], size: Int) {
 
 // CHECK-LABEL: sil [noinline] @_T013prespecialize3runyyF
 // Look for generic specialization <Swift.Int> of Swift.Array.init (repeating : A, count : Swift.Int) -> Swift.Array<A>
-// CHECK: function_ref @_T0S2ayxGx9repeating_Si5counttcfCSi_Tgq5
+// CHECK: function_ref @_T0S2ayxGx9repeating_Si5counttcfCSi_Tg5
 // CHECK: return
 @inline(never)
 public func run() {