Merge pull request #2380 from bitjammer/remote-mirror-existentials

Remote mirror existentials

Author: bitjammer

include/swift/Reflection/ReflectionContext.h

@@ -24,6 +24,7 @@
 #include "swift/Reflection/TypeLowering.h"
 #include "swift/Reflection/TypeRef.h"
 #include "swift/Reflection/TypeRefBuilder.h"
+#include "swift/SwiftRemoteMirror/MemoryReaderInterface.h"
 
 #include <iostream>
 #include <vector>
@@ -119,6 +120,85 @@ class ReflectionContext
     return getMetadataTypeInfo(MetadataAddress.second);
   }
 
+  bool
+  projectExistential(addr_t ExistentialAddress,
+                     const TypeRef *ExistentialTR,
+                     const TypeRef **OutInstanceTR,
+                     addr_t *OutInstanceAddress) {
+    if (ExistentialTR == nullptr)
+      return false;
+
+    auto ExistentialTI = getTypeInfo(ExistentialTR);
+    if (ExistentialTI == nullptr)
+      return false;
+
+    auto ExistentialRecordTI = dyn_cast<const RecordTypeInfo>(ExistentialTI);
+    if (ExistentialRecordTI == nullptr)
+      return false;
+
+    switch (ExistentialRecordTI->getRecordKind()) {
+    // Class existentials have trivial layout.
+    // The first word of the 3-word buffer has a pointer to the class instance.
+    case RecordKind::ClassExistential:
+      *OutInstanceTR = getBuilder().getTypeConverter().getUnknownObjectTypeRef();
+      *OutInstanceAddress = ExistentialAddress;
+      return true;
+
+    // Other existentials have 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::Existential: {
+      auto Fields = ExistentialRecordTI->getFields();
+      auto Metadata = std::find_if(Fields.begin(), Fields.end(),
+                                   [](const FieldInfo &FI) -> bool {
+        return FI.Name.compare("metadata") == 0;
+      });
+      if (Metadata == Fields.end())
+        return false;
+
+      // 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 + Metadata->Offset);
+
+      StoredPointer MetadataAddress = 0;
+      if (!getReader().readInteger(MetadataAddressAddress, &MetadataAddress))
+        return false;
+
+      auto InstanceTR = readTypeFromMetadata(MetadataAddress);
+      if (!InstanceTR)
+        return false;
+
+      *OutInstanceTR = InstanceTR;
+
+      auto InstanceTI = getTypeInfo(InstanceTR);
+      if (!InstanceTI)
+        return false;
+
+      if (InstanceTI->getSize() < ExistentialRecordTI->getSize()) {
+        // 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(RemoteAddress(ExistentialAddress),
+                                    &BoxAddress))
+          return false;
+
+        *OutInstanceAddress = BoxAddress;
+      }
+      return true;
+    }
+    default:
+      return false;
+    }
+  }
+
   /// Return a description of the layout of a value with the given type.
   const TypeInfo *getTypeInfo(const TypeRef *TR) {
     return getBuilder().getTypeConverter().getTypeInfo(TR);

include/swift/Remote/MetadataReader.h

@@ -579,7 +579,7 @@ class MetadataReader {
         return BuiltType();
 
       return Builder.createTupleType(elementTypes, std::move(labels),
-                                     /*variadic*/ false);
+                                     /*variardic*/ false);
     }
     case MetadataKind::Function: {
       auto Function = cast<TargetFunctionTypeMetadata<Runtime>>(Meta);
@@ -682,21 +682,28 @@ class MetadataReader {
     }
   }
 
