Serialize SIL witness-tables and v-tables and their entries when applicable

if package cmo is enabled. If two modules are in the same package and package
cmo is enabled, v-table or witness-table calls should not be generated at the
use site in client module.

Also allow serializing a definition with shared linkage in package cmo.

rdar://124632670

Author: elsh

lib/SILOptimizer/IPO/CrossModuleOptimization.cpp

@@ -71,6 +71,7 @@ class CrossModuleOptimization {
     : M(M), conservative(conservative), everything(everything) { }
 
   void serializeFunctionsInModule();
+  void serializeTablesInModule();
 
 private:
   bool canSerializeFunction(SILFunction *function,
@@ -188,6 +189,35 @@ void CrossModuleOptimization::serializeFunctionsInModule() {
   }
 }
 
+void CrossModuleOptimization::serializeTablesInModule() {
+  if (!M.getOptions().EnableSerializePackage)
+    return;
+
+  for (const auto &vt : M.getVTables()) {
+    if (!vt->isSerialized() &&
+        vt->getClass()->getEffectiveAccess() >= AccessLevel::Package) {
+      vt->setSerialized(IsSerialized);
+    }
+  }
+
+  for (auto &wt : M.getWitnessTables()) {
+    if (!wt.isSerialized() && (wt.getLinkage() == SILLinkage::Package ||
+                               wt.getLinkage() == SILLinkage::Public)) {
+      for (auto &entry : wt.getEntries()) {
+        // Entries in witness table with package linkage are not serialized
+        // (by default only entries in public witness table are; \see
+        // SILWitnessTable::conformanceIsSerialized), so serialize them here
+        // if package-cmo is enabled (otherwise nil).
+        if (entry.getKind() == SILWitnessTable::Method &&
+            !entry.getMethodWitness().Witness->isSerialized())
+          entry.getMethodWitness().Witness->setSerialized(IsSerialized);
+      }
+      // Then serialize the witness table itself.
+      wt.setSerialized(IsSerialized);
+    }
+  }
+}
+
 /// Recursively walk the call graph and select functions to be serialized.
 ///
 /// The results are stored in \p canSerializeFlags and the result for \p
@@ -280,9 +310,21 @@ bool CrossModuleOptimization::canSerializeInstruction(SILInstruction *inst,
     // public functions, because that can increase code size. E.g. if the
     // function is completely inlined afterwards.
     // Also, when emitting TBD files, we cannot introduce a new public symbol.
-    if ((conservative || M.getOptions().emitTBD) &&
-        !hasPublicOrPackageVisibility(callee->getLinkage(), M.getOptions().EnableSerializePackage)) {
-      return false;
+    if (conservative || M.getOptions().emitTBD) {
+      // In package-cmo, serialize this inst if its referenced function has
+      // package+ linkage, or is a definition with shared linkage.
+      // For example, `public func foo() { print("") }` is a function with
+      // public linkage which contains `print`, which is a definition with
+      // shared linkage, thus should be serialized.
+      if (M.getOptions().EnableSerializePackage) {
+        if (!(hasPublicOrPackageVisibility(callee->getLinkage(),
+                                           /*includePackage*/ true) ||
+              (hasSharedVisibility(callee->getLinkage()) &&
+               callee->isDefinition())))
+          return false;
+      } else if (!hasPublicVisibility(callee->getLinkage())) {
+        return false;
+      }
     }
 
     // In some project configurations imported C functions are not necessarily
@@ -374,7 +416,7 @@ bool CrossModuleOptimization::canSerializeType(SILType type) {
     [this](Type rawSubType) {
       CanType subType = rawSubType->getCanonicalType();
       if (NominalTypeDecl *subNT = subType->getNominalOrBoundGenericNominal()) {
-      
+
         if (conservative && subNT->getEffectiveAccess() < AccessLevel::Package) {
           return true;
         }
@@ -482,6 +524,12 @@ bool CrossModuleOptimization::shouldSerialize(SILFunction *function) {
 
     if (function->getLinkage() == SILLinkage::Shared)
       return true;
+  } else if (function->getModule().getOptions().EnableSerializePackage &&
+             (function->getLinkage() == SILLinkage::Package ||
+              function->getLinkage() == SILLinkage::Public)) {
+    // If package-cmo is enabled, we should not limit the amount of inlining
+    // as checked with CMOFunctionSizeLimit below.
+    return true;
   }
 
   // Also serialize "small" non-generic functions.
@@ -503,7 +551,7 @@ void CrossModuleOptimization::serializeFunction(SILFunction *function,
                                        const FunctionFlags &canSerializeFlags) {
   if (function->isSerialized())
     return;
-  
+
   if (!canSerializeFlags.lookup(function))
     return;
 
@@ -699,7 +747,10 @@ class CrossModuleOptimizationPass: public SILModuleTransform {
   void run() override {
 
     auto &M = *getModule();
-    if (M.getSwiftModule()->isResilient())
+    if (M.getSwiftModule()->isResilient() &&
+        // FIXME: need to properly lower type when this is enabled
+        // else leads to assert fail.
+        !M.getOptions().EnableSerializePackage)
       return;
     if (!M.isWholeModule())
       return;
@@ -727,6 +778,7 @@ class CrossModuleOptimizationPass: public SILModuleTransform {
 
     CrossModuleOptimization CMO(M, conservative, everything);
     CMO.serializeFunctionsInModule();
+    CMO.serializeTablesInModule();
   }
 };