Protocol conformances can now reference resilient value types

Change conformance records to reference NominalTypeDescriptors instead of
metadata patterns for resilient or generic types.

For a resilient type, we don't know if the metadata is constant or not,
so we can't directly reference either constant metadata or the metadata
template.

Also, whereas previously NominalTypeDescriptors would point to the
metadata pattern, they now point to the metadata accessor function.
This allows the recently-added logic for instantiating concrete types
by name to continue working.

In turn, swift_initClassMetadata_UniversalStrategy() would reach into
the NominalTypeDescriptor to get the pattern out, so that its bump
allocator could be used to allocate ivar tables. Since the pattern is
no longer available this way, we have to pass it in as a parameter.

In the future, we will split off the read-write metadata cache entry
from the pattern; then swift_initClassMetadata_UniversalStrategy() can
just take a pointer to that, since it doesn't actually need anything
else from the pattern.

Since Clang doesn't guarantee alignment for function pointers, I had
to kill the cute trick that packed the NominalTypeKind into the low
bits of the relative pointer to the pattern; instead the kind is now
stored out of line. We could fix this by packing it with some other
field, or keep it this way in case we add new flags later.

Now that generic metadata is instantiated by calling accessor functions,
this change removes the last remaining place that metadata patterns were
referenced from outside the module they were defined in. Now, the layout
of the metadata pattern and the behavior of swift_getGenericMetadata()
is purely an implementation detail of generic metadata accessors.

This patch allows two previously-XFAIL'd tests to pass.

Author: slavapestov

include/swift/ABI/MetadataValues.h

@@ -38,7 +38,7 @@ enum class MetadataKind : uintptr_t {
 };
 
 /// Kinds of Swift nominal type descriptor records.
-enum class NominalTypeKind : uintptr_t {
+enum class NominalTypeKind : unsigned {
 #define NOMINALTYPEMETADATAKIND(name, value) name = value,
 #include "MetadataKind.def"
 };
@@ -167,10 +167,10 @@ enum class TypeMetadataRecordKind : unsigned {
   /// and classes could be emitted as UniqueDirectType.
   UniqueIndirectClass,
 
-  /// The conformance is for a generic type.
-  /// getGenericPattern() points to the generic metadata pattern used to
-  /// form instances of the type.
-  UniqueGenericPattern,
+  /// The conformance is for a generic or resilient type.
+  /// getNominalTypeDescriptor() points to the nominal type descriptor shared
+  /// by all metadata instantiations of this type.
+  UniqueNominalTypeDescriptor,
 
   /// The conformance is for a nongeneric class type.
   /// getDirectType() points to the unique class object.

include/swift/Runtime/Metadata.h

@@ -1105,11 +1105,7 @@ struct Metadata {
   /// Get the nominal type descriptor if this metadata describes a nominal type,
   /// or return null if it does not.
   const NominalTypeDescriptor *getNominalTypeDescriptor() const;
-  
-  /// Get the generic metadata pattern from which this generic type instance was
-  /// instantiated, or null if the type is not generic.
-  const GenericMetadata *getGenericPattern() const;
-  
+
   /// Get the class object for this type if it has one, or return null if the
   /// type is not a class (or not a class with a class object).
   const ClassMetadata *getClassObject() const;
@@ -1309,20 +1305,15 @@ struct NominalTypeDescriptor {
       }
     } Enum;
   };
-  
-  RelativeDirectPointerIntPair<GenericMetadata, NominalTypeKind>
-    GenericMetadataPatternAndKind;
 
-  /// A pointer to the generic metadata pattern that is used to instantiate
-  /// instances of this type. Zero if the type is not generic.
-  GenericMetadata *getGenericMetadataPattern() const {
-    return const_cast<GenericMetadata*>(
-                                    GenericMetadataPatternAndKind.getPointer());
-  }
+  using MetadataAccessor = const Metadata *();
 
-  NominalTypeKind getKind() const {
-    return GenericMetadataPatternAndKind.getInt();
-  }
+  /// A pointer to the metadata accessor function that is used to instantiate
+  /// instances of this type. Zero if the type is not resilient or generic.
+  RelativeDirectPointer<MetadataAccessor> MetadataAccessorFn;
+
+  /// The kind of type described by this nominal type descriptor.
+  NominalTypeKind Kind;
 
   /// The generic parameter descriptor header. This describes how to find and
   /// parse the generic parameter vector in metadata records for this nominal
@@ -2172,7 +2163,7 @@ struct TypeMetadataRecord {
     RelativeDirectPointer<Metadata> DirectType;
 
     /// The generic metadata pattern for an unbound generic type.
-    RelativeDirectPointer<GenericMetadata> GenericPattern;
+    RelativeDirectPointer<NominalTypeDescriptor> TypeDescriptor;
   };
 
   /// Flags describing the type metadata record.
@@ -2194,19 +2185,19 @@ struct TypeMetadataRecord {
       break;
 
     case TypeMetadataRecordKind::UniqueIndirectClass:
-    case TypeMetadataRecordKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueNominalTypeDescriptor:
       assert(false && "not direct type metadata");
     }
 
     return DirectType;
   }
