Support Package CMO

* Add a new flag -experimental-package-cmo that requires -experimental-allow-non-resilient-access.
* Support serializing package decls for CMO in package if enabled.
* Only applies to default mode CMO.
* Unlike the existing CMO, package CMO can be built with -enable-library-evolution as package
modules are required to be built together in the same project.
* Create hasPublicOrPackageVisibility to opt in for package decls; needed for CMO, SILVerifier,
and other call sites that verify or determine codegen.

Resolves rdar://121976014

Author: elsh

include/swift/AST/SILOptions.h

@@ -126,6 +126,14 @@ class SILOptions {
   /// Controls whether cross module optimization is enabled.
   CrossModuleOptimizationMode CMOMode = CrossModuleOptimizationMode::Off;
 
+  /// Optimization to perform default CMO within a package boundary.
+  /// Unlike the existing CMO, package CMO can be built with
+  /// -enable-library-evolution since package modules are required
+  /// to be built in the same project. To enable this optimization, the
+  /// module also needs to opt in to allow non-resilient access with
+  /// -experimental-allow-non-resilient-access.
+  bool EnableSerializePackage = true;
+
   /// Enables the emission of stack protectors in functions.
   bool EnableStackProtection = true;
 

include/swift/Option/Options.td

@@ -984,6 +984,10 @@ def Oplayground : Flag<["-"], "Oplayground">, Group<O_Group>,
   Flags<[HelpHidden, FrontendOption, ModuleInterfaceOption]>,
   HelpText<"Compile with optimizations appropriate for a playground">;
 
+def ExperimentalPackageCMO : Flag<["-"], "experimental-package-cmo">,
+  Flags<[FrontendOption]>,
+  HelpText<"Enable optimization to perform defalut CMO within a package boundary">;
+
 def EnbaleDefaultCMO : Flag<["-"], "enable-default-cmo">,
   Flags<[HelpHidden, FrontendOption]>,
   HelpText<"Perform conservative cross-module optimization">;

include/swift/SIL/SILLinkage.h

@@ -289,6 +289,26 @@ inline bool hasPublicVisibility(SILLinkage linkage) {
   llvm_unreachable("Unhandled SILLinkage in switch.");
 }
 
+inline bool hasPublicOrPackageVisibility(SILLinkage linkage, bool includePackage) {
+    switch (linkage) {
+    case SILLinkage::Public:
+    case SILLinkage::PublicExternal:
+    case SILLinkage::PublicNonABI:
+        return true;
+    case SILLinkage::Package:
+    case SILLinkage::PackageExternal:
+    case SILLinkage::PackageNonABI:
+        return includePackage;
+    case SILLinkage::Hidden:
+    case SILLinkage::Shared:
+    case SILLinkage::Private:
+    case SILLinkage::HiddenExternal:
+        return false;
+    }
+
+    llvm_unreachable("Unhandled SILLinkage in switch.");
+}
+
 inline bool hasSharedVisibility(SILLinkage linkage) {
   switch (linkage) {
   case SILLinkage::Shared:

lib/Driver/ToolChains.cpp

@@ -300,6 +300,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
   inputArgs.AddLastArg(arguments, options::OPT_suppress_warnings);
   inputArgs.AddLastArg(arguments, options::OPT_suppress_remarks);
   inputArgs.AddLastArg(arguments, options::OPT_experimental_package_bypass_resilience);
+  inputArgs.AddLastArg(arguments, options::OPT_ExperimentalPackageCMO);
   inputArgs.AddLastArg(arguments, options::OPT_profile_generate);
   inputArgs.AddLastArg(arguments, options::OPT_profile_use);
   inputArgs.AddLastArg(arguments, options::OPT_profile_coverage_mapping);

lib/Frontend/CompilerInvocation.cpp

@@ -2335,6 +2335,18 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
   } else if (Args.hasArg(OPT_EnbaleCMOEverything)) {
     Opts.CMOMode = CrossModuleOptimizationMode::Everything;
   }
+
+  if (Args.hasArg(OPT_ExperimentalPackageCMO)) {
+    if (!FEOpts.AllowNonResilientAccess) {
+      Diags.diagnose(SourceLoc(), diag::ignoring_option_requires_option,
+                     "-experimental-package-cmo",
+                     "-experimental-allow-non-resilient-access");
+    } else {
+      Opts.EnableSerializePackage = true;
+      Opts.CMOMode = CrossModuleOptimizationMode::Default;
+    }
+  }
+
   Opts.EnableStackProtection =
       Args.hasFlag(OPT_enable_stack_protector, OPT_disable_stack_protector,
                    Opts.EnableStackProtection);

lib/IRGen/IRGenSIL.cpp

@@ -2446,8 +2446,10 @@ void IRGenModule::emitSILFunction(SILFunction *f) {
       f->getLoweredFunctionType()->isPolymorphic())
     return;
 
-  // Do not emit bodies of public_external functions.
-  if (hasPublicVisibility(f->getLinkage()) && f->isAvailableExternally())
+  // Do not emit bodies of public_external or package_external functions.
+  if (hasPublicOrPackageVisibility(f->getLinkage(),
+                                   f->getASTContext().SILOpts.EnableSerializePackage) &&
+      f->isAvailableExternally())
     return;
 
   PrettyStackTraceSILFunction stackTrace("emitting IR", f);

lib/SIL/IR/SILFunction.cpp

@@ -898,8 +898,8 @@ bool SILFunction::hasValidLinkageForFragileRef() const {
       isAvailableExternally())
     return false;
 
-  // Otherwise, only public functions can be referenced.
-  return hasPublicVisibility(getLinkage());
+  // Otherwise, only public or package functions can be referenced.
+  return hasPublicOrPackageVisibility(getLinkage(), getModule().getOptions().EnableSerializePackage);
 }
 
 bool

lib/SIL/Verifier/SILVerifier.cpp

@@ -2417,7 +2417,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
     if (F.isSerialized()) {
       require(RefG->isSerialized()
-                || hasPublicVisibility(RefG->getLinkage()),
+                || hasPublicOrPackageVisibility(RefG->getLinkage(), F.getModule().getOptions().EnableSerializePackage),
               "alloc_global inside fragile function cannot "
               "reference a private or hidden symbol");
     }
@@ -2436,7 +2436,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
     if (F.isSerialized()) {
       require(RefG->isSerialized()
-              || hasPublicVisibility(RefG->getLinkage()),
+              || hasPublicOrPackageVisibility(RefG->getLinkage(), F.getModule().getOptions().EnableSerializePackage),
               "global_addr/value inside fragile function cannot "
               "reference a private or hidden symbol");
     }

lib/SILOptimizer/IPO/CrossModuleOptimization.cpp

@@ -161,14 +161,26 @@ class InstructionVisitor : public SILCloner<InstructionVisitor> {
   }
 };
 
