IRGen: Use extern_weak linkage for Clang symbols from @_weakLinked imported modules.

rdar://96098097

Author: tshortli

include/swift/AST/Module.h

@@ -414,12 +414,11 @@ class ModuleDecl
   /// present overlays as if they were part of their underlying module.
   std::pair<ModuleDecl *, Identifier> getDeclaringModuleAndBystander();
 
+public:
   ///  If this is a traditional (non-cross-import) overlay, get its underlying
   ///  module if one exists.
   ModuleDecl *getUnderlyingModuleIfOverlay() const;
 
-public:
-
   /// Returns true if this module is an underscored cross import overlay
   /// declared by \p other or its underlying clang module, either directly or
   /// transitively (via intermediate cross-import overlays - for cross-imports
@@ -686,8 +685,9 @@ class ModuleDecl
   // Is \p spiGroup accessible as an explicitly imported SPI from this module?
   bool isImportedAsSPI(Identifier spiGroup, const ModuleDecl *fromModule) const;
 
-  /// Is \p importedModule imported as \c @_weakLinked from this module?
-  bool importsModuleAsWeakLinked(const ModuleDecl *importedModule) const;
+  /// Is \p targetDecl from a module that is imported as \c @_weakLinked from
+  /// this module?
+  bool isImportedAsWeakLinked(const Decl *targetDecl) const;
 
   /// \sa getImportedModules
   enum class ImportFilterKind {

lib/AST/Decl.cpp

@@ -1002,7 +1002,7 @@ bool Decl::isWeakImported(ModuleDecl *fromModule) const {
   if (isAlwaysWeakImported())
     return true;
 
-  if (fromModule->importsModuleAsWeakLinked(getModuleContext()))
+  if (fromModule->isImportedAsWeakLinked(this))
     return true;
 
   auto availability = getAvailabilityForLinkage();

lib/AST/Module.cpp

@@ -2576,8 +2576,18 @@ bool SourceFile::isImportedAsSPI(const ValueDecl *targetDecl) const {
 
 bool SourceFile::importsModuleAsWeakLinked(const ModuleDecl *module) const {
   for (auto &import : *Imports) {
-    if (import.options.contains(ImportFlags::WeakLinked) &&
-        module == import.module.importedModule)
+    if (!import.options.contains(ImportFlags::WeakLinked))
+      continue;
+
+    const ModuleDecl *importedModule = import.module.importedModule;
+    if (module == importedModule)
+      return true;
+
+    // Also check whether the target module is actually the underlyingClang
+    // module for this @_weakLinked import.
+    const ModuleDecl *clangModule =
+        importedModule->getUnderlyingModuleIfOverlay();
+    if (module == clangModule)
       return true;
   }
   return false;
@@ -2608,10 +2618,10 @@ bool ModuleDecl::isImportedAsSPI(Identifier spiGroup,
   return importedSPIGroups.count(spiGroup);
 }
 
-bool ModuleDecl::importsModuleAsWeakLinked(
-    const ModuleDecl *importedModule) const {
+bool ModuleDecl::isImportedAsWeakLinked(const Decl *targetDecl) const {
+  const auto *declaringModule = targetDecl->getModuleContext();
   for (auto file : getFiles()) {
-    if (file->importsModuleAsWeakLinked(importedModule))
+    if (file->importsModuleAsWeakLinked(declaringModule))
       return true;
   }
   return false;

lib/IRGen/GenDecl.cpp

@@ -2487,10 +2487,23 @@ void IRGenModule::emitGlobalDecl(Decl *D) {
 Address IRGenModule::getAddrOfSILGlobalVariable(SILGlobalVariable *var,
                                                 const TypeInfo &ti,
                                                 ForDefinition_t forDefinition) {
+  LinkEntity entity = LinkEntity::forSILGlobalVariable(var, *this);
+  LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
+
   if (auto clangDecl = var->getClangDecl()) {
     auto addr = getAddrOfClangGlobalDecl(cast<clang::VarDecl>(clangDecl),
                                          forDefinition);
 
+    // Override the linkage computed by Clang if the decl is from another
+    // module that imported @_weakLinked.
+    //
+    // FIXME: We should be able to set the linkage unconditionally here but
+    //        some fixes are needed for Cxx interop.
+    if (auto globalVar = dyn_cast<llvm::GlobalVariable>(addr)) {
+      if (getSwiftModule()->isImportedAsWeakLinked(var->getDecl()))
+        globalVar->setLinkage(link.getLinkage());
+    }
+
     // If we're not emitting this to define it, make sure we cast it to the
     // right type.
     if (!forDefinition) {
@@ -2503,7 +2516,6 @@ Address IRGenModule::getAddrOfSILGlobalVariable(SILGlobalVariable *var,
     return Address(addr, alignment);
   }
 
-  LinkEntity entity = LinkEntity::forSILGlobalVariable(var, *this);
   ResilienceExpansion expansion = getResilienceExpansionForLayout(var);
 
   llvm::Type *storageType;
@@ -2549,7 +2561,6 @@ Address IRGenModule::getAddrOfSILGlobalVariable(SILGlobalVariable *var,
 
   // Check whether we've created the global variable already.
   // FIXME: We should integrate this into the LinkEntity cache more cleanly.
-  LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
   auto gvar = Module.getGlobalVariable(link.getName(), /*allowInternal*/ true);
   if (gvar) {
     if (forDefinition)
@@ -3222,6 +3233,7 @@ llvm::Function *IRGenModule::getAddrOfSILFunction(
     }
   }
 
+  LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
   bool isDefinition = f->isDefinition();
   bool hasOrderNumber =
       isDefinition && !shouldCallPreviousImplementation;
@@ -3242,8 +3254,16 @@ llvm::Function *IRGenModule::getAddrOfSILFunction(
   if (clangAddr) {
     fn = dyn_cast<llvm::Function>(clangAddr->stripPointerCasts());
 
-    // If we have a function, move it to the appropriate position.
     if (fn) {
+      // Override the linkage computed by Clang if the decl is from another
+      // module that imported @_weakLinked.
+      //
+      // FIXME: We should be able to set the linkage unconditionally here but
+      //        some fixes are needed for Cxx interop.
+      if (!forDefinition && f->isWeakImportedByModule())
+        fn->setLinkage(link.getLinkage());
+
+      // If we have a function, move it to the appropriate position.
       if (hasOrderNumber) {
         auto &fnList = Module.getFunctionList();
         fnList.remove(fn);
@@ -3264,8 +3284,6 @@ llvm::Function *IRGenModule::getAddrOfSILFunction(
       getSignature(f->getLoweredFunctionType(), fpKind);
   addLLVMFunctionAttributes(f, signature);
 
-  LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
-
   fn = createFunction(*this, link, signature, insertBefore,
                       f->getOptimizationMode(), shouldEmitStackProtector(f));
 

lib/SIL/IR/SILFunction.cpp

@@ -453,6 +453,9 @@ bool SILFunction::isTypeABIAccessible(SILType type) const {
 }
 
 bool SILFunction::isWeakImported() const {
+  if (isWeakImportedByModule())
+    return true;
+
   // For imported functions check the Clang declaration.
   if (ClangNodeOwner)
     return ClangNodeOwner->getClangDecl()->isWeakImported();
@@ -462,7 +465,7 @@ bool SILFunction::isWeakImported() const {
   if (!isAvailableExternally())
     return false;
 
-  if (isAlwaysWeakImported() || isWeakImportedByModule())
+  if (isAlwaysWeakImported())
     return true;
 
   if (Availability.isAlwaysAvailable())

test/IRGen/Inputs/usr/include/BridgeTestFoundation.h

@@ -53,10 +53,13 @@ __attribute__((availability(macosx,introduced=10.51)))
 @interface NSUserNotificationAction : NSObject
 @end
 
+void always_available_function();
+
 __attribute__((availability(macosx,introduced=10.51)))
 void future_function_should_be_weak();
 
 extern int weak_variable __attribute__((weak_import));
+extern int strong_variable;
 
 @interface NSError : NSObject
 

test/IRGen/weaklinked_import_clang.swift

@@ -0,0 +1,30 @@
+// RUN: %empty-directory(%t)
+// RUN: %build-irgen-test-overlays
+
+// RUN: %target-swift-frontend(mock-sdk: -target %target-cpu-apple-macosx10.50 -sdk %S/Inputs -I %t) -primary-file %s -emit-ir | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+@_weakLinked import Foundation
+
+func testObjCClass() {
+  // CHECK-DAG: @"OBJC_CLASS_$_NSNotification" = extern_weak global %objc_class
+  _ = NSNotification()
+}
+
+func testGlobalVariables() {
+  // CHECK-DAG: @weak_variable = extern_weak global
+  _ = weak_variable
+
+  // CHECK-DAG: @strong_variable = extern_weak global
+  _ = strong_variable
+}
+
+func testFunctions() {
+  // CHECK-DAG: declare extern_weak void @always_available_function()
+  always_available_function()
+}
+
+// CHECK-DAG: @"OBJC_CLASS_$_NSNumber" = extern_weak global %objc_class
+// CHECK-DAG: @"OBJC_METACLASS_$_NSNumber" = extern_weak global %objc_class
+class CustomNumber: NSNumber {}