[Embedded] Introduce a new linkage model for embedded Swift

Author: DougGregor

include/swift/AST/DeclAttr.def

@@ -201,7 +201,11 @@ SIMPLE_DECL_ATTR(requires_stored_property_inits, RequiresStoredPropertyInits,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove | UnreachableInABIAttr,
   27)
 
-// Unused '28'
+SIMPLE_DECL_ATTR(alwaysEmitIntoObjectFile, AlwaysEmitIntoObjectFile,
+  OnAbstractFunction| OnVar | OnSubscript,
+  UserInaccessible | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove | ForbiddenInABIAttr,
+  28)
+
 // Unused '29'
 
 SIMPLE_DECL_ATTR(nonobjc, NonObjC,

include/swift/AST/DiagnosticsSema.def

@@ -1000,6 +1000,12 @@ ERROR(cannot_import_non_embedded_module,none,
       (Identifier))
 ERROR(volatile_is_experimental,none,
       "importing _Volatile module requires '-enable-experimental-feature Volatile'", ())
+ERROR(in_object_file_experimental,none,
+      "'@alwaysEmitIntoObjectFile' attribute requires '-enable-experimental-feature EmbeddedLinkageModel'", ())
+ERROR(in_object_file_generic,none,
+      "'@alwaysEmitIntoObjectFile' cannot be used on a generic function", ())
+ERROR(in_object_file_inlinable,none,
+      "'@alwaysEmitIntoObjectFile' cannot be used with inlinable attribute", ())
 
 ERROR(need_cxx_interop_to_import_module,none,
       "module %0 was built with C++ interoperability enabled, but "

include/swift/Basic/Features.def

@@ -420,6 +420,9 @@ EXPERIMENTAL_FEATURE(RawLayout, true)
 /// Enables the "embedded" swift mode (no runtime).
 EXPERIMENTAL_FEATURE(Embedded, true)
 
+/// Embedded linkage model.
+EXPERIMENTAL_FEATURE(EmbeddedLinkageModel, true)
+
 /// Enables importing the Volatile module
 EXPERIMENTAL_FEATURE(Volatile, true)
 

include/swift/SIL/SILDeclRef.h

@@ -401,6 +401,10 @@ struct SILDeclRef {
   /// True if the function has the @backDeployed attribute.
   bool isBackDeployed() const;
 
+  /// True if this function must be emitted to an object file in embedded
+  /// mode.
+  bool isEmittedToObjectFile() const;
+
   /// Return the expected linkage for a definition of this declaration.
   SILLinkage getDefinitionLinkage() const;
 

lib/AST/ASTDumper.cpp

@@ -5055,6 +5055,7 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, Label>,
   TRIVIAL_ATTR_PRINTER(WeakLinked, weak_linked)
   TRIVIAL_ATTR_PRINTER(Nonexhaustive, nonexhaustive)
   TRIVIAL_ATTR_PRINTER(Concurrent, concurrent)
+  TRIVIAL_ATTR_PRINTER(AlwaysEmitIntoObjectFile, alwaysEmitIntoObjectFile)
 
 #undef TRIVIAL_ATTR_PRINTER
 

lib/AST/FeatureSet.cpp

@@ -118,6 +118,7 @@ UNINTERESTING_FEATURE(DoExpressions)
 UNINTERESTING_FEATURE(ImplicitLastExprResults)
 UNINTERESTING_FEATURE(RawLayout)
 UNINTERESTING_FEATURE(Embedded)
+UNINTERESTING_FEATURE(EmbeddedLinkageModel)
 UNINTERESTING_FEATURE(Volatile)
 UNINTERESTING_FEATURE(SuppressedAssociatedTypes)
 UNINTERESTING_FEATURE(StructLetDestructuring)

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -261,6 +261,7 @@ extension ASTGenVisitor {
         .ImplicitSelfCapture,
         .InheritsConvenienceInitializers,
         .Inlinable,
+        .AlwaysEmitIntoObjectFile,
         .Isolated,
         .LexicalLifetimes,
         .LLDBDebuggerFunction,

lib/IRGen/GenDecl.cpp

@@ -1157,8 +1157,15 @@ static bool isLazilyEmittedFunction(SILFunction &f, SILModule &m) {
     return true;
   }
 
-  if (f.isPossiblyUsedExternally())
+  if (f.isPossiblyUsedExternally()) {
+    // Under the embedded linkage model, if the declaration is not specifically
+    // emitted to the object file, it's lazy.
+    if (f.getASTContext().LangOpts.hasFeature(Feature::EmbeddedLinkageModel) &&
+        !f.getDeclRef().isEmittedToObjectFile())
+      return true;
+
     return false;
+  }
 
   if (f.getDynamicallyReplacedFunction())
     return false;

lib/SIL/IR/SILDeclRef.cpp

@@ -510,15 +510,21 @@ static LinkageLimit getLinkageLimit(SILDeclRef constant) {
   case Kind::GlobalAccessor:
     // global unsafeMutableAddressor should be kept hidden if its decl
     // is resilient.
-    return cast<VarDecl>(d)->isResilient() ? Limit::NeverPublic : Limit::None;
+    if (cast<VarDecl>(d)->isResilient())
+      return Limit::NeverPublic;
+
+    break;
 
   case Kind::DefaultArgGenerator:
     // If the default argument is to be serialized, only use non-ABI public
     // linkage. If the argument is not to be serialized, don't use a limit.
     // This actually means that default arguments *can be ABI public* if
     // `isSerialized()` returns false and the effective access level is public,
     // which happens under `-enable-testing` with an internal decl.
-    return constant.isSerialized() ? Limit::AlwaysEmitIntoClient : Limit::None;
+    if (constant.isSerialized())
+      return Limit::AlwaysEmitIntoClient;
+
+    break;
 
   case Kind::PropertyWrapperBackingInitializer:
   case Kind::PropertyWrapperInitFromProjectedValue: {
@@ -528,9 +534,12 @@ static LinkageLimit getLinkageLimit(SILDeclRef constant) {
       // This actually means that it *can be ABI public* if `isSerialized()`
       // returns false and the effective access level is public, which happens
       // under `-enable-testing` with an internal decl.
-      return constant.isSerialized() ? Limit::AlwaysEmitIntoClient
-                                     : Limit::None;
+      if (constant.isSerialized())
+        return Limit::AlwaysEmitIntoClient;
+
+      break;
     }
+
     // Otherwise, regular property wrapper backing initializers (for properties)
     // are treated just like stored property initializers.
     LLVM_FALLTHROUGH;
@@ -571,6 +580,14 @@ static LinkageLimit getLinkageLimit(SILDeclRef constant) {
   case Kind::AsyncEntryPoint:
     llvm_unreachable("Already handled");
   }
+
+  // When using the Embedded linkage model, any symbol not explicitly emitted
+  // to the object file is considered on-demand
+  if (d->getASTContext().LangOpts.hasFeature(Feature::EmbeddedLinkageModel) &&
+      !constant.isSerialized() &&
+      !constant.isEmittedToObjectFile())
+    return Limit::OnDemand;
+
   return Limit::None;
 }
 
@@ -1089,6 +1106,18 @@ bool SILDeclRef::isBackDeployed() const {
   return false;
 }
 
+bool SILDeclRef::isEmittedToObjectFile() const {
+  // Entry points are always emitted to the object file.
+  if (kind == Kind::EntryPoint)
+    return true;
+
+  auto decl = getDecl();
+  if (!decl)
+    return false;
+
+  return decl->getAttrs().hasAttribute<AlwaysEmitIntoObjectFileAttr>();
+}
+
 bool SILDeclRef::isForeignToNativeThunk() const {
   // If this isn't a native entry-point, it's not a foreign-to-native thunk.
   if (isForeign)

lib/SILOptimizer/IPO/CrossModuleOptimization.cpp

@@ -1005,7 +1005,10 @@ void CrossModuleOptimization::keepMethodAlive(SILDeclRef method) {
 void CrossModuleOptimization::makeFunctionUsableFromInline(SILFunction *function) {
   assert(canUseFromInline(function));
   if (!isAvailableExternally(function->getLinkage()) &&
-      !isPackageOrPublic(function->getLinkage())) {
+      !isPackageOrPublic(function->getLinkage()) &&
+      !(function->getLinkage() == SILLinkage::Shared &&
+        M.getSwiftModule()->getASTContext().LangOpts.hasFeature(
+            Feature::EmbeddedLinkageModel))) {
     function->setLinkage(SILLinkage::Public);
   }
 }