[Embedded] Emit weak definitions for imported symbols

When Embedded Swift emits a symbol that was imported from another
module, ensure that the symbol is emitted as a weak definition. This
way, importing the same module (and using its symbol) into several
different modules doesn't cause duplicate-symbol errors at link time.
Rather, the linker will merge the different symbol definitions. This
makes Embedded Swift libraries work without resorting to
`-mergeable-symbols` or `-emit-empty-object-file`.

Author: DougGregor

include/swift/IRGen/Linking.h

@@ -1850,6 +1850,14 @@ class LinkEntity {
   bool isTypeKind() const { return isTypeKind(getKind()); }
 
   bool isAlwaysSharedLinkage() const;
+
+  /// Whether the link entity's definitions must be considered non-unique.
+  ///
+  /// This applies only in the Embedded Swift linkage model, and is used for
+  /// any symbols that have not been explicitly requested to have unique
+  /// definitions (e.g., with @_used).
+  bool hasNonUniqueDefinition() const;
+
 #undef LINKENTITY_GET_FIELD
 #undef LINKENTITY_SET_FIELD
 

include/swift/SIL/SILDeclRef.h

@@ -399,6 +399,14 @@ struct SILDeclRef {
   /// True if the function has the @backDeployed attribute.
   bool isBackDeployed() const;
 
+  /// True if this entity should have a non-unique definition based on the
+  /// embedded linkage model.
+  bool hasNonUniqueDefinition() const;
+
+  /// True if the declaration should have a non-unique definition based on the
+  /// embedded linkage model.
+  static bool declHasNonUniqueDefinition(const ValueDecl *decl);
+
   /// Return the expected linkage for a definition of this declaration.
   SILLinkage getDefinitionLinkage() const;
 

include/swift/SIL/SILFunction.h

@@ -659,6 +659,10 @@ class SILFunction
 
   bool isNoReturnFunction(TypeExpansionContext context) const;
 
+  /// True if this function should have a non-unique definition based on the
+  /// embedded linkage model.
+  bool hasNonUniqueDefinition() const;
+
   /// Unsafely rewrite the lowered type of this function.
   ///
   /// This routine does not touch the entry block arguments
@@ -916,6 +920,10 @@ class SILFunction
     return swift::isAvailableExternally(getLinkage());
   }
 
+  /// Helper method that determines whether this SILFunction is a Swift runtime
+  /// function, such as swift_retain.
+  bool isSwiftRuntimeFunction() const;
+
   /// Helper method which returns true if the linkage of the SILFunction
   /// indicates that the object's definition might be required outside the
   /// current SILModule.

include/swift/SIL/SILGlobalVariable.h

@@ -151,6 +151,10 @@ class SILGlobalVariable
   /// might be referenced from outside the current compilation unit.
   bool isPossiblyUsedExternally() const;
 
+  /// True if this variable should have a non-unique definition based on the
+  /// embedded linkage model.
+  bool hasNonUniqueDefinition() const;
+
   /// Returns true if this global variable should be preserved so it can
   /// potentially be inspected by the debugger.
   bool shouldBePreservedForDebugger() const;

lib/IRGen/GenDecl.cpp

@@ -1156,9 +1156,17 @@ static bool isLazilyEmittedFunction(SILFunction &f, SILModule &m) {
       f.getLoweredFunctionType()->getSubstGenericSignature()) {
     return true;
   }
-  
-  if (f.isPossiblyUsedExternally())
+
+  if (f.isPossiblyUsedExternally()) {
+    // Under the embedded linkage model, if it has a non-unique definition,
+    // treat it lazily.
+    if (f.hasNonUniqueDefinition() && !f.isSwiftRuntimeFunction()
+        && !f.markedAsUsed()) {
+      return true;
+    }
+
     return false;
+  }
 
   if (f.getDynamicallyReplacedFunction())
     return false;
@@ -2244,7 +2252,8 @@ void IRGenerator::emitEntryPointInfo() {
 static IRLinkage
 getIRLinkage(StringRef name, const UniversalLinkageInfo &info,
              SILLinkage linkage, ForDefinition_t isDefinition,
-             bool isWeakImported, bool isKnownLocal = false) {
+             bool isWeakImported, bool isKnownLocal,
+             bool hasNonUniqueDefinition) {
 #define RESULT(LINKAGE, VISIBILITY, DLL_STORAGE)                               \
   IRLinkage{llvm::GlobalValue::LINKAGE##Linkage,                               \
             llvm::GlobalValue::VISIBILITY##Visibility,                         \
@@ -2275,7 +2284,9 @@ getIRLinkage(StringRef name, const UniversalLinkageInfo &info,
   case SILLinkage::Package: {
     auto linkage = llvm::GlobalValue::ExternalLinkage;
 
-    if (info.MergeableSymbols)
+    if (hasNonUniqueDefinition)
+      linkage = llvm::GlobalValue::WeakODRLinkage;
+    else if (info.MergeableSymbols)
       linkage = llvm::GlobalValue::WeakODRLinkage;
 
     return {linkage, PublicDefinitionVisibility,
@@ -2293,6 +2304,8 @@ getIRLinkage(StringRef name, const UniversalLinkageInfo &info,
                         : RESULT(External, Hidden, Default);
 
   case SILLinkage::Hidden:
+    if (hasNonUniqueDefinition)
+      return RESULT(WeakODR, Hidden, Default);
     if (info.MergeableSymbols)
       return RESULT(WeakODR, Hidden, Default);
 
@@ -2301,7 +2314,7 @@ getIRLinkage(StringRef name, const UniversalLinkageInfo &info,
   case SILLinkage::Private: {
     if (info.forcePublicDecls() && !isDefinition)
       return getIRLinkage(name, info, SILLinkage::PublicExternal, isDefinition,
-                          isWeakImported, isKnownLocal);
+                          isWeakImported, isKnownLocal, hasNonUniqueDefinition);
 
     auto linkage = info.needLinkerToMergeDuplicateSymbols()
                        ? llvm::GlobalValue::LinkOnceODRLinkage
@@ -2357,7 +2370,8 @@ void irgen::updateLinkageForDefinition(IRGenModule &IGM,
   auto IRL =
       getIRLinkage(global->hasName() ? global->getName() : StringRef(),
                    linkInfo, entity.getLinkage(ForDefinition), ForDefinition,
-                   weakImported, isKnownLocal);
+                   weakImported, isKnownLocal,
+                   entity.hasNonUniqueDefinition());
   ApplyIRLinkage(IRL).to(global);
 
   LinkInfo link = LinkInfo::get(IGM, entity, ForDefinition);
@@ -2410,7 +2424,8 @@ LinkInfo LinkInfo::get(const UniversalLinkageInfo &linkInfo,
   bool weakImported = entity.isWeakImported(swiftModule);
   result.IRL = getIRLinkage(result.Name, linkInfo,
                             entity.getLinkage(isDefinition), isDefinition,
-                            weakImported, isKnownLocal);
+                            weakImported, isKnownLocal,
+                            entity.hasNonUniqueDefinition());
   result.ForDefinition = isDefinition;
   return result;
 }
@@ -2421,7 +2436,8 @@ LinkInfo LinkInfo::get(const UniversalLinkageInfo &linkInfo, StringRef name,
   LinkInfo result;
   result.Name += name;
   result.IRL = getIRLinkage(name, linkInfo, linkage, isDefinition,
-                            isWeakImported, linkInfo.Internalize);
+                            isWeakImported, linkInfo.Internalize,
+                            /*hasNonUniqueDefinition=*/false);
   result.ForDefinition = isDefinition;
   return result;
 }

lib/IRGen/Linking.cpp

@@ -1734,3 +1734,31 @@ bool LinkEntity::isAlwaysSharedLinkage() const {
     return false;
   }
 }
+
+bool LinkEntity::hasNonUniqueDefinition() const {
+  if (isDeclKind(getKind())) {
+    auto decl = getDecl();
+    return SILDeclRef::declHasNonUniqueDefinition(decl);
+  }
+
+  if (hasSILFunction()) {
+    return getSILFunction()->hasNonUniqueDefinition();
+  }
+
+  if (getKind() == Kind::SILGlobalVariable ||
+      getKind() == Kind::ReadOnlyGlobalObject)
+    return getSILGlobalVariable()->hasNonUniqueDefinition();
+
+  if (getKind() == Kind::TypeMetadata) {
+    // For a nominal type, check its declaration.
+    CanType type = getType();
+    if (auto nominal = type->getAnyNominal()) {
+      return SILDeclRef::declHasNonUniqueDefinition(nominal);
+    }
+
+    // All other type metadata is nonuniqued.
+    return true;
+  }
+
+  return false;
+}

lib/SIL/IR/SILDeclRef.cpp

@@ -571,6 +571,7 @@ static LinkageLimit getLinkageLimit(SILDeclRef constant) {
   case Kind::AsyncEntryPoint:
     llvm_unreachable("Already handled");
   }
+
   return Limit::None;
 }
 
@@ -1089,6 +1090,25 @@ bool SILDeclRef::isBackDeployed() const {
   return false;
 }
 
+bool SILDeclRef::hasNonUniqueDefinition() const {
+  if (auto decl = getDecl())
+    return declHasNonUniqueDefinition(decl);
+
+  return false;
+}
+
+bool SILDeclRef::declHasNonUniqueDefinition(const ValueDecl *decl) {
+  // This function only forces the issue in embedded.
+  if (!decl->getASTContext().LangOpts.hasFeature(Feature::Embedded))
+    return false;
+
+  // If the declaration is not from the main module, treat its definition as
+  // non-unique.
+  auto module = decl->getModuleContext();
+  auto &ctx = module->getASTContext();
+  return module != ctx.MainModule && ctx.MainModule;
+}
+
 bool SILDeclRef::isForeignToNativeThunk() const {
   // If this isn't a native entry-point, it's not a foreign-to-native thunk.
   if (isForeign)

lib/SIL/IR/SILFunction.cpp

@@ -553,6 +553,24 @@ bool SILFunction::isNoReturnFunction(TypeExpansionContext context) const {
       .isNoReturnFunction(getModule(), context);
 }
 
+bool SILFunction::hasNonUniqueDefinition() const {
+  // Non-uniqueness is a property of the Embedded linkage model.
+  if (!getASTContext().LangOpts.hasFeature(Feature::Embedded))
+    return false;
+
+  // If this is for a declaration, ask it.
+  if (auto declRef = getDeclRef()) {
+    return declRef.hasNonUniqueDefinition();
+  }
+
+  // If this function is from a different module than the one we are emitting
+  // code for, then it must have a non-unique definition.
+  if (getParentModule() != getModule().getSwiftModule())
+    return true;
+
+  return false;
+}
+
 ResilienceExpansion SILFunction::getResilienceExpansion() const {
   // If a function definition is in another module, and
   // it was serialized due to package serialization opt,
@@ -1016,6 +1034,17 @@ bool SILFunction::hasValidLinkageForFragileRef(SerializedKind_t callerSerialized
   return hasPublicOrPackageVisibility(getLinkage(), /*includePackage*/ true);
 }
 
+bool SILFunction::isSwiftRuntimeFunction() const {
+  if (!getName().starts_with("swift_") &&
+      !getName().starts_with("_swift_"))
+    return false;
+
+  auto module = getParentModule();
+  return !module ||
+      module->getName().str() == "Swift" ||
+      module->getName().str() == "_Concurrency";
+}
+
 bool
 SILFunction::isPossiblyUsedExternally() const {
   auto linkage = getLinkage();
@@ -1046,6 +1075,11 @@ SILFunction::isPossiblyUsedExternally() const {
       hasOpaqueResultTypeWithAvailabilityConditions())
     return true;
 
+  // All Swift runtime functions can be used externally.
+  if (getASTContext().LangOpts.hasFeature(Feature::Embedded) &&
+      isSwiftRuntimeFunction())
+    return true;
+
   return swift::isPossiblyUsedExternally(linkage, getModule().isWholeModule());
 }
 

lib/SIL/IR/SILGlobalVariable.cpp

@@ -88,6 +88,14 @@ bool SILGlobalVariable::isPossiblyUsedExternally() const {
   return swift::isPossiblyUsedExternally(linkage, getModule().isWholeModule());
 }
 
+bool SILGlobalVariable::hasNonUniqueDefinition() const {
+  auto decl = getDecl();
+  if (!decl)
+    return false;
+
+  return SILDeclRef::declHasNonUniqueDefinition(decl);
+}
+
 bool SILGlobalVariable::shouldBePreservedForDebugger() const {
   if (getModule().getOptions().OptMode != OptimizationMode::NoOptimization)
     return false;

lib/SILOptimizer/IPO/CrossModuleOptimization.cpp

@@ -950,7 +950,9 @@ void CrossModuleOptimization::serializeInstruction(SILInstruction *inst,
     }
     serializeFunction(callee, canSerializeFlags);
     assert(isSerializedWithRightKind(M, callee) ||
-           isPackageOrPublic(callee->getLinkage()));
+           isPackageOrPublic(callee->getLinkage()) ||
+           M.getSwiftModule()->getASTContext().LangOpts.hasFeature(
+              Feature::Embedded));
     return;
   }
 
@@ -1005,7 +1007,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::Embedded))) {
     function->setLinkage(SILLinkage::Public);
   }
 }