SwiftRemoteMirror: Project error existentials

Error existentials have a kind of special heap layout and can also
be compatible as NSError instances, too.

Author: bitjammer

include/swift/Reflection/ReflectionContext.h

@@ -40,6 +40,8 @@ template <typename Runtime>
 class ReflectionContext
        : public remote::MetadataReader<Runtime, TypeRefBuilder> {
   using super = remote::MetadataReader<Runtime, TypeRefBuilder>;
+  using super::readMetadata;
+  using super::readObjCClassName;
 
   std::unordered_map<typename super::StoredPointer, const TypeInfo *> Cache;
 
@@ -229,6 +231,77 @@ class ReflectionContext
       }
       return true;
     }
+    case RecordKind::ErrorExistential: {
+      // We have a pointer to an error existential, which is always heap object.
+
+      bool successfullyGotIsa = false;
+      StoredPointer MetadataAddress = 0;
+      std::tie(successfullyGotIsa, MetadataAddress)
+        = readMetadataFromInstance(ExistentialAddress.getAddressData());
+
+      if (!successfullyGotIsa)
+        return false;
+
+      bool isObjC = false;
+
+      // If we can determine the Objective-C class name, this is probably an
+      // error existential with NSError-compatible layout.
+      std::string ObjCClassName;
+      if (readObjCClassName(MetadataAddress, ObjCClassName)) {
+        if (ObjCClassName == "_SwiftNativeNSError")
+          isObjC = true;
+      } else {
+        // Otherwise, we can check to see if this is a class metadata with the
+        // kind value's least significant bit set, which indicates a pure
+        // Swift class.
+        auto Meta = readMetadata(MetadataAddress);
+        auto ClassMeta = dyn_cast<TargetClassMetadata<Runtime>>(Meta);
+        if (!ClassMeta)
+          return false;
+
+        isObjC = ClassMeta->isPureObjC();
+      }
+
+      // In addition to the isa pointer and two 32-bit reference counts, if the
+      // error existential is layout-compatible with NSError, we also need to
+      // skip over its three word-sized fields: the error code, the domain,
+      // and userInfo.
+      StoredPointer InstanceMetadataAddressAddress
+        = ExistentialAddress.getAddressData() +
+          (isObjC ? 5 : 2) * sizeof(StoredPointer);
+
+      // We need to get the instance's alignment info so we can get the exact
+      // offset of the start of its data in the class.
+      StoredPointer InstanceMetadataAddress = 0;
+      std::tie(successfullyGotIsa, InstanceMetadataAddress) =
+        readMetadataFromInstance(InstanceMetadataAddressAddress);
+      if (!successfullyGotIsa)
+        return false;
+
+      auto InstanceTR = readTypeFromMetadata(InstanceMetadataAddress);
+      if (!InstanceTR)
+        return false;
+
+      auto InstanceTI = getTypeInfo(InstanceTR);
+      if (!InstanceTI)
+        return false;
+
+      // Now we need to skip over the instance metadata pointer and instance's
+      // conformance pointer for Swift.ErrorProtocol.
+      StoredPointer InstanceAddress = InstanceMetadataAddressAddress +
+        2 * sizeof(StoredPointer);
+
+      // Round up to alignment, and we have the start address of the
+      // instance payload.
+      auto Alignment = InstanceTI->getAlignment();
+      InstanceAddress += Alignment - InstanceAddress % Alignment;
+
+      *OutInstanceTR = InstanceTR;
+      *OutInstanceAddress = RemoteAddress(InstanceAddress);
+
+      return true;
+      break;
+    }
     default:
       return false;
     }

include/swift/Reflection/TypeLowering.h

