Merge pull request #60625 from tshortli/weak-linked-import-inlinable

IRGen/SIL: Fix IR linkage computation for inlined function references from modules imported `@_weakLinked`

Author: tshortli

include/swift/AST/Module.h

@@ -685,9 +685,8 @@ class ModuleDecl
   // Is \p spiGroup accessible as an explicitly imported SPI from this module?
   bool isImportedAsSPI(Identifier spiGroup, const ModuleDecl *fromModule) const;
 
-  /// Is \p targetDecl from a module that is imported as \c @_weakLinked from
-  /// this module?
-  bool isImportedAsWeakLinked(const Decl *targetDecl) const;
+  /// Is \p module imported as \c @_weakLinked from this module?
+  bool isImportedAsWeakLinked(const ModuleDecl *module) const;
 
   /// \sa getImportedModules
   enum class ImportFilterKind {

include/swift/SIL/SILFunction.h

@@ -19,6 +19,7 @@
 
 #include "swift/AST/ASTNode.h"
 #include "swift/AST/Availability.h"
+#include "swift/AST/Module.h"
 #include "swift/AST/ResilienceExpansion.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/Basic/SwiftObjectHeader.h"
@@ -64,11 +65,6 @@ enum IsDistributed_t {
   IsNotDistributed,
   IsDistributed,
 };
-enum IsWeakImported_t {
-  IsNotWeakImported,
-  IsWeakImportedByModule,
-  IsAlwaysWeakImported,
-};
 
 enum class PerformanceConstraints : uint8_t {
   None = 0,
@@ -222,6 +218,10 @@ class SILFunction
   /// The AST decl context of the function.
   DeclContext *DeclCtxt = nullptr;
 
+  /// The module that defines this function. This member should only be set as
+  /// a fallback when a \c DeclCtxt is unavailable.
+  ModuleDecl *ParentModule = nullptr;
+
   /// The profiler for instrumentation based profiling, or null if profiling is
   /// disabled.
   SILProfiler *Profiler = nullptr;
@@ -322,8 +322,9 @@ class SILFunction
   /// would indicate.
   unsigned HasCReferences : 1;
 
-  /// Whether cross-module references to this function should use weak linking.
-  unsigned IsWeakImported : 2;
+  /// Whether cross-module references to this function should always use weak
+  /// linking.
+  unsigned IsAlwaysWeakImported : 1;
 
   /// Whether the implementation can be dynamically replaced.
   unsigned IsDynamicReplaceable : 1;
@@ -801,19 +802,11 @@ class SILFunction
 
   /// Returns whether this function's symbol must always be weakly referenced
   /// across module boundaries.
-  bool isAlwaysWeakImported() const {
-    return IsWeakImported == IsWeakImported_t::IsAlwaysWeakImported;
-  }
-
-  /// Returns whether this function's symbol was referenced by a module that
-  /// imports the defining module \c @_weakLinked.
-  bool isWeakImportedByModule() const {
-    return IsWeakImported == IsWeakImported_t::IsWeakImportedByModule;
-  }
+  bool isAlwaysWeakImported() const { return IsAlwaysWeakImported; }
 
-  void setIsWeakImported(IsWeakImported_t value) { IsWeakImported = value; }
+  void setIsAlwaysWeakImported(bool value) { IsAlwaysWeakImported = value; }
 
-  bool isWeakImported() const;
+  bool isWeakImported(ModuleDecl *module) const;
 
   /// Returns whether this function implementation can be dynamically replaced.
   IsDynamicallyReplaceable_t isDynamicallyReplaceable() const {
@@ -960,6 +953,18 @@ class SILFunction
     DeclCtxt = (DS ? DebugScope->Loc.getAsDeclContext() : nullptr);
   }
 
+  /// Returns the module that defines this function.
+  ModuleDecl *getParentModule() const {
+    return DeclCtxt ? DeclCtxt->getParentModule() : ParentModule;
+  }
+
+  /// Sets \c ParentModule as fallback if \c DeclCtxt is not available to
+  /// provide the parent module.
+  void setParentModule(ModuleDecl *module) {
+    assert(!DeclCtxt && "already have a DeclCtxt");
+    ParentModule = module;
+  }
+
   /// Initialize the debug scope for debug info on SIL level
   /// (-sil-based-debuginfo).
   void setSILDebugScope(const SILDebugScope *DS) {

lib/AST/Decl.cpp

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

lib/AST/Module.cpp

@@ -2663,10 +2663,9 @@ bool ModuleDecl::isImportedAsSPI(Identifier spiGroup,
   return importedSPIGroups.count(spiGroup);
 }
 
-bool ModuleDecl::isImportedAsWeakLinked(const Decl *targetDecl) const {
-  const auto *declaringModule = targetDecl->getModuleContext();
+bool ModuleDecl::isImportedAsWeakLinked(const ModuleDecl *module) const {
   for (auto file : getFiles()) {
-    if (file->importsModuleAsWeakLinked(declaringModule))
+    if (file->importsModuleAsWeakLinked(module))
       return true;
   }
   return false;

lib/IRGen/GenDecl.cpp

@@ -2520,7 +2520,8 @@ Address IRGenModule::getAddrOfSILGlobalVariable(SILGlobalVariable *var,
     // 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()))
+      auto varModule = var->getDecl()->getModuleContext();
+      if (getSwiftModule()->isImportedAsWeakLinked(varModule))
         globalVar->setLinkage(link.getLinkage());
     }
 
@@ -3275,13 +3276,16 @@ llvm::Function *IRGenModule::getAddrOfSILFunction(
     fn = dyn_cast<llvm::Function>(clangAddr->stripPointerCasts());
 
     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 (!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 *parentModule = f->getParentModule())
+          if (getSwiftModule()->isImportedAsWeakLinked(parentModule))
+            fn->setLinkage(link.getLinkage());
+      }
 
       // If we have a function, move it to the appropriate position.
       if (hasOrderNumber) {

lib/IRGen/Linking.cpp

@@ -1177,7 +1177,7 @@ bool LinkEntity::isWeakImported(ModuleDecl *module) const {
   case Kind::DynamicallyReplaceableFunctionVariable:
   case Kind::SILFunction:
   case Kind::DistributedAccessor: {
-    return getSILFunction()->isWeakImported();
+    return getSILFunction()->isWeakImported(module);
   }
 
   case Kind::AssociatedConformanceDescriptor:

lib/SIL/IR/Linker.cpp

@@ -16,10 +16,7 @@
 /// deserializing functions, vtables and witness tables.
 ///
 /// The behavior of the linker is controlled by a LinkMode value. The LinkMode
-/// has three possible values:
-///
-/// - LinkNone: The linker does not deserialize anything. This is only used for
-///   debugging and testing purposes, and never during normal operation.
+/// has two possible values:
 ///
 /// - LinkNormal: The linker deserializes bodies for declarations that must be
 ///   emitted into the client because they do not have definitions available

lib/SIL/IR/SILFunction.cpp

@@ -182,7 +182,7 @@ void SILFunction::init(
   this->InlineStrategy = inlineStrategy;
   this->Linkage = unsigned(Linkage);
   this->HasCReferences = false;
-  this->IsWeakImported = false;
+  this->IsAlwaysWeakImported = false;
   this->IsDynamicReplaceable = isDynamic;
   this->ExactSelfClass = isExactSelfClass;
   this->IsDistributed = isDistributed;
@@ -260,7 +260,7 @@ void SILFunction::createSnapshot(int id) {
   newSnapshot->perfConstraints = perfConstraints;
   newSnapshot->GlobalInitFlag = GlobalInitFlag;
   newSnapshot->HasCReferences = HasCReferences;
-  newSnapshot->IsWeakImported = IsWeakImported;
+  newSnapshot->IsAlwaysWeakImported = IsAlwaysWeakImported;
   newSnapshot->HasOwnership = HasOwnership;
   newSnapshot->IsWithoutActuallyEscapingThunk = IsWithoutActuallyEscapingThunk;
   newSnapshot->OptMode = OptMode;
@@ -452,9 +452,10 @@ bool SILFunction::isTypeABIAccessible(SILType type) const {
   return getModule().isTypeABIAccessible(type, TypeExpansionContext(*this));
 }
 
-bool SILFunction::isWeakImported() const {
-  if (isWeakImportedByModule())
-    return true;
+bool SILFunction::isWeakImported(ModuleDecl *module) const {
+  if (auto *parent = getParentModule())
+    if (module->isImportedAsWeakLinked(parent))
+      return true;
 
   // For imported functions check the Clang declaration.
   if (ClangNodeOwner)

lib/SIL/IR/SILFunctionBuilder.cpp

@@ -312,14 +312,7 @@ SILFunction *SILFunctionBuilder::getOrCreateFunction(
       F->setClangNodeOwner(decl);
 
     F->setAvailabilityForLinkage(decl->getAvailabilityForLinkage());
-
-    if (decl->isAlwaysWeakImported()) {
-      F->setIsWeakImported(IsWeakImported_t::IsAlwaysWeakImported);
-    } else if (decl->isWeakImported(mod.getSwiftModule())) {
-      F->setIsWeakImported(IsWeakImported_t::IsWeakImportedByModule);
-    } else {
-      F->setIsWeakImported(IsWeakImported_t::IsNotWeakImported);
-    }
+    F->setIsAlwaysWeakImported(decl->isAlwaysWeakImported());
 
     if (auto *accessor = dyn_cast<AccessorDecl>(decl)) {
       auto *storage = accessor->getStorage();

lib/SIL/Parser/ParseSIL.cpp

@@ -6514,9 +6514,7 @@ bool SILParserState::parseDeclSIL(Parser &P) {
     if (!objCReplacementFor.empty())
       FunctionState.F->setObjCReplacement(objCReplacementFor);
     FunctionState.F->setSpecialPurpose(specialPurpose);
-    FunctionState.F->setIsWeakImported(
-        isWeakImported ? IsWeakImported_t::IsAlwaysWeakImported
-                       : IsWeakImported_t::IsNotWeakImported);
+    FunctionState.F->setIsAlwaysWeakImported(isWeakImported);
     FunctionState.F->setAvailabilityForLinkage(availability);
     FunctionState.F->setWithoutActuallyEscapingThunk(
       isWithoutActuallyEscapingThunk);