Cross-module-optimization: Serialize immediately after CrossModuleSerializationSetup

Otherwise it can happen that e.g. specialization runs between CrossModuleSerializationSetup  and serialization, resulting that an inlinable function references a shared function (which doesn't have a public linkage).
The solution is to move serialization right after CrossModuleSerializationSetup. But only do that if cross-module-optimization is enabled (it would be a disruptive change to move serialization in general).

Author: eeckstein

include/swift/SILOptimizer/PassManager/Passes.def

@@ -311,6 +311,8 @@ PASS(SimplifyUnreachableContainingBlocks, "simplify-unreachable-containing-block
      "Utility pass. Removes all non-term insts from blocks with unreachable terms")
 PASS(SerializeSILPass, "serialize-sil",
      "Utility pass. Serializes the current SILModule")
+PASS(CMOSerializeSILPass, "cmo-serialize-sil",
+     "Utility pass. Serializes the current SILModule for cross-module-optimization")
 PASS(NonInlinableFunctionSkippingChecker, "check-non-inlinable-function-skipping",
      "Utility pass to ensure -experimental-skip-non-inlinable-function-bodies "
      "skips everything it should")

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -413,6 +413,12 @@ static void addPerfEarlyModulePassPipeline(SILPassPipelinePlan &P) {
   P.addOutliner();
 
   P.addCrossModuleSerializationSetup();
+  
+  // In case of cross-module-optimization, we need to serialize right after
+  // CrossModuleSerializationSetup. Eventually we want to serialize early
+  // anyway, but for now keep the SerializeSILPass at the later stage of the
+  // pipeline in case cross-module-optimization is not enabled.
+  P.addCMOSerializeSILPass();
 }
 
 static void addHighLevelEarlyLoopOptPipeline(SILPassPipelinePlan &P) {

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -391,6 +391,9 @@ void updateOpaqueArchetypes(SILFunction &F) {
 /// A utility pass to serialize a SILModule at any place inside the optimization
 /// pipeline.
 class SerializeSILPass : public SILModuleTransform {
+    
+  bool onlyForCrossModuleOptimization;
+    
   /// Removes [serialized] from all functions. This allows for more
   /// optimizations and for a better dead function elimination.
   void removeSerializedFlagFromAllFunctions(SILModule &M) {
@@ -422,12 +425,19 @@ class SerializeSILPass : public SILModuleTransform {
   }
 
 public:
-  SerializeSILPass() {}
+  SerializeSILPass(bool onlyForCrossModuleOptimization)
+    : onlyForCrossModuleOptimization(onlyForCrossModuleOptimization)
+  { }
+  
   void run() override {
     auto &M = *getModule();
     // Nothing to do if the module was serialized already.
     if (M.isSerialized())
       return;
+    
+    if (onlyForCrossModuleOptimization &&
+        !M.getOptions().CrossModuleOptimization)
+      return;
 
     // Mark all reachable functions as "anchors" so that they are not
     // removed later by the dead function elimination pass. This
@@ -449,5 +459,9 @@ class SerializeSILPass : public SILModuleTransform {
 };
 
 SILTransform *swift::createSerializeSILPass() {
-  return new SerializeSILPass();
+  return new SerializeSILPass(/* onlyForCrossModuleOptimization */ false);
+}
+
+SILTransform *swift::createCMOSerializeSILPass() {
+  return new SerializeSILPass(/* onlyForCrossModuleOptimization */ true);
 }

test/SILOptimizer/Inputs/cross-module.swift

@@ -236,3 +236,14 @@ public func useClassKeypath<T>(_ t: T) -> Int {
   return c[keyPath: getClassKeypath(t)]
 }
 
+@inline(never)
+func unrelated<U>(_ u: U) {
+  print(u)
+}
+
+@inline(never)
+public func callUnrelated<T>(_ t: T) -> T {
+  unrelated(43)
+  return t
+}
+

test/SILOptimizer/cross-module-optimization.swift

@@ -113,10 +113,18 @@ func testKeypath() {
   print(useClassKeypath(0))
 }
 
+func testMisc() {
+  // CHECK-OUTPUT: 43
+  // CHECK-OUTPUT: 42
+  // CHECK-SIL-DAG: sil shared {{.*}} @$s4Test13callUnrelatedyxxlFSi_Tg5
+  print(callUnrelated(42))
+}
+
 testNestedTypes()
 testClass()
 testError()
 testProtocolsAndClasses()
 testSubModule()
 testClosures()
 testKeypath()
+testMisc()