IRGen: improve DLLStorage computation for Windows

This slightly regresses the standard library build (intentionally) while
generally improving the build of dispatch, foundation, xctest.

Rather than continuing to rely on the short-term hack of special casing
the standard library, identify the module where the decl originates
from.  If the module is the current module, then assume that the symbol
need not be imported (static linking does not currently work on Windows
anyways).  This allows for properly identifying the module where the
symbol will be homed.

Because we no longer special case the standard library here, a few known
metadata types will be incorrectly marked as being imported rather than
local.

Since linked entities which have `Shared` SILLinkage should be module
local, special case them to always be local.  Without this the metadata
access function is still marked incorrectly.

With this computation we now get nearly all the cases correct.  Dispatch
no longer has to rely on the linker relaxing the import to a local
binding.  XCTest is also clean.  Foundation misses the following case:
- `$sSS10FoundationE19_bridgeToObjectiveCAA8NSStringCyF`

The regressed cases in swiftCore are:
- `$sBi64_WV`
- `$sBi8_WV`
- `$sBi16_WV`
- `$sBi32_WV`
- `$sBpWV`
- `$syycWV`
- `$sBoWV`
- `$sBOWV`
- `$sBbWV`
- `$sytWV`

Author: compnerd

include/swift/IRGen/Linking.h

@@ -1155,6 +1155,8 @@ class LinkEntity {
   /// Get the default LLVM type to use for forward declarations of this
   /// entity.
   llvm::Type *getDefaultDeclarationType(IRGenModule &IGM) const;
+
+  bool isAlwaysSharedLinkage() const;
 #undef LINKENTITY_GET_FIELD
 #undef LINKENTITY_SET_FIELD
 };

lib/IRGen/GenDecl.cpp

