Runtime: Add support for resilient superclasses

If the nominal type descriptor's resilient superclass flag
is set, the generic parameter offset, vtable start offset
and field offset start offset are all relative to the
start of the class's immedaite members, and not the start
of the class metadata.

Support this by loading the size of the superclass and
adding it to these offsets if the flag is set.

Author: slavapestov

include/swift/Remote/MetadataReader.h

@@ -992,6 +992,35 @@ class MetadataReader {
     swift_runtime_unreachable("Unhandled IsaEncodingKind in switch.");
   }
 
+  /// Read the offset of the generic parameters of a class from the nominal
+  /// type descriptor. If the class has a resilient superclass, we also
+  /// have to read the superclass size and add that to the offset.
+  ///
+  /// The offset is in units of words, from the start of the class's
+  /// metadata.
+  std::pair<bool, uint32_t>
+  readGenericArgsOffset(MetadataRef metadata,
+                        NominalTypeDescriptorRef descriptor) {
+    if (metadata->getKind() == MetadataKind::Class) {
+      auto *classMetadata = cast<TargetClassMetadata<Runtime>>(metadata);
+      if (classMetadata->SuperClass) {
+        auto superMetadata = readMetadata(classMetadata->SuperClass);
+        if (!superMetadata)
+          return std::make_pair(false, 0);
+
+        auto result =
+          descriptor->GenericParams.getOffset(
+            classMetadata,
+            cast<TargetClassMetadata<Runtime>>(superMetadata));
+
+        return std::make_pair(true, result);
+      }
+    }
+
+    auto result = descriptor->GenericParams.getOffset();
+    return std::make_pair(true, result);
+  }
+
   /// Read a single generic type argument from a bound generic type
   /// metadata.
   std::pair<bool, StoredPointer>
