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

@@ -2491,6 +2491,16 @@ Address IRGenModule::getAddrOfSILGlobalVariable(SILGlobalVariable *var,
     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) {
@@ -3242,8 +3252,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);

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 {}