Implement readSizeOfFieldsNotBelongingToInstanceFromTypeRef

Implement readSizeOfFieldsNotBelongingToInstanceFromTypeRef
as an alternative way to finding out the end of the fields that belong
to the instance when reading the field's start from binary is not
possible (for example, embedded Swift doesn't emit any reflection
metadata on the binary).

Author: augusto2112

include/swift/Remote/MetadataReader.h

@@ -617,7 +617,7 @@ class MetadataReader {
 
   /// Given a remote pointer to class metadata, attempt to discover its class
   /// instance size and whether fields should use the resilient layout strategy.
-  llvm::Optional<unsigned> readInstanceStartAndAlignmentFromClassMetadata(
+  llvm::Optional<unsigned> readInstanceStartFromClassMetadata(
       StoredPointer MetadataAddress) {
     auto meta = readMetadata(MetadataAddress);
     if (!meta || meta->getKind() != MetadataKind::Class)

include/swift/RemoteInspection/ReflectionContext.h

@@ -908,7 +908,7 @@ class ReflectionContext
         // Figure out where the stored properties of this class begin
         // by looking at the size of the superclass
         auto start =
-            this->readInstanceStartAndAlignmentFromClassMetadata(MetadataAddress);
+            this->readInstanceStartFromClassMetadata(MetadataAddress);
 
         // Perform layout
         if (start)
@@ -1202,8 +1202,42 @@ class ReflectionContext
     }
   }
 
-  const RecordTypeInfo *getRecordTypeInfo(const TypeRef *TR,
-                              remote::TypeInfoProvider *ExternalTypeInfo) {
+  /// Given a typeref, attempt to calculate where the fields that don't belong
+  /// to this instance ends. For example, for a superclass, the size of it's non
+  /// instance fields would be one word for the isa pointer plus one word for
+  /// the refcount field. For a subclass the size would be the superclass's size
+  /// (including fields). Note that this is not the same as the start of the
+  /// subclass's fields, as this value does not account for padding. Check
+  /// MetadataReader::readInstanceStartFromClassMetadata for similar
+  /// functionality.
+  llvm::Optional<unsigned>
+  readSizeOfFieldsNotBelongingToInstanceFromTypeRef(const TypeRef *TR) {
+    size_t isaAndRetainCountSize = sizeof(StoredSize) + sizeof(long long);
+
+    const TypeRef *superclass = getBuilder().lookupSuperclass(TR);
+    if (!superclass)
+      // If there is no superclass the stat of the instance's field is right
+      // after the isa and retain fields.
+      return isaAndRetainCountSize;
+
+    auto superclassStart =
+        readSizeOfFieldsNotBelongingToInstanceFromTypeRef(superclass);
+    if (!superclassStart)
+      return llvm::None;
+
+    auto *superTI = getBuilder().getTypeConverter().getClassInstanceTypeInfo(
+        superclass, *superclassStart, nullptr);
+    if (!superTI)
+      return llvm::None;
+
+    // The start of the subclass's fields is right after the super class's ones.
+    size_t start = superTI->getSize();
+    return start;
+  }
+
+  const RecordTypeInfo *
+  getRecordTypeInfo(const TypeRef *TR,
+                    remote::TypeInfoProvider *ExternalTypeInfo) {
     auto *TypeInfo = getTypeInfo(TR, ExternalTypeInfo);
     return dyn_cast_or_null<const RecordTypeInfo>(TypeInfo);
   }