+static bool isVisible(SILLinkage linkage, SILOptions options) {
+  if (options.EnableSerializePackage)
+    return linkage == SILLinkage::Public || linkage == SILLinkage::Package;
+  return linkage == SILLinkage::Public;
+}
+static bool isVisible(AccessLevel accessLevel, SILOptions options) {
+  if (options.EnableSerializePackage)
+    return accessLevel == AccessLevel::Package || accessLevel == AccessLevel::Public;
+  return accessLevel == AccessLevel::Public;
+}
+
 /// Select functions in the module which should be serialized.
 void CrossModuleOptimization::serializeFunctionsInModule() {
 
   FunctionFlags canSerializeFlags;
 
   // Start with public functions.
   for (SILFunction &F : M) {
-    if (F.getLinkage() == SILLinkage::Public || everything) {
+    if (isVisible(F.getLinkage(), M.getOptions()) ||
+        everything) {
       if (canSerializeFunction(&F, canSerializeFlags, /*maxDepth*/ 64)) {
         serializeFunction(&F, canSerializeFlags);
       }
@@ -185,7 +197,6 @@ bool CrossModuleOptimization::canSerializeFunction(
                                FunctionFlags &canSerializeFlags,
                                int maxDepth) {
   auto iter = canSerializeFlags.find(function);
-  
   // Avoid infinite recursion in case it's a cycle in the call graph.
   if (iter != canSerializeFlags.end())
     return iter->second;
@@ -270,7 +281,7 @@ bool CrossModuleOptimization::canSerializeInstruction(SILInstruction *inst,
     // function is completely inlined afterwards.
     // Also, when emitting TBD files, we cannot introduce a new public symbol.
     if ((conservative || M.getOptions().emitTBD) &&
-        !hasPublicVisibility(callee->getLinkage())) {
+        !hasPublicOrPackageVisibility(callee->getLinkage(), M.getOptions().EnableSerializePackage)) {
       return false;
     }
 
@@ -290,13 +301,12 @@ bool CrossModuleOptimization::canSerializeInstruction(SILInstruction *inst,
     // inline.
     if (!canUseFromInline(callee))
       return false;
-  
     return true;
   }
   if (auto *GAI = dyn_cast<GlobalAddrInst>(inst)) {
     SILGlobalVariable *global = GAI->getReferencedGlobal();
     if ((conservative || M.getOptions().emitTBD) &&
-        !hasPublicVisibility(global->getLinkage())) {
+        !hasPublicOrPackageVisibility(global->getLinkage(), M.getOptions().EnableSerializePackage)) {
       return false;
     }
 
@@ -344,7 +354,7 @@ 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) &&
-          !hasPublicVisibility(referencedFunc->getLinkage())) {
+          !hasPublicOrPackageVisibility(referencedFunc->getLinkage(), M.getOptions().EnableSerializePackage)) {
         return false;
       }
 
@@ -368,7 +378,7 @@ bool CrossModuleOptimization::canSerializeType(SILType type) {
         if (conservative && subNT->getEffectiveAccess() < AccessLevel::Package) {
           return true;
         }
-      
+
         // Exclude types which are defined in an @_implementationOnly imported
         // module. Such modules are not transitively available.
         if (!canUseFromInline(subNT)) {
@@ -542,15 +552,15 @@ void CrossModuleOptimization::serializeInstruction(SILInstruction *inst,
       }
     }
     serializeFunction(callee, canSerializeFlags);
-    assert(callee->isSerialized() || callee->getLinkage() == SILLinkage::Public);
+    assert(callee->isSerialized() || isVisible(callee->getLinkage(), M.getOptions()));
     return;
   }
   if (auto *GAI = dyn_cast<GlobalAddrInst>(inst)) {
     SILGlobalVariable *global = GAI->getReferencedGlobal();
     if (canSerializeGlobal(global)) {
       serializeGlobal(global);
     }
-    if (!hasPublicVisibility(global->getLinkage())) {
+    if (!hasPublicOrPackageVisibility(global->getLinkage(), M.getOptions().EnableSerializePackage)) {
       global->setLinkage(SILLinkage::Public);
     }
     return;
@@ -606,7 +616,7 @@ void CrossModuleOptimization::makeDeclUsableFromInline(ValueDecl *decl) {
   if (M.getSwiftModule() != decl->getDeclContext()->getParentModule())
     return;
 
-  if (decl->getFormalAccess() < AccessLevel::Public &&
+  if (!isVisible(decl->getFormalAccess(), M.getOptions()) &&
       !decl->isUsableFromInline()) {
     // Mark the nominal type as "usableFromInline".
     // TODO: find a way to do this without modifying the AST. The AST should be

lib/Serialization/DeserializeSIL.cpp

@@ -77,6 +77,7 @@ static std::optional<SILLinkage> fromStableSILLinkage(unsigned value) {
   case SIL_LINKAGE_SHARED: return SILLinkage::Shared;
   case SIL_LINKAGE_PRIVATE: return SILLinkage::Private;
   case SIL_LINKAGE_PUBLIC_EXTERNAL: return SILLinkage::PublicExternal;
+  case SIL_LINKAGE_PACKAGE_EXTERNAL: return SILLinkage::PackageExternal;
   case SIL_LINKAGE_HIDDEN_EXTERNAL: return SILLinkage::HiddenExternal;
   }