@@ -1725,8 +1725,8 @@ void IRGenModule::emitVTableStubs() {
 
 static IRLinkage
 getIRLinkage(const UniversalLinkageInfo &info, SILLinkage linkage,
-             ForDefinition_t isDefinition,
-             bool isWeakImported) {
+             ForDefinition_t isDefinition, bool isWeakImported,
+             bool isKnownLocal = false) {
 #define RESULT(LINKAGE, VISIBILITY, DLL_STORAGE)                               \
   IRLinkage{llvm::GlobalValue::LINKAGE##Linkage,                               \
             llvm::GlobalValue::VISIBILITY##Visibility,                         \
@@ -1766,7 +1766,8 @@ getIRLinkage(const UniversalLinkageInfo &info, SILLinkage linkage,
   case SILLinkage::Private: {
     if (info.forcePublicDecls() && !isDefinition)
       return getIRLinkage(info, SILLinkage::PublicExternal, isDefinition,
-                          isWeakImported);
+                          isWeakImported, isKnownLocal);
+
     auto linkage = info.needLinkerToMergeDuplicateSymbols()
                        ? llvm::GlobalValue::LinkOnceODRLinkage
                        : llvm::GlobalValue::InternalLinkage;
@@ -1782,7 +1783,10 @@ getIRLinkage(const UniversalLinkageInfo &info, SILLinkage linkage,
 
     auto linkage = isWeakImported ? llvm::GlobalValue::ExternalWeakLinkage
                                   : llvm::GlobalValue::ExternalLinkage;
-    return {linkage, llvm::GlobalValue::DefaultVisibility, ImportedStorage};
+    return {linkage, llvm::GlobalValue::DefaultVisibility,
+            isKnownLocal
+                ? llvm::GlobalValue::DefaultStorageClass
+                : ImportedStorage};
   }
 
   case SILLinkage::HiddenExternal:
@@ -1791,8 +1795,10 @@ getIRLinkage(const UniversalLinkageInfo &info, SILLinkage linkage,
       return RESULT(AvailableExternally, Hidden, Default);
 
     return {llvm::GlobalValue::ExternalLinkage,
-            llvm::GlobalValue::DefaultVisibility, ImportedStorage};
-
+            llvm::GlobalValue::DefaultVisibility,
+            isKnownLocal
+                ? llvm::GlobalValue::DefaultStorageClass
+                : ImportedStorage};
   }
 
   llvm_unreachable("bad SIL linkage");
@@ -1807,9 +1813,15 @@ void irgen::updateLinkageForDefinition(IRGenModule &IGM,
   // entire linkage computation.
   UniversalLinkageInfo linkInfo(IGM);
   bool weakImported = entity.isWeakImported(IGM.getSwiftModule());
+
+  bool isKnownLocal = entity.isAlwaysSharedLinkage();
+  if (const auto *DC = entity.getDeclContextForEmission())
+    if (const auto *MD = DC->getParentModule())
+      isKnownLocal = IGM.getSwiftModule() == MD;
+
   auto IRL =
       getIRLinkage(linkInfo, entity.getLinkage(ForDefinition),
-                   ForDefinition, weakImported);
+                   ForDefinition, weakImported, isKnownLocal);
   ApplyIRLinkage(IRL).to(global);
 
   // Everything externally visible is considered used in Swift.
@@ -1834,21 +1846,16 @@ LinkInfo LinkInfo::get(const UniversalLinkageInfo &linkInfo,
                        const LinkEntity &entity,
                        ForDefinition_t isDefinition) {
   LinkInfo result;
-  // FIXME: For anything in the standard library, we assume is locally defined.
-  // The only two ways imported interfaces are currently created is via a shims
-  // interface where the ClangImporter will correctly give us the proper DLL
-  // storage for the declaration.  Otherwise, it is from a `@_silgen_name`
-  // attributed declaration, which we explicitly handle elsewhere.  So, in the
-  // case of a standard library build, just assume everything is locally
-  // defined.  Ideally, we would integrate the linkage calculation properly to
-  // avoid this special casing.
-  ForDefinition_t isStdlibOrDefinition =
-      ForDefinition_t(swiftModule->isStdlibModule() || isDefinition);
+
+  bool isKnownLocal = entity.isAlwaysSharedLinkage();
+  if (const auto *DC = entity.getDeclContextForEmission())
+    if (const auto *MD = DC->getParentModule())
+      isKnownLocal = MD == swiftModule;
 
   entity.mangle(result.Name);
   bool weakImported = entity.isWeakImported(swiftModule);
-  result.IRL = getIRLinkage(linkInfo, entity.getLinkage(isStdlibOrDefinition),
-                            isDefinition, weakImported);
+  result.IRL = getIRLinkage(linkInfo, entity.getLinkage(isDefinition),
+                            isDefinition, weakImported, isKnownLocal);
   result.ForDefinition = isDefinition;
   return result;
 }

lib/IRGen/Linking.cpp

@@ -1077,6 +1077,7 @@ DeclContext *LinkEntity::getDeclContextForEmission() const {
   case Kind::TypeMetadataAccessFunction:
   case Kind::TypeMetadataLazyCacheVariable:
   case Kind::TypeMetadataDemanglingCacheVariable:
+    assert(isAlwaysSharedLinkage() && "kind should always be shared linkage");
     return nullptr;
 
   // TODO
@@ -1089,3 +1090,19 @@ DeclContext *LinkEntity::getDeclContextForEmission() const {
     return nullptr;
   }
 }
+
+bool LinkEntity::isAlwaysSharedLinkage() const {
+  switch (getKind()) {
+  case Kind::ModuleDescriptor:
+  case Kind::ExtensionDescriptor:
+  case Kind::AnonymousDescriptor:
+  case Kind::ObjCClassRef:
+  case Kind::TypeMetadataAccessFunction:
+  case Kind::TypeMetadataLazyCacheVariable:
+  case Kind::TypeMetadataDemanglingCacheVariable:
+    return true;
+
+  default:
+    return false;
+  }
+}