MandatoryPerformanceOptimizations: force inlining of transparent functions and de-virtualization

Do this even if the function then contains references to other functions with wrong linkage. Instead fix the linkage later.
Fixes a false error in embedded swift.

rdar://134352676

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -118,6 +118,16 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
           context.erase(instructionIncludingDebugUses: iem)
         }
 
+      case let fri as FunctionRefInst:
+        // Mandatory de-virtualization and mandatory inlining might leave referenced functions in "serialized"
+        // functions with wrong linkage. Fix this by making the referenced function public.
+        // It's not great, because it can prevent dead code elimination. But it's only a rare case.
+        if function.serializedKind != .notSerialized,
+           !fri.referencedFunction.hasValidLinkageForFragileRef(function.serializedKind)
+        {
+          fri.referencedFunction.set(linkage: .public, moduleContext)
+        }
+
       default:
         break
       }
@@ -153,6 +163,8 @@ private func specializeVTableAndAddEntriesToWorklist(for type: Type, in function
 
 private func inlineAndDevirtualize(apply: FullApplySite, alreadyInlinedFunctions: inout Set<PathFunctionTuple>,
                                    _ context: FunctionPassContext, _ simplifyCtxt: SimplifyContext) {
+  // De-virtualization and inlining in/into a "serialized" function might create function references to functions
+  // with wrong linkage. We need to fix this later (see handling of FunctionRefInst in `optimize`).
   if simplifyCtxt.tryDevirtualize(apply: apply, isMandatory: true) != nil {
     return
   }
@@ -166,9 +178,7 @@ private func inlineAndDevirtualize(apply: FullApplySite, alreadyInlinedFunctions
     return
   }
 
-  if apply.canInline &&
-     shouldInline(apply: apply, callee: callee, alreadyInlinedFunctions: &alreadyInlinedFunctions)
-  {
+  if shouldInline(apply: apply, callee: callee, alreadyInlinedFunctions: &alreadyInlinedFunctions) {
     if apply.inliningCanInvalidateStackNesting  {
       simplifyCtxt.notifyInvalidatedStackNesting()
     }
@@ -196,9 +206,14 @@ private func removeUnusedMetatypeInstructions(in function: Function, _ context:
 
 private func shouldInline(apply: FullApplySite, callee: Function, alreadyInlinedFunctions: inout Set<PathFunctionTuple>) -> Bool {
   if callee.isTransparent {
+    precondition(callee.hasOwnership, "transparent functions should have ownership at this stage of the pipeline")
     return true
   }
 
+  if !apply.canInline {
+    return false
+  }
+
   if apply is BeginApplyInst {
     // Avoid co-routines because they might allocate (their context).
     return true

lib/SILOptimizer/Utils/Devirtualize.cpp

@@ -1182,7 +1182,8 @@ static bool canDevirtualizeWitnessMethod(ApplySite applySite, bool isMandatory)
 
   // function_ref inside fragile function cannot reference a private or
   // hidden symbol.
-  if (applySite.getFunction()->isAnySerialized() &&
+  if (!isMandatory &&
+      applySite.getFunction()->isAnySerialized() &&
       !f->hasValidLinkageForFragileRef(applySite.getFunction()->getSerializedKind()))
     return false;
 

test/SILOptimizer/mandatory_devirt_witness_method.sil

@@ -0,0 +1,59 @@
+// RUN: %target-sil-opt -module-name=test -enable-sil-verify-all %s -mandatory-performance-optimizations -performance-diagnostics | %FileCheck %s
+
+sil_stage canonical
+
+import Swift
+import SwiftShims
+import Builtin
+
+public protocol P {
+  func foo()
+}
+
+private struct S : P {
+  @_hasStorage var x: Int
+  func foo()
+}
+
+// Linkage should be set to public
+// CHECK-LABEL: sil [perf_constraint] [ossa] @S_foo : $@convention(method) (S) -> () {
+sil private [ossa] @S_foo : $@convention(method) (S) -> () {
+bb0(%0 : $S):
+  %2 = tuple ()
+  return %2 : $()
+}
+
+sil private [transparent] [thunk] [ossa] @S_foo_thunk : $@convention(witness_method: P) (@in_guaranteed S) -> () {
+bb0(%0 : $*S):
+  %1 = load [trivial] %0 : $*S
+  %2 = function_ref @S_foo : $@convention(method) (S) -> ()
+  %3 = apply %2(%1) : $@convention(method) (S) -> ()
+  %4 = tuple ()
+  return %4 : $()
+}
+
+// CHECK-LABEL: sil shared [serialized] [perf_constraint] [ossa] @$s8call_foo4test1S{{.*}}_Tgq5 : $@convention(thin) (S) -> () {
+// CHECK:         [[F:%.*]] = function_ref @S_foo : $@convention(method) (S) -> ()
+// CHECK:         = apply [[F]](%0) : $@convention(method) (S) -> ()
+// CHECK:       // end sil function '$s8call_foo4test1S{{.*}}_Tgq5'
+sil [ossa] [serialized] @call_foo : $@convention(thin) <T where T : P> (@in_guaranteed T) -> () {
+bb0(%0 : $*T):
+  %2 = witness_method $T, #P.foo : <Self where Self : P> (Self) -> () -> () : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
+  %3 = apply %2<T>(%0) : $@convention(witness_method: P) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
+  %4 = tuple ()
+  return %4 : $()
+}
+
+sil [no_locks] [ossa] [serialized] @main : $@convention(thin) (@in_guaranteed S) -> () {
+bb0(%0 : $*S):
+  %5 = function_ref @call_foo : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
+  %6 = apply %5<S>(%0) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> ()
+  %8 = tuple ()
+  return %8 : $()
+}
+
+sil_witness_table private S: P module test {
+  method #P.foo: <Self where Self : P> (Self) -> () -> () : @S_foo_thunk	
+}
+
+

test/SILOptimizer/mandatory_performance_optimizations.sil

@@ -120,7 +120,7 @@ bb0:
   %2 = tuple ()
   return %2 : $()
 }
-sil shared [transparent] [serialized] [thunk] [canonical] @$sSiSLsSL1loiySbx_xtFZTW : $@convention(witness_method: Comparable) (@in_guaranteed Int, @in_guaranteed Int, @thick Int.Type) -> Bool {
+sil shared [ossa] [transparent] [serialized] [thunk] [canonical] @$sSiSLsSL1loiySbx_xtFZTW : $@convention(witness_method: Comparable) (@in_guaranteed Int, @in_guaranteed Int, @thick Int.Type) -> Bool {
 bb0(%0 : $*Int, %1 : $*Int, %2 : $@thick Int.Type):
   %3 = integer_literal $Builtin.Int1, 0
   %4 = struct $Bool (%3 : $Builtin.Int1)