Implement ReflectionContext::readInstanceStartFromTypeRef

Implement ReflectionContext::readInstanceStartFromTypeRef as an
alternative way to finding out the start of an instance's field 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,6 +1202,34 @@ class ReflectionContext
     }
   }
 
+  /// Given a typeref, attempt to discover its class instance size. For a
+  /// version of this function that performs the same job but starting out with
+  /// an instance pointer check
+  /// MetadataReader::readInstanceStartFromClassMetadata.
+  llvm::Optional<unsigned> readInstanceStartFromTypeRef(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 = readInstanceStartFromTypeRef(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 field is right after the super class's start
+    // + fields.
+    size_t start = *superclassStart + superTI->getSize();
+    return start;
+  }
+
   const RecordTypeInfo *getRecordTypeInfo(const TypeRef *TR,
                               remote::TypeInfoProvider *ExternalTypeInfo) {
     auto *TypeInfo = getTypeInfo(TR, ExternalTypeInfo);