- 
-  const GenericMetadata *getGenericPattern() const {
+
+  const NominalTypeDescriptor *getNominalTypeDescriptor() const {
     switch (Flags.getTypeKind()) {
     case TypeMetadataRecordKind::Universal:
       return nullptr;
 
-    case TypeMetadataRecordKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueNominalTypeDescriptor:
       break;
 
     case TypeMetadataRecordKind::UniqueDirectClass:
@@ -2216,9 +2207,9 @@ struct TypeMetadataRecord {
       assert(false && "not generic metadata pattern");
     }
 
-    return GenericPattern;
+    return TypeDescriptor;
   }
-  
+
   /// Get the canonical metadata for the type referenced by this record, or
   /// return null if the record references a generic or universal type.
   const Metadata *getCanonicalTypeMetadata() const;
@@ -2290,9 +2281,9 @@ struct ProtocolConformanceRecord {
     /// An indirect reference to the metadata.
     RelativeIndirectablePointer<const ClassMetadata *> IndirectClass;
 
-    /// The generic metadata pattern for a generic type which has instances that
-    /// conform to the protocol.
-    RelativeIndirectablePointer<GenericMetadata> GenericPattern;
+    /// The nominal type descriptor for a resilient or generic type which has
+    /// instances that conform to the protocol.
+    RelativeIndirectablePointer<NominalTypeDescriptor> TypeDescriptor;
   };
 
 
@@ -2337,7 +2328,7 @@ struct ProtocolConformanceRecord {
 
     case TypeMetadataRecordKind::UniqueDirectClass:
     case TypeMetadataRecordKind::UniqueIndirectClass:
-    case TypeMetadataRecordKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueNominalTypeDescriptor:
       assert(false && "not direct type metadata");
     }
 
@@ -2354,7 +2345,7 @@ struct ProtocolConformanceRecord {
 
     case TypeMetadataRecordKind::UniqueDirectType:
     case TypeMetadataRecordKind::NonuniqueDirectType:
-    case TypeMetadataRecordKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueNominalTypeDescriptor:
     case TypeMetadataRecordKind::UniqueIndirectClass:
       assert(false && "not direct class object");
     }
@@ -2375,19 +2366,19 @@ struct ProtocolConformanceRecord {
     case TypeMetadataRecordKind::UniqueDirectType:
     case TypeMetadataRecordKind::UniqueDirectClass:
     case TypeMetadataRecordKind::NonuniqueDirectType:
-    case TypeMetadataRecordKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueNominalTypeDescriptor:
       assert(false && "not indirect class object");
     }
 
     return IndirectClass;
   }
 
-  const GenericMetadata *getGenericPattern() const {
+  const NominalTypeDescriptor *getNominalTypeDescriptor() const {
     switch (Flags.getTypeKind()) {
     case TypeMetadataRecordKind::Universal:
       return nullptr;
 
-    case TypeMetadataRecordKind::UniqueGenericPattern:
+    case TypeMetadataRecordKind::UniqueNominalTypeDescriptor:
       break;
 
     case TypeMetadataRecordKind::UniqueDirectClass:
@@ -2397,7 +2388,7 @@ struct ProtocolConformanceRecord {
       assert(false && "not generic metadata pattern");
     }
 
-    return GenericPattern;
+    return TypeDescriptor;
   }
 
   /// Get the directly-referenced static witness table.
@@ -2645,6 +2636,7 @@ struct ClassFieldLayout {
 /// Initialize the field offset vector for a dependent-layout class, using the
 /// "Universal" layout strategy.
 extern "C" void swift_initClassMetadata_UniversalStrategy(ClassMetadata *self,
+                                      GenericMetadata *pattern,
                                       size_t numFields,
                                       const ClassFieldLayout *fieldLayouts,
                                       size_t *fieldOffsets);

lib/IRGen/GenDecl.cpp

@@ -1861,19 +1861,11 @@ getTypeEntityInfo(IRGenModule &IGM, CanType conformingType) {
   if (IGM.hasMetadataPattern(nom)) {
     // Conformances for generics, concrete subclasses of generics, and
     // resiliently-sized types are represented by referencing the
-    // metadata pattern.
-    //
-    // FIXME: this is wrong if the conforming type is a resilient type from
-    // another module. In that case, we don't know if we require runtime
-    // metadata instantiation or not, and instead, we need a way to reference
-    // the metadata accessor function from the conformance table.
-    typeKind = TypeMetadataRecordKind::UniqueGenericPattern;
-    entity = LinkEntity::forTypeMetadata(
-                         nom->getDeclaredType()->getCanonicalType(),
-                         TypeMetadataAddress::AddressPoint,
-                         /*isPattern*/ true);
-    defaultTy = IGM.TypeMetadataPatternStructTy;
-    defaultPtrTy = IGM.TypeMetadataPatternPtrTy;
+    // nominal type descriptor.
+    typeKind = TypeMetadataRecordKind::UniqueNominalTypeDescriptor;
+    entity = LinkEntity::forNominalTypeDescriptor(nom);
+    defaultTy = IGM.NominalTypeDescriptorTy;
+    defaultPtrTy = IGM.NominalTypeDescriptorPtrTy;
   } else if (auto ct = dyn_cast<ClassType>(conformingType)) {
     auto clas = ct->getDecl();
     if (clas->isForeign()) {

lib/IRGen/GenMeta.cpp

@@ -2031,7 +2031,8 @@ namespace {
     void layout() {
       asImpl().addName();
       asImpl().addKindDependentFields();
-      asImpl().addGenericMetadataPatternAndKind();
+      asImpl().addMetadataAccessorFn();
+      asImpl().addNominalTypeKind();
       asImpl().addGenericParams();
     }
 
@@ -2041,20 +2042,32 @@ namespace {
                                  ntd->getDeclaredType()->getCanonicalType(),
                                  /*willBeRelativelyAddressed*/ true));
     }
-    
-    void addGenericMetadataPatternAndKind() {
+
+    void addMetadataAccessorFn() {
       NominalTypeDecl *ntd = asImpl().getTarget();
-      auto kind = asImpl().getKind();
-      if (!IGM.hasMetadataPattern(ntd)) {
-        // There's no pattern to link.
-        addConstantInt32(kind);
+
+      // If the type has constant metadata and this is known to be the case
+      // from all resilience domains that can access it, don't link the
+      // accessor.
+      if (!IGM.isResilient(ntd, IGM.getResilienceExpansionForAccess(ntd)) &&
+          !IGM.hasMetadataPattern(ntd)) {
+        addConstantInt32(asImpl().getKind());
         return;
       }
 
-      addRelativeAddressWithTag(
-        IGM.getAddrOfTypeMetadata(ntd->getDeclaredType()->getCanonicalType(),
-                                  /*pattern*/ true),
-        kind);
+      llvm::Function *fn;
+      if (ntd->isGenericContext()) {
+        fn = getGenericTypeMetadataAccessFunction(IGM, ntd, NotForDefinition);
+      } else {
+        CanType declaredType = ntd->getDeclaredType()->getCanonicalType();
+        fn = getTypeMetadataAccessFunction(IGM, declaredType, NotForDefinition);
+      }
+
+      addRelativeAddress(fn);
+    }
+
+    void addNominalTypeKind() {
+      addConstantInt32(asImpl().getKind());
     }
 
     void addGenericParams() {
@@ -2894,7 +2907,8 @@ namespace {
       }
 
       if (HasDependentMetadata) {
-        asImpl().emitInitializeMetadata(IGF, metadataValue, vwtableValue);
+        asImpl().emitInitializeMetadata(IGF, metadataValue, metadataPattern,
+                                        vwtableValue);
       }
 
       // The metadata is now complete.
@@ -3565,6 +3579,7 @@ namespace {
 
     void emitInitializeMetadata(IRGenFunction &IGF,
                                 llvm::Value *metadata,
+                                llvm::Value *pattern,
                                 llvm::Value *vwtable) {
       assert(!HasDependentVWT && "class should never have dependent VWT");
 
@@ -3707,7 +3722,7 @@ namespace {
         // Ask the runtime to lay out the class.
         auto numFields = IGF.IGM.getSize(Size(storedProperties.size()));
         IGF.Builder.CreateCall(IGF.IGM.getInitClassMetadataUniversalFn(),
-                               {metadata, numFields,
+                               {metadata, pattern, numFields,
                                 firstField.getAddress(), fieldVector});
         IGF.Builder.CreateLifetimeEnd(fields,
                         IGF.IGM.getPointerSize() * storedProperties.size() * 2);
@@ -4613,10 +4628,11 @@ namespace {
 
     void emitInitializeMetadata(IRGenFunction &IGF,
                                 llvm::Value *metadata,
+                                llvm::Value *pattern,
                                 llvm::Value *vwtable) {
       // Nominal types are always preserved through SIL lowering.
       auto structTy = Target->getDeclaredTypeInContext()->getCanonicalType();
-      IGM.getTypeInfoForLowered(CanType(Target->getDeclaredTypeInContext()))
+      IGM.getTypeInfoForLowered(structTy)
         .initializeMetadata(IGF, metadata, vwtable,
                             SILType::getPrimitiveAddressType(structTy));
     }
@@ -4761,6 +4777,7 @@ class GenericEnumMetadataBuilder
 
   void emitInitializeMetadata(IRGenFunction &IGF,
                               llvm::Value *metadata,
+                              llvm::Value *pattern,
                               llvm::Value *vwtable) {
     // Nominal types are always preserved through SIL lowering.
     auto enumTy = Target->getDeclaredTypeInContext()->getCanonicalType();

lib/IRGen/IRGenModule.cpp

@@ -278,6 +278,11 @@ IRGenModule::IRGenModule(IRGenModuleDispatcher &dispatcher, SourceFile *SF,
   ProtocolConformanceRecordPtrTy
     = ProtocolConformanceRecordTy->getPointerTo(DefaultAS);
 
+  NominalTypeDescriptorTy
+    = llvm::StructType::create(LLVMContext, "swift.type_descriptor");
+  NominalTypeDescriptorPtrTy
+    = NominalTypeDescriptorTy->getPointerTo(DefaultAS);
+
   TypeMetadataRecordTy
     = createStructType(*this, "swift.type_metadata_record", {
       RelativeAddressTy,

lib/IRGen/IRGenModule.h

@@ -389,6 +389,8 @@ class IRGenModule {
   llvm::PointerType *ObjCBlockPtrTy;   /// %objc_block*
   llvm::StructType *ProtocolConformanceRecordTy;
   llvm::PointerType *ProtocolConformanceRecordPtrTy;
+  llvm::StructType *NominalTypeDescriptorTy;
+  llvm::PointerType *NominalTypeDescriptorPtrTy;
   llvm::StructType *TypeMetadataRecordTy;
   llvm::PointerType *TypeMetadataRecordPtrTy;
   llvm::StructType *FieldDescriptorTy;

lib/IRGen/RuntimeFunctions.def

@@ -573,13 +573,16 @@ FUNCTION(GetExistentialMetadata,
 
 // struct FieldInfo { size_t Size; size_t AlignMask; };
 // void swift_initClassMetadata_UniversalStrategy(Metadata *self,
+//                                                GenericMetadata *pattern,
 //                                                size_t numFields,
 //                                                const FieldInfo *fields,
 //                                                size_t *fieldOffsets);
 FUNCTION(InitClassMetadataUniversal,
          swift_initClassMetadata_UniversalStrategy, RuntimeCC,
          RETURNS(VoidTy),
-         ARGS(TypeMetadataPtrTy, SizeTy,
+         ARGS(TypeMetadataPtrTy,
+              TypeMetadataPatternPtrTy,
+              SizeTy,
               SizeTy->getPointerTo(),
               SizeTy->getPointerTo()),
          ATTRS(NoUnwind))

stdlib/public/runtime/Metadata.cpp

@@ -1504,6 +1504,7 @@ static void _swift_initializeSuperclass(ClassMetadata *theClass,
 /// Initialize the field offset vector for a dependent-layout class, using the
 /// "Universal" layout strategy.
 void swift::swift_initClassMetadata_UniversalStrategy(ClassMetadata *self,
+                                          GenericMetadata *pattern,
                                           size_t numFields,
                                           const ClassFieldLayout *fieldLayouts,
                                           size_t *fieldOffsets) {
@@ -1596,9 +1597,7 @@ void swift::swift_initClassMetadata_UniversalStrategy(ClassMetadata *self,
   // even if Swift doesn't, because of SwiftObject.)
   rodata->InstanceStart = size;
 
-  auto &allocator = unsafeGetInitializedCache(
-                           self->getDescription()->getGenericMetadataPattern())
-    .getAllocator();
+  auto &allocator = unsafeGetInitializedCache(pattern).getAllocator();
 
   // Always clone the ivar descriptors.
   if (numFields) {
@@ -2385,14 +2384,6 @@ Metadata::getNominalTypeDescriptor() const {
   }
 }
 
-const GenericMetadata *
-Metadata::getGenericPattern() const {
-  auto ntd = getNominalTypeDescriptor();
-  if (!ntd)
-    return nullptr;
-  return ntd->getGenericMetadataPattern();
-}
-
 const ClassMetadata *
 Metadata::getClassObject() const {
   switch (getKind()) {