Merge pull request #18172 from dcci/reflexist

[Reflection] Hoist computation of metadata/value for opaque existential to the reader

Author: dcci

include/swift/Reflection/ReflectionContext.h

@@ -80,6 +80,7 @@ class ReflectionContext
   using super::readIsaMask;
   using super::readTypeFromMetadata;
   using super::readGenericArgFromMetadata;
+  using super::readMetadataAndValueOpaqueExistential;
   using super::readMetadataFromInstance;
   using typename super::StoredPointer;
 
@@ -479,59 +480,20 @@ class ReflectionContext
       *OutInstanceAddress = ExistentialAddress;
       return true;
 
-    // Opaque existentials fall under two cases:
-    // If the value fits in three words, it starts at the beginning of the
-    // container. If it doesn't, the first word is a pointer to a heap box.
     case RecordKind::OpaqueExistential: {
-      auto Fields = ExistentialRecordTI->getFields();
-      auto ExistentialMetadataField = std::find_if(Fields.begin(), Fields.end(),
-                                   [](const FieldInfo &FI) -> bool {
-        return FI.Name.compare("metadata") == 0;
-      });
-      if (ExistentialMetadataField == Fields.end())
+      auto OptMetaAndValue =
+          readMetadataAndValueOpaqueExistential(ExistentialAddress);
+      if (!OptMetaAndValue)
         return false;
+      RemoteAddress MetadataAddress = OptMetaAndValue->first;
+      RemoteAddress ValueAddress = OptMetaAndValue->second;
 
-      // Get the metadata pointer for the contained instance type.
-      // This is equivalent to:
-      // auto PointerArray = reinterpret_cast<uintptr_t*>(ExistentialAddress);
-      // uintptr_t MetadataAddress = PointerArray[Offset];
-      auto MetadataAddressAddress
-        = RemoteAddress(ExistentialAddress.getAddressData() +
-                        ExistentialMetadataField->Offset);
-
-      StoredPointer MetadataAddress = 0;
-      if (!getReader().readInteger(MetadataAddressAddress, &MetadataAddress))
-        return false;
-
-      auto InstanceTR = readTypeFromMetadata(MetadataAddress);
+      auto InstanceTR = readTypeFromMetadata(MetadataAddress.getAddressData());
       if (!InstanceTR)
         return false;
 
       *OutInstanceTR = InstanceTR;
-
-      auto InstanceTI = getTypeInfo(InstanceTR);
-      if (!InstanceTI)
-        return false;
-
-      if (InstanceTI->getSize() <= ExistentialMetadataField->Offset) {
-        // The value fits in the existential container, so it starts at the
-        // start of the container.
-        *OutInstanceAddress = ExistentialAddress;
-      } else {
-        // Otherwise it's in a box somewhere off in the heap. The first word
-        // of the container has the address to that box.
-        StoredPointer BoxAddress = 0;
-
-        if (!getReader().readInteger(ExistentialAddress, &BoxAddress))
-          return false;
-
-        // Address = BoxAddress + (sizeof(HeapObject) + alignMask) & ~alignMask)
-        auto Alignment = InstanceTI->getAlignment();
-        auto StartOfValue = BoxAddress + getSizeOfHeapObject();
-        // Align.
-        StartOfValue += Alignment - StartOfValue % Alignment;
-        *OutInstanceAddress = RemoteAddress(StartOfValue);
-      }
+      *OutInstanceAddress = ValueAddress;
       return true;
     }
     case RecordKind::ErrorExistential: {

include/swift/Remote/MetadataReader.h

@@ -24,6 +24,8 @@
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/Range.h"
 #include "swift/Basic/LLVM.h"
+#include "swift/Runtime/ExistentialContainer.h"
+#include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Unreachable.h"
 
 #include <vector>
@@ -261,7 +263,64 @@ class MetadataReader {
 
     return start;
   }
-  
+
+  /// Given a pointer to the metadata, attempt to read the value
+  /// witness table.
+  llvm::Optional<TargetValueWitnessTable<Runtime>>
+  readValueWitnessTable(StoredPointer MetadataAddress) {
+    // The value witness table pointer is at offset -1 from the metadata
+    // pointer, that is, the pointer-sized word immediately before the
+    // pointer's referenced address.
+    TargetValueWitnessTable<Runtime> VWT;
+    auto ValueWitnessTableAddrAddr = MetadataAddress - sizeof(StoredPointer);
+    StoredPointer ValueWitnessTableAddr;
+    if (!Reader->readInteger(RemoteAddress(ValueWitnessTableAddrAddr),
+                             &ValueWitnessTableAddr))
+      return llvm::None;
+    if (!Reader->readBytes(RemoteAddress(ValueWitnessTableAddr),
+                           (uint8_t *)&VWT, sizeof(VWT)))
+      return llvm::None;
+    return VWT;
+  }
+
+  /// Given a known-opaque existential, attemp to discover the pointer to its
+  /// metadata address and its value.
+  llvm::Optional<std::pair<RemoteAddress, RemoteAddress>>
+  readMetadataAndValueOpaqueExistential(RemoteAddress ExistentialAddress) {
+    // OpaqueExistentialContainer is the layout of an opaque existential.
+    // `Type` is the pointer to the metadata.
+    TargetOpaqueExistentialContainer<Runtime> Container;
+    if (!Reader->readBytes(RemoteAddress(ExistentialAddress),
+                           (uint8_t *)&Container, sizeof(Container)))
+      return llvm::None;
+    auto MetadataAddress = reinterpret_cast<StoredPointer>(Container.Type);
+    auto Metadata = readMetadata(MetadataAddress);
+    if (!Metadata)
+      return llvm::None;
+
+    auto VWT = readValueWitnessTable(MetadataAddress);
+    if (!VWT)
+      return llvm::None;
+
+    // Inline representation (the value fits in the existential container).
+    // So, the value starts at the first word of the container.
+    if (VWT->isValueInline())
+      return llvm::Optional<std::pair<RemoteAddress, RemoteAddress>>(
+          {RemoteAddress(MetadataAddress), ExistentialAddress});
+
+    // Non-inline (box'ed) representation.
+    // The first word of the container stores the address to the box.
+    StoredPointer BoxAddress;
+    if (!Reader->readInteger(ExistentialAddress, &BoxAddress))
+      return llvm::None;
+
+    auto AlignmentMask = VWT->getAlignmentMask();
+    auto Offset = (sizeof(HeapObject) + AlignmentMask) & ~AlignmentMask;
+    auto StartOfValue = BoxAddress + Offset;
+    return llvm::Optional<std::pair<RemoteAddress, RemoteAddress>>(
+        {RemoteAddress(MetadataAddress), RemoteAddress(StartOfValue)});
+  }
+
   /// Given a remote pointer to metadata, attempt to turn it into a type.
   BuiltType readTypeFromMetadata(StoredPointer MetadataAddress,
                                  bool skipArtificialSubclasses = false) {