GenericCloner: make sure that we can always specialize in mandatory mode

This may involve changing the linkage of the specialized function.
If called from a serialized function we cannot make the specialized function shared and non-serialized.
The only other option is to keep the original function's linkage.

rdar://121675461

Author: eeckstein

lib/SILOptimizer/Utils/GenericCloner.cpp

@@ -32,8 +32,6 @@ using namespace swift;
 SILFunction *GenericCloner::createDeclaration(
     SILOptFunctionBuilder &FunctionBuilder, SILFunction *Orig,
     const ReabstractionInfo &ReInfo, StringRef NewName) {
-  assert((!ReInfo.isSerialized() || Orig->isSerialized())
-         && "Specialization cannot make body more resilient");
   assert((Orig->isTransparent() || Orig->isBare() || Orig->getLocation())
          && "SILFunction missing location");
   assert((Orig->isTransparent() || Orig->isBare() || Orig->getDebugScope())

lib/SILOptimizer/Utils/Generics.cpp

@@ -3210,11 +3210,17 @@ void swift::trySpecializeApplyOfGeneric(
   // not have an external entry point, Since the callee is not
   // fragile we cannot serialize the body of the specialized
   // callee either.
-  if (F->isSerialized() && !RefF->hasValidLinkageForFragileInline())
-      return;
+  bool needSetLinkage = false;
+  if (isMandatory) {
+    if (F->isSerialized() && !RefF->hasValidLinkageForFragileInline())
+      needSetLinkage = true;
+  } else {
+    if (F->isSerialized() && !RefF->hasValidLinkageForFragileInline())
+        return;
 
-  if (shouldNotSpecialize(RefF, F))
-    return;
+    if (shouldNotSpecialize(RefF, F))
+      return;
+  }
 
   // If the caller and callee are both fragile, preserve the fragility when
   // cloning the callee. Otherwise, strip it off so that we can optimize
@@ -3331,7 +3337,15 @@ void swift::trySpecializeApplyOfGeneric(
     return;
   }
 
-  if (F->isSerialized() && !SpecializedF->hasValidLinkageForFragileInline()) {
+  if (needSetLinkage) {
+    assert(F->isSerialized() && !RefF->hasValidLinkageForFragileInline());
+    // If called from a serialized function we cannot make the specialized function
+    // shared and non-serialized. The only other option is to keep the original
+    // function's linkage. It's not great, because it can prevent dead code
+    // elimination - usually the original function is a public function.
+    SpecializedF->setLinkage(RefF->getLinkage());
+    SpecializedF->setSerialized(IsNotSerialized);
+  } else if (F->isSerialized() && !SpecializedF->hasValidLinkageForFragileInline()) {
     // If the specialized function already exists as a "IsNotSerialized" function,
     // but now it's called from a "IsSerialized" function, we need to mark it as
     // IsSerialized.

test/SILOptimizer/mandatory_performance_optimizations.sil

@@ -256,14 +256,14 @@ bb0(%0 : $Int, %1 : $@thick Int.Type, %2 : @owned $Builtin.NativeObject):
   return %2 : $Builtin.NativeObject
 }
 
-// CHECK-LABEL: sil shared [ossa] @$s12metatype_argTf4dnn_n : $@convention(thin) (Int, @owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
+// CHECK-LABEL: sil [ossa] @$s12metatype_argTf4dnn_n : $@convention(thin) (Int, @owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
 // CHECK:       bb0(%0 : $Int, %1 : @owned $Builtin.NativeObject):
 // CHECK:         %2 = metatype $@thick Int.Type
 // CHECK:         fix_lifetime %2 : $@thick Int.Type
 // CHECK:         return %1 : $Builtin.NativeObject
 // CHECK:       } // end sil function '$s12metatype_argTf4dnn_n'
 
-// CHECK-LABEL: sil shared [ossa] @$s19metatype_arg_throwsTf4dnn_n : $@convention(thin) (Int, @owned Builtin.NativeObject) -> (@owned Builtin.NativeObject, @error any Error) {
+// CHECK-LABEL: sil [ossa] @$s19metatype_arg_throwsTf4dnn_n : $@convention(thin) (Int, @owned Builtin.NativeObject) -> (@owned Builtin.NativeObject, @error any Error) {
 // CHECK:       bb0(%0 : $Int, %1 : @owned $Builtin.NativeObject):
 // CHECK:         %2 = metatype $@thick Int.Type
 // CHECK:         fix_lifetime %2 : $@thick Int.Type

test/embedded/default-arguments.swift

@@ -0,0 +1,19 @@
+// RUN: %target-swift-frontend -emit-ir %s -enable-experimental-feature Embedded -o /dev/null
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: VENDOR=apple
+// REQUIRES: OS=macosx
+
+// Check that this doesn't crash the compiler in embedded mode.
+
+public func foo<T>(_ t: T) -> T {
+  t
+}
+
+public func testit(_ x: Int = foo(27)) -> Int {
+  x
+}
+
+public func callit() -> Int {
+  testit()
+}