@@ -1010,11 +1039,14 @@ class MetadataReader {
       return std::make_pair(false, 0);
 
     auto numGenericParams = descriptor->GenericParams.NumPrimaryParams;
-    auto offsetToGenericArgs =
-      sizeof(StoredPointer) * (descriptor->GenericParams.Offset);
+    auto offsetToGenericArgs = readGenericArgsOffset(Meta, descriptor);
+    if (!offsetToGenericArgs.first)
+      return std::make_pair(false, 0);
+
     auto addressOfGenericArgAddress =
-      Meta.getAddress() + offsetToGenericArgs +
-      index * sizeof(StoredPointer);
+      (Meta.getAddress() +
+       offsetToGenericArgs.second * sizeof(StoredPointer) +
+       index * sizeof(StoredPointer));
 
     if (index >= numGenericParams)
       return std::make_pair(false, 0);
@@ -1357,10 +1389,13 @@ class MetadataReader {
     std::vector<BuiltType> substitutions;
 
     auto numGenericParams = descriptor->GenericParams.NumPrimaryParams;
-    auto offsetToGenericArgs =
-      sizeof(StoredPointer) * (descriptor->GenericParams.Offset);
+    auto offsetToGenericArgs = readGenericArgsOffset(metadata, descriptor);
+    if (!offsetToGenericArgs.first)
+      return {};
+
     auto addressOfGenericArgAddress =
-      metadata.getAddress() + offsetToGenericArgs;
+      (metadata.getAddress() + sizeof(StoredPointer) *
+       offsetToGenericArgs.second);
 
     using ArgIndex = decltype(descriptor->GenericParams.NumPrimaryParams);
     for (ArgIndex i = 0; i < numGenericParams;

include/swift/Runtime/Metadata.h

@@ -39,6 +39,7 @@
 #if SWIFT_OBJC_INTEROP
 #include <objc/runtime.h>
 #endif
+#include "llvm/Support/Casting.h"
 
 namespace swift {
 
@@ -1029,13 +1030,22 @@ struct GenericContextDescriptor {
 };
 
 /// Header for a generic parameter descriptor.
-struct GenericParameterDescriptorHeader {
+template<typename Runtime>
+struct TargetGenericParameterDescriptorHeader {
+  using StoredPointer = typename Runtime::StoredPointer;
+  using ClassMetadata = TargetClassMetadata<Runtime>;
+
+private:
   /// The offset to the first generic argument from the start of
-  /// metadata record.
+  /// metadata record, in words.
   ///
   /// This is meaningful if NumGenericRequirements is nonzero.
+  ///
+  /// If this class has a resilient superclass, this offset is relative to the
+  /// size of the resilient superclass metadata. Otherwise, it is absolute.
   uint32_t Offset;
 
+public:
   /// The amount of generic requirement data in the metadata record, in
   /// words, excluding the lexical parent type.  A value of zero means
   /// there is no generic requirement data.
@@ -1056,6 +1066,30 @@ struct GenericParameterDescriptorHeader {
   /// Flags for this generic parameter descriptor.
   GenericParameterDescriptorFlags Flags;
 
+  /// This is factored in a silly way because remote mirrors cannot directly
+  /// dereference the SuperClass field of class metadata.
+  uint32_t getOffset(const ClassMetadata *classMetadata,
+                     const ClassMetadata *superMetadata) const {
+    if (Flags.hasResilientSuperclass())
+      return superMetadata->getSizeInWords() + Offset;
+
+    return Offset;
+  }
+
+  uint32_t getOffset() const {
+    assert(!Flags.hasResilientSuperclass());
+    return Offset;
+  }
+
+  uint32_t getOffset(const TargetMetadata<Runtime> *metadata) const {
+    if (auto *classMetadata = llvm::dyn_cast<ClassMetadata>(metadata))
+      if (auto *superclass = classMetadata->SuperClass)
+        if (auto *superMetadata = llvm::dyn_cast<ClassMetadata>(superclass))
+          return getOffset(classMetadata, superMetadata);
+
+    return getOffset();
+  }
+
   /// True if the nominal type has generic requirements other than its
   /// parent metadata.
   bool hasGenericRequirements() const { return NumGenericRequirements > 0; }
@@ -1080,14 +1114,31 @@ struct TargetMethodDescriptor {
 /// Header for a class vtable descriptor. This is a variable-sized
 /// structure that describes how to find and parse a vtable
 /// within the type metadata for a class.
-struct VTableDescriptorHeader {
-  /// The offset of the vtable for this class in its metadata, if any.
+template <typename Runtime>
+struct TargetVTableDescriptorHeader {
+  using StoredPointer = typename Runtime::StoredPointer;
+
+private:
+  /// The offset of the vtable for this class in its metadata, if any,
+  /// in words.
+  ///
+  /// If this class has a resilient superclass, this offset is relative to the
+  /// size of the resilient superclass metadata. Otherwise, it is absolute.
   uint32_t VTableOffset;
+
+public:
   /// The number of vtable entries. This is the number of MethodDescriptor
   /// records following the vtable header in the class's nominal type
   /// descriptor, which is equal to the number of words this subclass's vtable
   /// entries occupy in instantiated class metadata.
   uint32_t VTableSize;
+
+  uint32_t getVTableOffset(const TargetClassMetadata<Runtime> *metadata) const {
+    const auto *description = metadata->getDescription();
+    if (description->GenericParams.Flags.hasResilientSuperclass())
+      return metadata->SuperClass->getSizeInWords() + VTableOffset;
+    return VTableOffset;
+  }
 };
 
 template<typename Runtime> struct TargetNominalTypeDescriptor;
@@ -1096,7 +1147,7 @@ template<typename Runtime>
 using TargetNominalTypeDescriptorTrailingObjects
   = swift::ABI::TrailingObjects<TargetNominalTypeDescriptor<Runtime>,
         GenericContextDescriptor,
-        VTableDescriptorHeader,
+        TargetVTableDescriptorHeader<Runtime>,
         TargetMethodDescriptor<Runtime>>;
 
 /// Common information about all nominal types. For generic types, this
@@ -1116,6 +1167,9 @@ struct TargetNominalTypeDescriptor final
 public:
   using StoredPointer = typename Runtime::StoredPointer;
   using MethodDescriptor = TargetMethodDescriptor<Runtime>;
+  using VTableDescriptorHeader = TargetVTableDescriptorHeader<Runtime>;
+  using GenericParameterDescriptorHeader = TargetGenericParameterDescriptorHeader<Runtime>;
+  using ClassMetadata = TargetClassMetadata<Runtime>;
 
   /// The mangled name of the nominal type.
   TargetRelativeDirectPointer<Runtime, const char> Name;
@@ -1127,19 +1181,22 @@ struct TargetNominalTypeDescriptor final
       /// The number of stored properties in the class, not including its
       /// superclasses. If there is a field offset vector, this is its length.
       uint32_t NumFields;
+
+    private:
       /// The offset of the field offset vector for this class's stored
-      /// properties in its metadata, if any. 0 means there is no field offset
+      /// properties in its metadata, in words. 0 means there is no field offset
       /// vector.
       ///
-      /// To deal with resilient superclasses correctly, this will
-      /// eventually need to be relative to the start of this class's
-      /// metadata area.
+      /// If this class has a resilient superclass, this offset is relative to
+      /// the size of the resilient superclass metadata. Otherwise, it is
+      /// absolute.
       uint32_t FieldOffsetVectorOffset;
-      
+
+    public:
       /// The field names. A doubly-null-terminated list of strings, whose
       /// length and order is consistent with that of the field offset vector.
       RelativeDirectPointer<const char, /*nullable*/ true> FieldNames;
-      
+
       /// The field type vector accessor. Returns a pointer to an array of
       /// type metadata references whose order is consistent with that of the
       /// field offset vector.
@@ -1148,7 +1205,16 @@ struct TargetNominalTypeDescriptor final
 
       /// True if metadata records for this type have a field offset vector for
       /// its stored properties.
-      bool hasFieldOffsetVector() const { return FieldOffsetVectorOffset != 0; }      
+      bool hasFieldOffsetVector() const { return FieldOffsetVectorOffset != 0; }
+
+      unsigned getFieldOffsetVectorOffset(const ClassMetadata *metadata) const {
+        const auto *description = metadata->getDescription();
+
+        if (description->GenericParams.Flags.hasResilientSuperclass())
+          return metadata->SuperClass->getSizeInWords() + FieldOffsetVectorOffset;
+
+        return FieldOffsetVectorOffset;
+      }
     } Class;
 
     /// Information about struct types.
@@ -1503,7 +1569,7 @@ struct TargetClassMetadata : public TargetHeapMetadata<Runtime> {
   /// Get a pointer to the field offset vector, if present, or null.
   const StoredPointer *getFieldOffsets() const {
     assert(isTypeMetadata());
-    auto offset = getDescription()->Class.FieldOffsetVectorOffset;
+    auto offset = getDescription()->Class.getFieldOffsetVectorOffset(this);
     if (offset == 0)
       return nullptr;
     auto asWords = reinterpret_cast<const void * const*>(this);
@@ -1520,6 +1586,13 @@ struct TargetClassMetadata : public TargetHeapMetadata<Runtime> {
     return getter(this);
   }
 
+  uint32_t getSizeInWords() const {
+    assert(isTypeMetadata());
+    uint32_t size = getClassSize() - getClassAddressPoint();
+    assert(size % sizeof(StoredPointer) == 0);
+    return size / sizeof(StoredPointer);
+  }
+
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Class;
   }
@@ -1768,7 +1841,7 @@ struct TargetValueMetadata : public TargetMetadata<Runtime> {
 
     auto asWords = reinterpret_cast<
       ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> const *>(this);
-    return (asWords + Description->GenericParams.Offset);
+    return (asWords + Description->GenericParams.getOffset(this));
   }
 
   const TargetNominalTypeDescriptor<Runtime> *getDescription() const {

stdlib/public/runtime/Demangle.cpp

@@ -166,7 +166,7 @@ _buildDemanglingForNominalType(const Metadata *type, Demangle::Demangler &Dem) {
 
   auto typeBytes = reinterpret_cast<const char *>(type);
   auto genericArgs = reinterpret_cast<const Metadata * const *>(
-               typeBytes + sizeof(void*) * description->GenericParams.Offset);
+      typeBytes + sizeof(void*) * description->GenericParams.getOffset(type));
 
   return _applyGenericArguments(genericArgs, description, node,
                                 description->GenericParams.NestingDepth,

stdlib/public/runtime/Metadata.cpp

@@ -1448,7 +1448,8 @@ static void _swift_initializeSuperclass(ClassMetadata *theClass) {
     if (genericParams.Flags.hasVTable()) {
       auto *vtable = description->getVTableDescriptor();
       for (unsigned i = 0, e = vtable->VTableSize; i < e; ++i) {
-        classWords[vtable->VTableOffset + i] = description->getMethod(i);
+        classWords[vtable->getVTableOffset(theClass) + i]
+          = description->getMethod(i);
       }
     }
   }
@@ -1470,23 +1471,23 @@ static void _swift_initializeSuperclass(ClassMetadata *theClass) {
 
     // Copy the generic requirements.
     if (genericParams.hasGenericRequirements()) {
-      unsigned numParamWords = genericParams.NumGenericRequirements;
-      memcpy(classWords + genericParams.Offset,
-             superWords + genericParams.Offset,
-             numParamWords * sizeof(uintptr_t));
+      memcpy(classWords + genericParams.getOffset(ancestor),
+             superWords + genericParams.getOffset(ancestor),
+             genericParams.NumGenericRequirements * sizeof(uintptr_t));
     }
 
     // Copy the vtable entries.
     if (genericParams.Flags.hasVTable()) {
       auto *vtable = description->getVTableDescriptor();
-      memcpy(classWords + vtable->VTableOffset,
-             superWords + vtable->VTableOffset,
+      memcpy(classWords + vtable->getVTableOffset(ancestor),
+             superWords + vtable->getVTableOffset(ancestor),
              vtable->VTableSize * sizeof(uintptr_t));
     }
 
     // Copy the field offsets.
     if (description->Class.hasFieldOffsetVector()) {
-      unsigned fieldOffsetVector = description->Class.FieldOffsetVectorOffset;
+      unsigned fieldOffsetVector =
+        description->Class.getFieldOffsetVectorOffset(ancestor);
       memcpy(classWords + fieldOffsetVector,
              superWords + fieldOffsetVector,
              description->Class.NumFields * sizeof(uintptr_t));