Merge pull request #26584 from jckarter/prefab-value-witness-in-generic-pattern

IRGen: Use known value witnesses in generic metadata patterns.

Author: jckarter

lib/IRGen/GenMeta.cpp

@@ -2358,7 +2358,8 @@ template <class Impl, class DeclType>
     }
 
     void addValueWitnessTable() {
-      auto table = asImpl().emitValueWitnessTable();
+      ConstantReference table =
+                              asImpl().emitValueWitnessTable(/*relative*/ true);
       B.addRelativeAddress(table);
     }
 
@@ -3455,13 +3456,13 @@ namespace {
       B.add(emitNominalTypeDescriptor());
     }
 
-    llvm::Constant *emitValueWitnessTable() {
+    ConstantReference emitValueWitnessTable(bool relativeReference) {
       auto type = this->Target->getDeclaredType()->getCanonicalType();
-      return irgen::emitValueWitnessTable(IGM, type, false);
+      return irgen::emitValueWitnessTable(IGM, type, false, relativeReference);
     }
 
     void addValueWitnessTable() {
-      B.add(emitValueWitnessTable());
+      B.add(emitValueWitnessTable(false).getValue());
     }
 
     void addFieldOffset(VarDecl *var) {
@@ -3517,18 +3518,18 @@ namespace {
     }
   };
 
-  /// Emit a value witness table for a fixed-layout generic type, or a null
-  /// placeholder if the value witness table is dependent on generic parameters.
-  /// Returns nullptr if the value witness table is dependent.
-  static llvm::Constant *
+  /// Emit a value witness table for a fixed-layout generic type, or a template
+  /// if the value witness table is dependent on generic parameters.
+  static ConstantReference
   getValueWitnessTableForGenericValueType(IRGenModule &IGM,
                                           NominalTypeDecl *decl,
                                           bool &dependent) {
     CanType unboundType
       = decl->getDeclaredType()->getCanonicalType();
 
     dependent = hasDependentValueWitnessTable(IGM, unboundType);
-    return emitValueWitnessTable(IGM, unboundType, dependent);
+    return emitValueWitnessTable(IGM, unboundType, dependent,
+                                 /*relative reference*/ true);
   }
 
   /// A builder for metadata templates.
@@ -3564,7 +3565,8 @@ namespace {
       return StructContextDescriptorBuilder(IGM, Target, RequireMetadata).emit();
     }
 
-    llvm::Constant *emitValueWitnessTable() {
+    ConstantReference emitValueWitnessTable(bool relativeReference) {
+      assert(relativeReference && "should only relative reference");
       return getValueWitnessTableForGenericValueType(IGM, Target,
                                                      HasDependentVWT);
     }
@@ -3697,13 +3699,13 @@ namespace {
       B.addInt(IGM.MetadataKindTy, unsigned(getMetadataKind(Target)));
     }
 
-    llvm::Constant *emitValueWitnessTable() {
+    ConstantReference emitValueWitnessTable(bool relativeReference) {
       auto type = Target->getDeclaredType()->getCanonicalType();
-      return irgen::emitValueWitnessTable(IGM, type, false);
+      return irgen::emitValueWitnessTable(IGM, type, false, relativeReference);
     }
 
     void addValueWitnessTable() {
-      B.add(emitValueWitnessTable());
+      B.add(emitValueWitnessTable(/*relative*/ false).getValue());
     }
 
     llvm::Constant *emitNominalTypeDescriptor() {
@@ -3798,7 +3800,8 @@ namespace {
       return EnumContextDescriptorBuilder(IGM, Target, RequireMetadata).emit();
     }
 
-    llvm::Constant *emitValueWitnessTable() {
+    ConstantReference emitValueWitnessTable(bool relativeReference) {
+      assert(relativeReference && "should only relative reference");
       return getValueWitnessTableForGenericValueType(IGM, Target,
                                                      HasDependentVWT);
     }
@@ -4054,7 +4057,7 @@ namespace {
     }
 
     void addValueWitnessTable() {
-      B.add(emitValueWitnessTable());
+      B.add(emitValueWitnessTable(/*relative*/ false).getValue());
     }
 
     void flagUnfilledFieldOffset() {
@@ -4081,7 +4084,7 @@ namespace {
     }
 
     void addValueWitnessTable() {
-      B.add(emitValueWitnessTable());
+      B.add(emitValueWitnessTable(/*relative*/ false).getValue());
     }
 
     void addPayloadSize() const {

lib/IRGen/GenValueWitness.cpp

@@ -927,25 +927,21 @@ static constexpr uint64_t sizeAndAlignment(Size size, Alignment alignment) {
 /// Return a reference to a known value witness table from the runtime
 /// that's suitable for the given type, if there is one, or return null
 /// if we should emit a new one.
-static llvm::Constant *
-getAddrOfKnownValueWitnessTable(IRGenModule &IGM, CanType type) {
+static ConstantReference
+getAddrOfKnownValueWitnessTable(IRGenModule &IGM, CanType type,
+                                bool relativeReference) {
   // Native PE binaries shouldn't reference data symbols across DLLs, so disable
-  // this on Windows.
-  if (IGM.useDllStorage())
-    return nullptr;
+  // this on Windows, unless we're forming a relative indirectable reference.
+  if (IGM.useDllStorage() && !relativeReference)
+    return {};
 
   if (auto nom = type->getAnyNominal()) {
-    // TODO: Generic metadata patterns relative-reference their VWT, which won't
-    // work if the VWT is in a different module without supporting indirection
-    // through the GOT.
-    if (nom->isGenericContext())
-      return nullptr;
     // TODO: Non-C enums have extra inhabitants and also need additional value
     // witnesses for their tag manipulation (except when they're empty, in
     // which case values never exist to witness).
     if (auto enumDecl = dyn_cast<EnumDecl>(nom))
       if (!enumDecl->isObjC() && !type->isUninhabited())
-        return nullptr;
+        return {};
   }
 
   auto &C = IGM.Context;
@@ -954,20 +950,19 @@ getAddrOfKnownValueWitnessTable(IRGenModule &IGM, CanType type) {
 
   auto &ti = IGM.getTypeInfoForUnlowered(AbstractionPattern::getOpaque(), type);
 
-  // Empty types can use empty tuple witnesses.
-  if (ti.isKnownEmpty(ResilienceExpansion::Maximal))
-    return IGM.getAddrOfValueWitnessTable(TupleType::getEmpty(C));
-
   // We only have witnesses for fixed type info.
   auto *fixedTI = dyn_cast<FixedTypeInfo>(&ti);
   if (!fixedTI)
-    return nullptr;
-  
+    return {};
+
   CanType witnessSurrogate;
+  ReferenceCounting refCounting;
 
+  // Empty types can use empty tuple witnesses.
+  if (ti.isKnownEmpty(ResilienceExpansion::Maximal)) {
+    witnessSurrogate = TupleType::getEmpty(C);
   // Handle common POD type layouts.
-  ReferenceCounting refCounting;
-  if (fixedTI->isPOD(ResilienceExpansion::Maximal)
+  } else if (fixedTI->isPOD(ResilienceExpansion::Maximal)
       && fixedTI->getFixedExtraInhabitantCount(IGM) == 0) {
     // Reuse one of the integer witnesses if applicable.
     switch (sizeAndAlignment(fixedTI->getFixedSize(),
@@ -1015,26 +1010,32 @@ getAddrOfKnownValueWitnessTable(IRGenModule &IGM, CanType type) {
       break;
     }
   }
-  
-  if (witnessSurrogate)
-    return IGM.getAddrOfValueWitnessTable(witnessSurrogate);
-  return nullptr;
+
+  if (witnessSurrogate) {
+    if (relativeReference) {
+      return IGM.getAddrOfLLVMVariableOrGOTEquivalent(
+                            LinkEntity::forValueWitnessTable(witnessSurrogate));
+    } else {
+      return {IGM.getAddrOfValueWitnessTable(witnessSurrogate),
+              ConstantReference::Direct};
+    }
+  }
+  return {};
 }
 
-/// Emit a value-witness table for the given type, which is assumed to
-/// be non-dependent.
-llvm::Constant *irgen::emitValueWitnessTable(IRGenModule &IGM,
+/// Emit a value-witness table for the given type.
+ConstantReference irgen::emitValueWitnessTable(IRGenModule &IGM,
                                              CanType abstractType,
-                                             bool isPattern) {
+                                             bool isPattern,
+                                             bool relativeReference) {
   // We shouldn't emit global value witness tables for generic type instances.
   assert(!isa<BoundGenericType>(abstractType) &&
          "emitting VWT for generic instance");
 
   // See if we can use a prefab witness table from the runtime.
-  // Note that we can't do this on Windows since the PE loader does not support
-  // cross-DLL pointers in data.
   if (!isPattern) {
-    if (auto known = getAddrOfKnownValueWitnessTable(IGM, abstractType)) {
+    if (auto known = getAddrOfKnownValueWitnessTable(IGM, abstractType,
+                                                     relativeReference)) {
       return known;
     }
   }
@@ -1061,7 +1062,8 @@ llvm::Constant *irgen::emitValueWitnessTable(IRGenModule &IGM,
   auto global = cast<llvm::GlobalVariable>(addr);
   global->setConstant(canBeConstant);
 
-  return llvm::ConstantExpr::getBitCast(global, IGM.WitnessTablePtrTy);
+  return {llvm::ConstantExpr::getBitCast(global, IGM.WitnessTablePtrTy),
+          ConstantReference::Direct};
 }
 
 llvm::Constant *IRGenModule::emitFixedTypeLayout(CanType t,

lib/IRGen/GenValueWitness.h

@@ -31,6 +31,7 @@ namespace swift {
 namespace irgen {
   class ConstantStructBuilder;
   class IRGenModule;
+  class ConstantReference;
 
   /// True if a type has a generic-parameter-dependent value witness table.
   /// Currently, this is true if the size and/or alignment of the type is
@@ -42,8 +43,9 @@ namespace irgen {
   /// \param isPattern - true if the table just serves as an instantiation
   ///   pattern and does not need to be modifiable in-place (if the type
   ///   does not have static layout for some reason)
-  llvm::Constant *emitValueWitnessTable(IRGenModule &IGM, CanType type,
-                                        bool isPattern);
+  ConstantReference emitValueWitnessTable(IRGenModule &IGM, CanType type,
+                                          bool isPattern,
+                                          bool relativeReference);
 }
 }
 

test/IRGen/generic_metadata_fixed_known_vwtable.swift

@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend -emit-ir %s | %FileCheck %s
+
+// CHECK-LABEL: @"$s36generic_metadata_fixed_known_vwtable6StroctVMP" =
+// CHECK-SAME:    $sytWV
+struct Stroct<T> {}
+
+// CHECK-LABEL: @"$s36generic_metadata_fixed_known_vwtable4EnomOMP" =
+// CHECK-SAME:    $sytWV
+enum Enom<T> {}