Improvements for cross-module-optimization

* Include small non-generic functions for serializaion
* serialize initializer of global variables: so that global let variables can be constant propagated across modules

rdar://problem/60696510

Author: eeckstein

lib/SILOptimizer/IPO/CrossModuleSerializationSetup.cpp

@@ -23,11 +23,17 @@
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
+#include "swift/SILOptimizer/Utils/SILInliner.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 
 using namespace swift;
 
+/// Functions up to this (abstract) size are serialized, even if they are not
+/// generic.
+static llvm::cl::opt<int> CMOFunctionSizeLimit("cmo-function-size-limit",
+                                               llvm::cl::init(20));
+
 namespace {
 
 /// Scans a whole module and marks functions and types as inlinable or usable
@@ -54,6 +60,8 @@ class CrossModuleSerializationSetup {
 
   bool canSerialize(SILFunction *F, bool lookIntoThunks);
 
+  bool canSerialize(SILInstruction *inst, bool lookIntoThunks);
+
   void setUpForSerialization(SILFunction *F);
 
   void prepareInstructionForSerialization(SILInstruction *inst);
@@ -193,18 +201,31 @@ static llvm::cl::opt<bool> SerializeEverything(
 
 /// Decide whether to serialize a function.
 static bool shouldSerialize(SILFunction *F) {
-  // The basic heursitic: serialize all generic functions, because it makes a
-  // huge difference if generic functions can be specialized or not.
-  if (!F->getLoweredFunctionType()->isPolymorphic() && !SerializeEverything)
-    return false;
-
   // Check if we already handled this function before.
   if (F->isSerialized() == IsSerialized)
     return false;
 
   if (F->hasSemanticsAttr("optimize.no.crossmodule"))
     return false;
 
+  if (SerializeEverything)
+    return true;
+
+  // The basic heursitic: serialize all generic functions, because it makes a
+  // huge difference if generic functions can be specialized or not.
+  if (F->getLoweredFunctionType()->isPolymorphic())
+    return true;
+
+  // Also serialize "small" non-generic functions.
+  int size = 0;
+  for (SILBasicBlock &block : *F) {
+    for (SILInstruction &inst : block) {
+      size += (int)instructionInlineCost(inst);
+      if (size >= CMOFunctionSizeLimit)
+        return false;
+    }
+  }
+
   return true;
 }
 
@@ -227,6 +248,11 @@ prepareInstructionForSerialization(SILInstruction *inst) {
     handleReferencedFunction(callee);
     return;
   }
+  if (auto *GAI = dyn_cast<GlobalAddrInst>(inst)) {
+    GAI->getReferencedGlobal()->setSerialized(IsSerialized);
+    GAI->getReferencedGlobal()->setLinkage(SILLinkage::Public);
+    return;
+  }
   if (auto *MI = dyn_cast<MethodInst>(inst)) {
     handleReferencedMethod(MI->getMember());
     return;
@@ -285,26 +311,42 @@ bool CrossModuleSerializationSetup::canSerialize(SILFunction *F,
   // First step: check if serializing F is even possible.
   for (SILBasicBlock &block : *F) {
     for (SILInstruction &inst : block) {
-      if (auto *FRI = dyn_cast<FunctionRefBaseInst>(&inst)) {
-        SILFunction *callee = FRI->getReferencedFunctionOrNull();
-        if (!canUseFromInline(callee, lookIntoThunks))
-          return false;
-      } else if (auto *KPI = dyn_cast<KeyPathInst>(&inst)) {
-        bool canUse = true;
-        KPI->getPattern()->visitReferencedFunctionsAndMethods(
-            [&](SILFunction *func) {
-              if (!canUseFromInline(func, lookIntoThunks))
-                canUse = false;
-            },
-            [](SILDeclRef method) { });
-        if (!canUse)
-          return false;
-      }
+      if (!canSerialize(&inst, lookIntoThunks))
+        return false;
     }
   }
   return true;
 }
 
+bool CrossModuleSerializationSetup::canSerialize(SILInstruction *inst,
+                                                 bool lookIntoThunks) {
+  if (auto *FRI = dyn_cast<FunctionRefBaseInst>(inst)) {
+    SILFunction *callee = FRI->getReferencedFunctionOrNull();
+    return canUseFromInline(callee, lookIntoThunks);
+  }
+  if (auto *KPI = dyn_cast<KeyPathInst>(inst)) {
+    bool canUse = true;
+    KPI->getPattern()->visitReferencedFunctionsAndMethods(
+        [&](SILFunction *func) {
+          if (!canUseFromInline(func, lookIntoThunks))
+            canUse = false;
+        },
+        [&](SILDeclRef method) {
+          if (method.isForeign)
+            canUse = false;
+        });
+    return canUse;
+  }
+  if (auto *GAI = dyn_cast<GlobalAddrInst>(inst)) {
+    return !GAI->getReferencedGlobal()->getName().startswith("globalinit_");
+  }
+  if (auto *MI = dyn_cast<MethodInst>(inst)) {
+    return !MI->getMember().isForeign;
+  }
+  
+  return true;
+}
+
 /// Returns true if the function \p func can be used from a serialized function.
 ///
 /// If \p lookIntoThunks is true, serializable shared thunks are also accepted.
@@ -351,12 +393,17 @@ void CrossModuleSerializationSetup::setUpForSerialization(SILFunction *F) {
   }
   F->setSerialized(IsSerialized);
 
-  // As a code size optimization, make serialized functions
-  // @alwaysEmitIntoClient.
-  // Also, for shared thunks it's required to make them @alwaysEmitIntoClient.
-  // SILLinkage::Public would not work for shared functions, because it could
-  // result in duplicate-symbol linker errors.
-  F->setLinkage(SILLinkage::PublicNonABI);
+  if (F->getLoweredFunctionType()->isPolymorphic() ||
+      F->getLinkage() != SILLinkage::Public) {
+    // As a code size optimization, make serialized functions
+    // @alwaysEmitIntoClient.
+    // Also, for shared thunks it's required to make them @alwaysEmitIntoClient.
+    // SILLinkage::Public would not work for shared functions, because it could
+    // result in duplicate-symbol linker errors.
+    F->setLinkage(SILLinkage::PublicNonABI);
+  } else {
+    F->setLinkage(SILLinkage::Public);
+  }
 }
 
 /// Select functions in the module which should be serialized.

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -447,6 +447,10 @@ static void addPerfEarlyModulePassPipeline(SILPassPipelinePlan &P) {
   // is linked in from the stdlib.
   P.addTempRValueOpt();
 
+  // Needed to serialize static initializers of globals for cross-module
+  // optimization.
+  P.addGlobalOpt();
+
   // Add the outliner pass (Osize).
   P.addOutliner();
 

test/SILOptimizer/Inputs/cross-module.swift

@@ -130,6 +130,7 @@ extension Int : PrivateProtocol {
 }
 
 @inline(never)
+@_semantics("optimize.no.crossmodule")
 private func printFooExistential(_ p: PrivateProtocol) {
   print(p.foo())
 }
@@ -266,3 +267,4 @@ public func callUnrelated<T>(_ t: T) -> T {
   return t
 }
 
+public let globalLet = 529387

test/SILOptimizer/cross-module-optimization.swift

@@ -17,7 +17,9 @@
 
 // Second test: check if CMO really imports the SIL of functions in other modules.
 
-// RUN: %target-build-swift -O -wmo -module-name=Main -I%t %s -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-sil | %FileCheck %s -check-prefix=CHECK-SIL
+// RUN: %target-build-swift -O -wmo -module-name=Main -I%t %s -Xllvm -sil-disable-pass=FunctionSignatureOpts -emit-sil -o %t/out.sil
+// RUN: %FileCheck %s -check-prefix=CHECK-SIL < %t/out.sil
+// RUN: %FileCheck %s -check-prefix=CHECK-SIL2 < %t/out.sil
 
 import Test
 
@@ -54,13 +56,18 @@ func testClass() {
   print(createClass_gen(0))
 }
 
+// CHECK-SIL2-LABEL: sil hidden [noinline] @$s4Main9testErroryyF
+@inline(never)
 func testError() {
   // CHECK-OUTPUT: PrivateError()
-  // CHECK-SIL-DAG: sil @$s4Test12PrivateError33_{{.*}} : $@convention(method) (@thin PrivateError.Type) -> PrivateError{{$}}
+  // CHECK-SIL2: struct $PrivateError ()
+  // CHECK-SIL2: alloc_existential_box $Error, $PrivateError
   print(returnPrivateError(27))
   // CHECK-OUTPUT: InternalError()
-  // CHECK-SIL-DAG: sil @$s4Test13InternalErrorVACycfC : $@convention(method) (@thin InternalError.Type) -> InternalError{{$}}
+  // CHECK-SIL2: struct $InternalError ()
+  // CHECK-SIL2: alloc_existential_box $Error, $InternalError
   print(returnInternalError(27))
+  // CHECK-SIL2: } // end sil function '$s4Main9testErroryyF'
 }
 
 class DerivedFromOpen<T> : OpenClass<T> { }
@@ -123,6 +130,15 @@ func testMisc() {
   print(classWithPublicProperty(33))
 }
 
+// CHECK-SIL2-LABEL: sil hidden [noinline] @$s4Main10testGlobalyyF
+@inline(never)
+func testGlobal() {
+  // CHECK-OUTPUT: 529387
+  // CHECK-SIL2: integer_literal $Builtin.Int{{[0-9]+}}, 529387
+  print(globalLet)
+  // CHECK-SIL2: } // end sil function '$s4Main10testGlobalyyF'
+}
+
 testNestedTypes()
 testClass()
 testError()
@@ -131,3 +147,5 @@ testSubModule()
 testClosures()
 testKeypath()
 testMisc()
+testGlobal()
+