@@ -52,6 +52,10 @@ enum class RecordKind : unsigned {
   // An existential metatype.
   ExistentialMetatype,
 
+  // An error existential is a special kind of heap object, so is a retainable
+  // pointer, with no witness tables.
+  ErrorExistential,
+
   // A class instance layout, consisting of the stored properties of
   // one class, excluding superclasses.
   ClassInstance,

include/swift/Reflection/TypeRef.h

@@ -386,6 +386,14 @@ class ProtocolTypeRef final : public TypeRef {
     FIND_OR_CREATE_TYPEREF(A, ProtocolTypeRef, MangledName);
   }
 
+  bool isAnyObject() const {
+    return MangledName == "Ps9AnyObject_";
+  }
+
+  bool isErrorProtocol() const {
+    return MangledName == "Ps13ErrorProtocol_";
+  }
+
   const std::string &getMangledName() const {
     return MangledName;
   }

include/swift/Remote/MetadataReader.h

@@ -895,23 +895,29 @@ class MetadataReader {
     return targetAddress + signext;
   }
 
-private:
-  template <template <class R> class M>
-  MetadataRef _readMetadata(StoredPointer address) {
-    return _readMetadata(address, sizeof(M<Runtime>));
-  }
+  /// Given a pointer to an Objective-C class, try to read its class name.
+  bool readObjCClassName(StoredPointer classAddress, std::string &className) {
+    // The following algorithm only works on the non-fragile Apple runtime.
 
-  MetadataRef _readMetadata(StoredPointer address, size_t sizeAfter) {
-    auto size = sizeAfter;
-    uint8_t *buffer = (uint8_t *) malloc(size);
-    if (!Reader->readBytes(RemoteAddress(address), buffer, size)) {
-      free(buffer);
-      return nullptr;
-    }
+    // Grab the RO-data pointer.  This part is not ABI.
+    StoredPointer roDataPtr = readObjCRODataPtr(classAddress);
+    if (!roDataPtr) return false;
 
-    auto metadata = reinterpret_cast<TargetMetadata<Runtime>*>(buffer);
-    MetadataCache.insert(std::make_pair(address, OwnedMetadataRef(metadata)));
-    return MetadataRef(address, metadata);
+    // This is ABI.
+    static constexpr auto OffsetToName =
+    roundUpToAlignment(size_t(12), sizeof(StoredPointer))
+    + sizeof(StoredPointer);;
+
+    // Read the name pointer.
+    StoredPointer namePtr;
+    if (!Reader->readInteger(RemoteAddress(roDataPtr + OffsetToName), &namePtr))
+      return false;
+
+    // If the name pointer is null, treat that as an error.
+    if (!namePtr)
+      return false;
+
+    return Reader->readString(RemoteAddress(namePtr), className);
   }
 
   MetadataRef readMetadata(StoredPointer address) {
@@ -924,64 +930,83 @@ class MetadataReader {
       return nullptr;
 
     switch (getEnumeratedMetadataKind(KindValue)) {
-    case MetadataKind::Class:
-      return _readMetadata<TargetClassMetadata>(address);
-    case MetadataKind::Enum:
-      return _readMetadata<TargetEnumMetadata>(address);
-    case MetadataKind::ErrorObject:
-      return _readMetadata<TargetEnumMetadata>(address);
-    case MetadataKind::Existential: {
-      StoredPointer numProtocolsAddress = address +
+      case MetadataKind::Class:
+        return _readMetadata<TargetClassMetadata>(address);
+      case MetadataKind::Enum:
+        return _readMetadata<TargetEnumMetadata>(address);
+      case MetadataKind::ErrorObject:
+        return _readMetadata<TargetEnumMetadata>(address);
+      case MetadataKind::Existential: {
+        StoredPointer numProtocolsAddress = address +
         TargetExistentialTypeMetadata<Runtime>::OffsetToNumProtocols;
-      StoredPointer numProtocols;
-      if (!Reader->readInteger(RemoteAddress(numProtocolsAddress),
-                               &numProtocols))
-        return nullptr;
+        StoredPointer numProtocols;
+        if (!Reader->readInteger(RemoteAddress(numProtocolsAddress),
+                                 &numProtocols))
+          return nullptr;
 
-      auto totalSize = sizeof(TargetExistentialTypeMetadata<Runtime>)
-                     + numProtocols *
-          sizeof(ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptor>);
+        auto totalSize = sizeof(TargetExistentialTypeMetadata<Runtime>)
+        + numProtocols *
+        sizeof(ConstTargetMetadataPointer<Runtime, TargetProtocolDescriptor>);
 
-      return _readMetadata(address, totalSize);
-    }
-    case MetadataKind::ExistentialMetatype:
-      return _readMetadata<TargetExistentialMetatypeMetadata>(address);
-    case MetadataKind::ForeignClass:
-      return _readMetadata<TargetForeignClassMetadata>(address);
-    case MetadataKind::Function:
-      return _readMetadata<TargetFunctionTypeMetadata>(address);
-    case MetadataKind::HeapGenericLocalVariable:
-      return _readMetadata<TargetHeapLocalVariableMetadata>(address);
-    case MetadataKind::HeapLocalVariable:
-      return _readMetadata<TargetHeapLocalVariableMetadata>(address);
-    case MetadataKind::Metatype:
-      return _readMetadata<TargetMetatypeMetadata>(address);
-    case MetadataKind::ObjCClassWrapper:
-      return _readMetadata<TargetObjCClassWrapperMetadata>(address);
-    case MetadataKind::Opaque:
-      return _readMetadata<TargetOpaqueMetadata>(address);
-    case MetadataKind::Optional:
-      return _readMetadata<TargetEnumMetadata>(address);
-    case MetadataKind::Struct:
-      return _readMetadata<TargetStructMetadata>(address);
-    case MetadataKind::Tuple: {
-      auto numElementsAddress = address +
+        return _readMetadata(address, totalSize);
+      }
+      case MetadataKind::ExistentialMetatype:
+        return _readMetadata<TargetExistentialMetatypeMetadata>(address);
+      case MetadataKind::ForeignClass:
+        return _readMetadata<TargetForeignClassMetadata>(address);
+      case MetadataKind::Function:
+        return _readMetadata<TargetFunctionTypeMetadata>(address);
+      case MetadataKind::HeapGenericLocalVariable:
+        return _readMetadata<TargetHeapLocalVariableMetadata>(address);
+      case MetadataKind::HeapLocalVariable:
+        return _readMetadata<TargetHeapLocalVariableMetadata>(address);
+      case MetadataKind::Metatype:
+        return _readMetadata<TargetMetatypeMetadata>(address);
+      case MetadataKind::ObjCClassWrapper:
+        return _readMetadata<TargetObjCClassWrapperMetadata>(address);
+      case MetadataKind::Opaque:
+        return _readMetadata<TargetOpaqueMetadata>(address);
+      case MetadataKind::Optional:
+        return _readMetadata<TargetEnumMetadata>(address);
+      case MetadataKind::Struct:
+        return _readMetadata<TargetStructMetadata>(address);
+      case MetadataKind::Tuple: {
+        auto numElementsAddress = address +
         TargetTupleTypeMetadata<Runtime>::OffsetToNumElements;
-      StoredSize numElements;
-      if (!Reader->readInteger(RemoteAddress(numElementsAddress),
-                               &numElements))
-        return nullptr;
-      auto totalSize = sizeof(TargetTupleTypeMetadata<Runtime>)
-                     + numElements * sizeof(StoredPointer);
-      return _readMetadata(address, totalSize);
-    }
+        StoredSize numElements;
+        if (!Reader->readInteger(RemoteAddress(numElementsAddress),
+                                 &numElements))
+          return nullptr;
+        auto totalSize = sizeof(TargetTupleTypeMetadata<Runtime>)
+        + numElements * sizeof(StoredPointer);
+        return _readMetadata(address, totalSize);
+      }
     }
 
     // We can fall out here if the value wasn't actually a valid
     // MetadataKind.
     return nullptr;
   }
 
+private:
+  template <template <class R> class M>
+  MetadataRef _readMetadata(StoredPointer address) {
+    return _readMetadata(address, sizeof(M<Runtime>));
+  }
+
+  MetadataRef _readMetadata(StoredPointer address, size_t sizeAfter) {
+    auto size = sizeAfter;
+    uint8_t *buffer = (uint8_t *) malloc(size);
+    if (!Reader->readBytes(RemoteAddress(address), buffer, size)) {
+      free(buffer);
+      return nullptr;
+    }
+
+    auto metadata = reinterpret_cast<TargetMetadata<Runtime>*>(buffer);
+    MetadataCache.insert(std::make_pair(address, OwnedMetadataRef(metadata)));
+    return MetadataRef(address, metadata);
+  }
+
   StoredPointer readAddressOfNominalTypeDescriptor(MetadataRef metadata) {
     switch (metadata->getKind()) {
     case MetadataKind::Class: {
@@ -1144,31 +1169,6 @@ class MetadataReader {
     return nominal;
   }
 
-  /// Given a pointer to an Objective-C class, try to read its class name.
-  bool readObjCClassName(StoredPointer classAddress, std::string &className) {
-    // The following algorithm only works on the non-fragile Apple runtime.
-
-    // Grab the RO-data pointer.  This part is not ABI.
-    StoredPointer roDataPtr = readObjCRODataPtr(classAddress);
-    if (!roDataPtr) return false;
-
-    // This is ABI.
-    static constexpr auto OffsetToName =
-      roundUpToAlignment(size_t(12), sizeof(StoredPointer))
-        + sizeof(StoredPointer);;
-
-    // Read the name pointer.
-    StoredPointer namePtr;
-    if (!Reader->readInteger(RemoteAddress(roDataPtr + OffsetToName), &namePtr))
-      return false;
-
-    // If the name pointer is null, treat that as an error.
-    if (!namePtr)
-      return false;
-
-    return Reader->readString(RemoteAddress(namePtr), className);
-  }
-
   /// Given that the remote process is running the non-fragile Apple runtime,
   /// grab the ro-data from a class pointer.
   StoredPointer readObjCRODataPtr(StoredPointer classAddress) {

include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h

@@ -62,6 +62,7 @@ typedef enum swift_layout_kind {
   SWIFT_THICK_FUNCTION,
   SWIFT_EXISTENTIAL,
   SWIFT_CLASS_EXISTENTIAL,
+  SWIFT_ERROR_EXISTENTIAL,
   SWIFT_EXISTENTIAL_METATYPE,
   SWIFT_CLASS_INSTANCE,
   SWIFT_CLOSURE_CONTEXT,

stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift

@@ -41,6 +41,7 @@ public enum InstanceKind : UInt8 {
   case None
   case Object
   case Existential
+  case ErrorExistential
   case Closure
 }
 
@@ -362,6 +363,34 @@ public func reflect<T>(any: T) {
   anyPointer.deallocateCapacity(sizeof(Any.self))
 }
 
+// Reflect an `ErrorProtocol`, a.k.a. an "error existential".
+//
+// These are always boxed on the heap, with the following layout:
+//
+// - Word 0: Metadata Pointer
+// - Word 1: 2x 32-bit reference counts
+//
+// If Objective-C interop is available, an ErrorProtocol is also an
+// `NSError`, and so has:
+//
+// - Word 2: code (NSInteger)
+// - Word 3: domain (NSString *)
+// - Word 4: userInfo (NSDictionary *)
+//
+// Then, always follow:
+//
+// - Word 2 or 5: Instance type metadata pointer
+// - Word 3 or 6: Instance witness table for conforming
+//   to `Swift.ErrorProtocol`.
+//
+// Following that is the instance that conforms to `ErrorProtocol`,
+// rounding up to its alignment.
+public func reflect<T: ErrorProtocol>(error: T) {
+  let error: ErrorProtocol = error
+  let errorPointerValue = unsafeBitCast(error, to: UInt.self)
+  reflect(instanceAddress: errorPointerValue, kind: .ErrorExistential)
+}
+
 /// Reflect a closure context. The given function must be a Swift-native
 /// @convention(thick) function value.
 public func reflect(function: () -> ()) {