+  BuiltType readTypeFromMangledName(const char *MangledTypeName,
+                                    size_t Length) {
+    auto Demangled = Demangle::demangleSymbolAsNode(MangledTypeName, Length);
+    return decodeMangledType(Demangled);
+  }
+
   /// Read the isa pointer of a class or closure context instance and apply
   /// the isa mask.
   std::pair<bool, StoredPointer> readMetadataFromInstance(
       StoredPointer ObjectAddress) {
+    StoredPointer isaMaskValue = ~0;
     auto isaMask = readIsaMask();
-    if (!isaMask.first)
-      return {false, 0};
+    if (isaMask.first)
+      isaMaskValue = isaMask.second;
 
     StoredPointer MetadataAddress;
     if (!Reader->readBytes(RemoteAddress(ObjectAddress),
                            (uint8_t*)&MetadataAddress,
                            sizeof(StoredPointer)))
       return {false, 0};
 
-    return {true, MetadataAddress & isaMask.second};
+    return {true, MetadataAddress & isaMaskValue};
   }
 
   /// Given the address of a nominal type descriptor, attempt to resolve

include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h

@@ -74,6 +74,12 @@ swift_typeref_t
 swift_reflection_typeRefForInstance(SwiftReflectionContextRef ContextRef,
                                     uintptr_t Object);
 
+/// Returns a typeref from a mangled type name string.
+swift_typeref_t
+swift_reflection_typeRefForMangledTypeName(SwiftReflectionContextRef ContextRef,
+                                           const char *MangledName,
+                                           uint64_t Length);
+
 /// Returns a structure describing the layout of a value of a typeref.
 /// For classes, this returns the reference value itself.
 swift_typeinfo_t
