Reflection: Use correct starting offset and alignment in class instance layout

Also, add caching for class instance layout.

Author: slavapestov

include/swift/Reflection/ReflectionContext.h

@@ -40,13 +40,13 @@ class ReflectionContext
        : public remote::MetadataReader<Runtime, TypeRefBuilder> {
   using super = remote::MetadataReader<Runtime, TypeRefBuilder>;
 
+  std::unordered_map<typename super::StoredPointer, const TypeInfo *> Cache;
+
 public:
   using super::getBuilder;
   using super::readTypeFromMetadata;
   using typename super::StoredPointer;
 
-public:
-
   explicit ReflectionContext(std::shared_ptr<MemoryReader> reader)
     : super(std::move(reader)) {}
 
@@ -72,28 +72,44 @@ class ReflectionContext
   /// Return a description of the layout of a heap object having the given
   /// metadata as its isa pointer.
   const TypeInfo *getInstanceTypeInfo(StoredPointer MetadataAddress) {
-    // FIXME: Add caching
+    // See if we cached the layout already
+    auto found = Cache.find(MetadataAddress);
+    if (found != Cache.end())
+      return found->second;
+
     auto &TC = getBuilder().getTypeConverter();
 
-    auto TR = readTypeFromMetadata(MetadataAddress);
-    if (TR == nullptr)
-      return nullptr;
+    const TypeInfo *TI = nullptr;
 
+    auto TR = readTypeFromMetadata(MetadataAddress);
     auto kind = this->readKindFromMetadata(MetadataAddress);
-    if (!kind.first)
-      return nullptr;
-
-    switch (kind.second) {
-    case MetadataKind::Class: {
-      auto start = this->readInstanceStartFromClassMetadata(MetadataAddress);
-      if (!start.first)
-        return nullptr;
-      auto *TI = TC.getInstanceTypeInfo(TR, start.second);
-      return TI;
-    }
-    default:
-      return nullptr;
+    if (TR != nullptr && kind.first) {
+      switch (kind.second) {
+      case MetadataKind::Class: {
+        // Figure out where the stored properties of this class begin
+        // by looking at the size of the superclass
+        bool valid;
+        unsigned size, align;
+        auto super =
+            this->readSuperClassFromClassMetadata(MetadataAddress);
+        if (super) {
+          std::tie(valid, size, align) =
+              this->readInstanceSizeAndAlignmentFromClassMetadata(super);
+
+          // Perform layout
+          if (valid)
+            TI = TC.getInstanceTypeInfo(TR, size, align);
+        }
+        break;
+      }
+      default:
+        break;
+      }
     }
+
+    // Cache the result for future lookups
+    Cache[MetadataAddress] = TI;
+    return TI;
   }
 
   /// Return a description of the layout of a value with the given type.

include/swift/Reflection/TypeLowering.h

@@ -180,7 +180,8 @@ class TypeConverter {
   ///
   /// Not cached.
   const TypeInfo *getInstanceTypeInfo(const TypeRef *TR,
-                                      unsigned InstanceStart);
+                                      unsigned start,
+                                      unsigned align);
 
   /* Not really public */
   const ReferenceTypeInfo *

include/swift/Remote/MetadataReader.h

@@ -482,27 +482,48 @@ class MetadataReader {
     return {true, meta->getKind()};
   }
 
-  /// Given a remote pointer to class metadata, attempt to discover its class
-  /// instance start offset.
-  std::pair<bool, unsigned>
-  readInstanceStartFromClassMetadata(StoredPointer MetadataAddress) {
+  /// Given a remote pointer to class metadata, attempt to read its superclass.
+  StoredPointer
+  readSuperClassFromClassMetadata(StoredPointer MetadataAddress) {
     auto meta = readMetadata(MetadataAddress);
-    if (!meta)
-      return {false, 0};
+    if (!meta || meta->getKind() != MetadataKind::Class)
+      return StoredPointer();
 
-    auto address = readAddressOfNominalTypeDescriptor(meta);
-    if (!address)
-      return {false, 0};
+    auto classMeta = cast<TargetClassMetadata<Runtime>>(meta);
+    return classMeta->SuperClass;
+  }
 
-    auto descriptor = readNominalTypeDescriptor(address);
-    if (!descriptor)
-      return {false, 0};
+  /// Given a remote pointer to class metadata, attempt to discover its class
+  /// instance size and alignment.
+  std::tuple<bool, unsigned, unsigned>
+  readInstanceSizeAndAlignmentFromClassMetadata(StoredPointer MetadataAddress) {
+    auto superMeta = readMetadata(MetadataAddress);
+    if (!superMeta || superMeta->getKind() != MetadataKind::Class)
+      return {false, 0, 0};
+    auto super = cast<TargetClassMetadata<Runtime>>(superMeta);
+
+    // See swift_initClassMetadata_UniversalStrategy()
+    uint32_t size, align;
+    if (super->isTypeMetadata()) {
+      size = super->getInstanceSize();
+      align = super->getInstanceAlignMask() + 1;
+    } else {
+      // The following algorithm only works on the non-fragile Apple runtime.
+
+      // Grab the RO-data pointer.  This part is not ABI.
+      StoredPointer roDataPtr = readObjCRODataPtr(MetadataAddress);
+      if (!roDataPtr)
+        return false;
 
-    if (descriptor->Class.NumFields == 0)
-      return {true, sizeof(StoredPointer)};
+      auto address = roDataPtr + sizeof(uint32_t) * 2;
+
+      align = 16; // malloc alignment guarantee
+
+      if (!Reader->readInteger(RemoteAddress(address), &size))
+        return {false, 0, 0};
+    }
 
-    // return {true, meta->getFieldOffsets()[0]};
-    return {true, sizeof(StoredPointer)};
+    return {true, size, align};
   }
 
   /// Given a remote pointer to metadata, attempt to turn it into a type.

include/swift/Runtime/Metadata.h

@@ -1659,7 +1659,7 @@ struct TargetClassMetadata : public TargetHeapMetadata<Runtime> {
     Flags = flags;
   }
 
-  StoredPointer getInstanceSize() const {
+  StoredSize getInstanceSize() const {
     assert(isTypeMetadata());
     return InstanceSize;
   }

stdlib/public/Reflection/TypeLowering.cpp

@@ -871,7 +871,8 @@ const TypeInfo *TypeConverter::getTypeInfo(const TypeRef *TR) {
 }
 
 const TypeInfo *TypeConverter::getInstanceTypeInfo(const TypeRef *TR,
-                                                   unsigned InstanceStart) {
+                                                   unsigned start,
+                                                   unsigned align) {
   const FieldDescriptor *FD = getBuilder().getFieldTypeInfo(TR);
   if (FD == nullptr)
     return nullptr;
@@ -881,12 +882,9 @@ const TypeInfo *TypeConverter::getInstanceTypeInfo(const TypeRef *TR,
     // Lower the class's fields using substitutions from the
     // TypeRef to make field types concrete.
     RecordTypeInfoBuilder builder(*this, RecordKind::ClassInstance);
-    auto *ReferenceTI = getTypeInfo(getNativeObjectTypeRef());
-    if (ReferenceTI == nullptr)
-      return nullptr;
 
     // Start layout from the given instance start offset.
-    builder.addField(InstanceStart, ReferenceTI->getAlignment());
+    builder.addField(start, align);
 
     for (auto Field : getBuilder().getFieldTypeRefs(TR, FD))
       builder.addField(Field.first, Field.second);