Serialize SIL witness-tables and v-tables and their entries 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 the
client module.

If package cmo is enabled, allow serializing a definition with shared linkage
so a function referencing such def can be serialized. Also modified to allow
serializing witness thunks for conformance with package linkage. Added a step
after serializing SIL functions to loop over v-tables and witness-tables and
serialize entries and tables if serializable.

rdar://124632670

Author: elsh

include/swift/SIL/SILLinkage.h

@@ -394,12 +394,16 @@ inline SILLinkage effectiveLinkageForClassMember(SILLinkage linkage,
 // protocol requirement, even if the extended type is not public;
 // then SILGen gives the member private linkage, ignoring the more
 // visible access level it was given in the AST.
-inline bool
-fixmeWitnessHasLinkageThatNeedsToBePublic(SILDeclRef witness) {
+//
+// Despite the FIXME above, this is still used to determine the linkage
+// for witness thunks. In case package serialization is enabled, we need
+// to take the package linkage into account so we can set a proper final
+// linkage to the thunks in the witness table with a package linkage.
+inline bool fixmeWitnessHasLinkageThatNeedsToBePublic(SILDeclRef witness,
+                                                      bool isPackageVisible) {
   auto witnessLinkage = witness.getLinkage(ForDefinition);
-  return !hasPublicVisibility(witnessLinkage)
-         && (!hasSharedVisibility(witnessLinkage)
-             || !witness.isSerialized());
+  return !hasPublicOrPackageVisibility(witnessLinkage, isPackageVisible) &&
+         (!hasSharedVisibility(witnessLinkage) || !witness.isSerialized());
 }
 
 } // end swift namespace

lib/SIL/IR/SILSymbolVisitor.cpp

@@ -289,7 +289,9 @@ class SILSymbolVisitorImpl : public ASTVisitor<SILSymbolVisitorImpl> {
             return;
 
           if (!isa<SelfProtocolConformance>(rootConformance) &&
-              !fixmeWitnessHasLinkageThatNeedsToBePublic(witnessRef)) {
+              !fixmeWitnessHasLinkageThatNeedsToBePublic(
+                  witnessRef,
+                  witnessRef.getASTContext().SILOpts.EnableSerializePackage)) {
             return;
           }
         }

lib/SIL/IR/SILWitnessTable.cpp

@@ -171,11 +171,19 @@ bool SILWitnessTable::conformanceIsSerialized(
   if (normalConformance && normalConformance->isResilient())
     return false;
 
-  if (conformance->getProtocol()->getEffectiveAccess() < AccessLevel::Public)
+  // Allow serializing conformance with package access level if
+  // package serialization is enabled.
+  auto optInPackage = conformance->getDeclContext()
+                          ->getASTContext()
+                          .SILOpts.EnableSerializePackage;
+  auto accessLevelToCheck =
+      optInPackage ? AccessLevel::Package : AccessLevel::Public;
+
+  if (conformance->getProtocol()->getEffectiveAccess() < accessLevelToCheck)
     return false;
 
   auto *nominal = conformance->getDeclContext()->getSelfNominalTypeDecl();
-  return nominal->getEffectiveAccess() >= AccessLevel::Public;
+  return nominal->getEffectiveAccess() >= accessLevelToCheck;
 }
 
 bool SILWitnessTable::enumerateWitnessTableConditionalConformances(

lib/SILGen/SILGenType.cpp

@@ -635,7 +635,12 @@ class SILGenConformance : public SILGenWitnessTable<SILGenConformance> {
     auto witnessLinkage = witnessRef.getLinkage(ForDefinition);
     auto witnessSerialized = Serialized;
     if (witnessSerialized &&
-        fixmeWitnessHasLinkageThatNeedsToBePublic(witnessRef)) {
+        // If package optimization is enabled, this is false;
+        // witness thunk should get a `shared` linkage in the
+        // else block below.
+        fixmeWitnessHasLinkageThatNeedsToBePublic(
+            witnessRef,
+            witnessRef.getASTContext().SILOpts.EnableSerializePackage)) {
       witnessLinkage = SILLinkage::Public;
       witnessSerialized = IsNotSerialized;
     } else {

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,
@@ -172,6 +173,14 @@ static bool isVisible(AccessLevel accessLevel, SILOptions options) {
   return accessLevel == AccessLevel::Public;
 }
 
+static bool hasSerializableVisibility(SILLinkage linkage, bool isDefinition,
+                                      SILOptions options) {
+  if (options.EnableSerializePackage)
+    return (hasPublicOrPackageVisibility(linkage, /*includePackage*/ true) ||
+            (hasSharedVisibility(linkage) && isDefinition));
+  return hasPublicVisibility(linkage);
+}
+
 /// Select functions in the module which should be serialized.
 void CrossModuleOptimization::serializeFunctionsInModule() {
 
@@ -188,6 +197,40 @@ 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() && hasPublicOrPackageVisibility(
+                                  wt.getLinkage(), /*includePackage*/ true)) {
+      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() &&
+            hasSerializableVisibility(
+                entry.getMethodWitness().Witness->getLinkage(),
+                entry.getMethodWitness().Witness->isDefinition(),
+                M.getOptions())) {
+          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 +323,16 @@ 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, allow serializing this inst if its referenced function
+      // is a definition with a shared linkage or has a package/public linkage.
+      // For example, `public func foo() { print("") }` is a function with
+      // a public linkage which references `print`; the definition of `print`
+      // should have a shared linkage and be allowed to be serialized, so that
+      // `foo` could be serialized.
+      if (!hasSerializableVisibility(callee->getLinkage(),
+                                     callee->isDefinition(), M.getOptions()))
+        return false;
     }
 
     // In some project configurations imported C functions are not necessarily
@@ -306,7 +356,8 @@ bool CrossModuleOptimization::canSerializeInstruction(SILInstruction *inst,
   if (auto *GAI = dyn_cast<GlobalAddrInst>(inst)) {
     SILGlobalVariable *global = GAI->getReferencedGlobal();
     if ((conservative || M.getOptions().emitTBD) &&
-        !hasPublicOrPackageVisibility(global->getLinkage(), M.getOptions().EnableSerializePackage)) {
+        !hasSerializableVisibility(global->getLinkage(), global->isDefinition(),
+                                   M.getOptions())) {
       return false;
     }
 
@@ -354,7 +405,9 @@ bool CrossModuleOptimization::canSerializeGlobal(SILGlobalVariable *global) {
       // function is completely inlined afterwards.
       // Also, when emitting TBD files, we cannot introduce a new public symbol.
       if ((conservative || M.getOptions().emitTBD) &&
-          !hasPublicOrPackageVisibility(referencedFunc->getLinkage(), M.getOptions().EnableSerializePackage)) {
+          !hasSerializableVisibility(referencedFunc->getLinkage(),
+                                     referencedFunc->isDefinition(),
+                                     M.getOptions())) {
         return false;
       }
 
@@ -374,7 +427,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 +535,12 @@ bool CrossModuleOptimization::shouldSerialize(SILFunction *function) {
 
     if (function->getLinkage() == SILLinkage::Shared)
       return true;
+  } else if (hasSerializableVisibility(function->getLinkage(),
+                                       function->isDefinition(),
+                                       function->getModule().getOptions())) {
+    // 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 +562,7 @@ void CrossModuleOptimization::serializeFunction(SILFunction *function,
                                        const FunctionFlags &canSerializeFlags) {
   if (function->isSerialized())
     return;
-  
+
   if (!canSerializeFlags.lookup(function))
     return;
 
@@ -699,7 +758,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 +789,7 @@ class CrossModuleOptimizationPass: public SILModuleTransform {
 
     CrossModuleOptimization CMO(M, conservative, everything);
     CMO.serializeFunctionsInModule();
+    CMO.serializeTablesInModule();
   }
 };