IRGen: adjust the linkage for VWT emission on Windows

When building the standard library, we would previously mark the well
known metadata for a number of types as having external storage
(DLLImport). The well known builtin VWT are defined in the runtime
rather than the module, which would prevent us from properly annotating
the symbol. This change is an improvement but not completely sufficient
as we currently mark the VWT for `() -> ()` as having external storage.

Author: compnerd

lib/IRGen/GenDecl.cpp

@@ -5656,7 +5656,14 @@ llvm::Constant *
 IRGenModule::getAddrOfValueWitnessTable(CanType concreteType,
                                         ConstantInit definition) {
   LinkEntity entity = LinkEntity::forValueWitnessTable(concreteType);
-  return getAddrOfLLVMVariable(entity, definition, DebugTypeInfo());
+  llvm::Constant *C = getAddrOfLLVMVariable(entity, definition, DebugTypeInfo());
+  if (getSwiftModule()->isStdlibModule() && useDllStorage(Triple))
+    if (IsWellKnownBuiltinOrStructralType(concreteType))
+      ApplyIRLinkage({llvm::GlobalValue::ExternalLinkage,
+                      llvm::GlobalValue::DefaultVisibility,
+                      llvm::GlobalValue::DefaultStorageClass})
+          .to(cast<llvm::GlobalValue>(C));
+  return C;
 }
 
 static Address getAddrOfSimpleVariable(IRGenModule &IGM,

lib/IRGen/IRGenModule.cpp

@@ -1375,6 +1375,39 @@ llvm::Module *IRGenModule::getModule() const {
   return ClangCodeGen->GetModule();
 }
 
+bool IRGenModule::IsWellKnownBuiltinOrStructralType(CanType T) const {
+  static const CanType kStructural[] = {
+    Context.TheEmptyTupleType, Context.TheNativeObjectType,
+    Context.TheBridgeObjectType, Context.TheRawPointerType,
+    Context.getAnyObjectType()
+  };
+
+  if (std::any_of(std::begin(kStructural), std::end(kStructural),
+                  [T](const CanType &ST) { return T == ST; }))
+    return true;
+
+  if (auto IntTy = dyn_cast<BuiltinIntegerType>(T)) {
+    auto Width = IntTy->getWidth();
+    if (Width.isPointerWidth())
+      return true;
+    if (!Width.isFixedWidth())
+      return false;
+    switch (Width.getFixedWidth()) {
+    case 8:
+    case 16:
+    case 32:
+    case 64:
+    case 128:
+    case 256:
+      return true;
+    default:
+      break;
+    }
+  }
+
+  return false;
+}
+
 GeneratedModule IRGenModule::intoGeneratedModule() && {
   return GeneratedModule{
     std::move(LLVMContext),

lib/IRGen/IRGenModule.h

@@ -1137,6 +1137,8 @@ class IRGenModule {
 
   ClassMetadataStrategy getClassMetadataStrategy(const ClassDecl *theClass);
 
+  bool IsWellKnownBuiltinOrStructralType(CanType type) const;
+
 private:
   TypeConverter &Types;
   friend TypeConverter;

lib/IRGen/MetadataRequest.cpp

@@ -3694,41 +3694,6 @@ namespace {
       return nullptr;
     }
 
-    bool hasVisibleValueWitnessTable(CanType t) const {
-      // Some builtin and structural types have value witnesses exported from
-      // the runtime.
-      auto &C = IGF.IGM.Context;
-      if (t == C.TheEmptyTupleType
-          || t == C.TheNativeObjectType
-          || t == C.TheBridgeObjectType
-          || t == C.TheRawPointerType
-          || t == C.getAnyObjectType())
-        return true;
-      if (auto intTy = dyn_cast<BuiltinIntegerType>(t)) {
-        auto width = intTy->getWidth();
-        if (width.isPointerWidth())
-          return true;
-        if (width.isFixedWidth()) {
-          switch (width.getFixedWidth()) {
-          case 8:
-          case 16:
-          case 32:
-          case 64:
-          case 128:
-          case 256:
-            return true;
-          default:
-            return false;
-          }
-        }
-        return false;
-      }
-
-      // TODO: If a nominal type is in the same source file as we're currently
-      // emitting, we would be able to see its value witness table.
-      return false;
-    }
-
     /// Fallback default implementation.
     llvm::Value *visitType(CanType t, DynamicMetadataRequest request) {
       auto silTy = IGF.IGM.getLoweredType(t);
@@ -3737,7 +3702,10 @@ namespace {
       // If the type is in the same source file, or has a common value
       // witness table exported from the runtime, we can project from the
       // value witness table instead of emitting a new record.
-      if (hasVisibleValueWitnessTable(t))
+      //
+      // TODO: If a nominal type is in the same source file as we're currently
+      // emitting, we would be able to see its value witness table.
+      if (IGF.IGM.IsWellKnownBuiltinOrStructralType(t))
         return emitFromValueWitnessTable(t);
 
       // If the type is a singleton aggregate, the field's layout is equivalent