@@ -141,7 +147,7 @@ swift_reflection_genericArgumentOfTypeRef(swift_typeref_t OpaqueTypeRef,
 /// Returns true if InstanceTypeRef and StartOfInstanceData contain valid
 /// valid values.
 int swift_reflection_projectExistential(SwiftReflectionContextRef ContextRef,
-                                        addr_t InstanceAddress,
+                                        addr_t ExistentialAddress,
                                         swift_typeref_t ExistentialTypeRef,
                                         swift_typeref_t *OutInstanceTypeRef,
                                         addr_t *OutStartOfInstanceData);

stdlib/private/SwiftReflectionTest/SwiftReflectionTest.swift

@@ -21,12 +21,13 @@
 import MachO
 import Darwin
 
+let RequestInstanceKind = "k"
 let RequestInstanceAddress = "i"
 let RequestReflectionInfos = "r"
 let RequestReadBytes = "b";
 let RequestSymbolAddress = "s"
 let RequestStringLength = "l"
-let RequestExit = "e"
+let RequestDone = "d"
 let RequestPointerSize = "p"
 
 internal func debugLog(_ message: String) {
@@ -36,6 +37,13 @@ internal func debugLog(_ message: String) {
 #endif
 }
 
+public enum InstanceKind : UInt8 {
+  case None
+  case Object
+  case Existential
+  case Closure
+}
+
 /// Represents a section in a loaded image in this process.
 internal struct Section {
   /// The absolute start address of the section's data in this address space.
@@ -255,11 +263,17 @@ internal func sendPointerSize() {
 /// - Get the pointer size of this process, which affects assumptions about the
 ///   the layout of runtime structures with pointer-sized fields.
 /// - Read raw bytes out of this process's address space.
-public func reflect(_ instance: AnyObject) {
+///
+/// The parent sends a Done message to indicate that it's done
+/// looking at this instance. It will continue to ask for instances,
+/// so call doneReflecting() when you don't have any more instances.
+internal func reflect(instanceAddress: UInt, kind: InstanceKind) {
   while let command = readLine(strippingNewline: true) {
     switch command {
+    case String(validatingUTF8: RequestInstanceKind)!:
+      sendValue(kind.rawValue)
     case String(validatingUTF8: RequestInstanceAddress)!:
-      sendAddress(of: instance)
+      sendValue(instanceAddress)
     case String(validatingUTF8: RequestReflectionInfos)!:
       sendReflectionInfos()
     case String(validatingUTF8: RequestReadBytes)!:
@@ -270,14 +284,40 @@ public func reflect(_ instance: AnyObject) {
       sendStringLength()
     case String(validatingUTF8: RequestPointerSize)!:
       sendPointerSize();
-    case String(validatingUTF8: RequestExit)!:
-      exit(EXIT_SUCCESS)
+    case String(validatingUTF8: RequestDone)!:
+      return;
     default:
-      fatalError("Unknown request received!")
+      fatalError("Unknown request received: '\(Array(command.utf8))'!")
     }
   }
 }
 
+/// Reflect a class instance.
+public func reflect(object: AnyObject) {
+  let address = unsafeAddress(of: object)
+  let addressValue = unsafeBitCast(address, to: UInt.self)
+  reflect(instanceAddress: addressValue, kind: .Object)
+}
+
+/// Reflect any type at all by boxing it into an existential container (an `Any`)
+///
+/// This function serves to exercise the projectExistential function of the
+/// SwiftRemoteMirror API.
+public func reflect<T>(any: T) {
+  let any: Any = any
+  let anyPointer = UnsafeMutablePointer<Any>(allocatingCapacity: sizeof(Any.self))
+  anyPointer.initialize(with: any)
+  let anyPointerValue = unsafeBitCast(anyPointer, to: UInt.self)
+  reflect(instanceAddress: anyPointerValue, kind: .Existential)
+  anyPointer.deallocateCapacity(sizeof(Any.self))
+}
+
+/// Call this function to indicate to the parent that there are
+/// no more instances to look at.
+public func doneReflecting() {
+  sendValue(InstanceKind.None.rawValue)
+}
+
 /* Example usage
 
 public protocol P {

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -84,6 +84,15 @@ swift_reflection_typeRefForInstance(SwiftReflectionContextRef ContextRef,
   return reinterpret_cast<swift_typeref_t>(TR);
 }
 
+swift_typeref_t
+swift_reflection_typeRefForMangledTypeName(SwiftReflectionContextRef ContextRef,
+                                           const char *MangledTypeName,
+                                           uint64_t Length) {
+  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
+  auto TR = Context->readTypeFromMangledName(MangledTypeName, Length);
+  return reinterpret_cast<swift_typeref_t>(TR);
+}
+
 swift_typeref_t
 swift_reflection_genericArgumentOfTypeRef(swift_typeref_t OpaqueTypeRef,
                                           unsigned Index) {
@@ -237,12 +246,14 @@ swift_reflection_childOfInstance(SwiftReflectionContextRef ContextRef,
 }
 
 int swift_reflection_projectExistential(SwiftReflectionContextRef ContextRef,
-                                        addr_t InstanceAddress,
+                                        addr_t ExistentialAddress,
                                         swift_typeref_t ExistentialTypeRef,
                                         swift_typeref_t *InstanceTypeRef,
                                         addr_t *StartOfInstanceData) {
-  // TODO
-  return false;
+  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
+  auto ExistentialTR = reinterpret_cast<const TypeRef *>(ExistentialTypeRef);
+  return Context->projectExistential(ExistentialAddress, ExistentialTR,
+    reinterpret_cast<const TypeRef **>(InstanceTypeRef), StartOfInstanceData);
 }
 
 void swift_reflection_dumpTypeRef(swift_typeref_t OpaqueTypeRef) {

tools/swift-reflection-test/messages.h

@@ -10,10 +10,18 @@
 //
 //===----------------------------------------------------------------------===//
 
+static const char *REQUEST_INSTANCE_KIND = "k\n";
 static const char *REQUEST_INSTANCE_ADDRESS = "i\n";
 static const char *REQUEST_REFLECTION_INFO = "r\n";
 static const char *REQUEST_READ_BYTES = "b\n";
 static const char *REQUEST_SYMBOL_ADDRESS = "s\n";
 static const char *REQUEST_STRING_LENGTH = "l\n";
 static const char *REQUEST_POINTER_SIZE = "p\n";
-static const char *REQUEST_EXIT = "e\n";
+static const char *REQUEST_DONE = "d\n";
+
+typedef enum InstanceKind {
+  None,
+  Object,
+  Existential,
+  Closure
+} InstanceKind;