Teach MetadataReader how to skip artificial subclasses,

and improve RemoteAST to provide corresponding APIs.

Author: rjmccall

include/swift/Remote/MetadataReader.h

@@ -626,7 +626,8 @@ class MetadataReader {
   }
 
   /// Given a remote pointer to metadata, attempt to turn it into a type.
-  BuiltType readTypeFromMetadata(StoredPointer MetadataAddress) {
+  BuiltType readTypeFromMetadata(StoredPointer MetadataAddress,
+                                 bool skipArtificialSubclasses = false) {
     auto Cached = TypeCache.find(MetadataAddress);
     if (Cached != TypeCache.end())
       return Cached->second;
@@ -643,7 +644,7 @@ class MetadataReader {
 
     switch (Meta->getKind()) {
     case MetadataKind::Class:
-      return readNominalTypeFromMetadata(Meta);
+      return readNominalTypeFromMetadata(Meta, skipArtificialSubclasses);
     case MetadataKind::Struct:
       return readNominalTypeFromMetadata(Meta);
     case MetadataKind::Enum:
@@ -997,6 +998,20 @@ class MetadataReader {
     return targetAddress + signext;
   }
 
+  template<typename Offset>
+  llvm::Optional<StoredPointer>
+  resolveNullableRelativeOffset(StoredPointer targetAddress) {
+    Offset relative;
+    if (!Reader->readInteger(RemoteAddress(targetAddress), &relative))
+      return llvm::None;
+    if (relative == 0)
+      return 0;
+    using SignedOffset = typename std::make_signed<Offset>::type;
+    using SignedPointer = typename std::make_signed<StoredPointer>::type;
+    auto signext = (SignedPointer)(SignedOffset)relative;
+    return targetAddress + signext;
+  }
+
   /// 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.
@@ -1118,12 +1133,39 @@ class MetadataReader {
     return MetadataRef(address, metadata);
   }
 
-  StoredPointer readAddressOfNominalTypeDescriptor(MetadataRef metadata) {
+  StoredPointer readAddressOfNominalTypeDescriptor(MetadataRef &metadata,
+                                        bool skipArtificialSubclasses = false) {
     switch (metadata->getKind()) {
     case MetadataKind::Class: {
       auto classMeta = cast<TargetClassMetadata<Runtime>>(metadata);
-      return resolveRelativeOffset<StoredPointer>(metadata.getAddress() +
-                                       classMeta->offsetToDescriptorOffset());
+      while (true) {
+        auto descriptorAddress =
+          resolveNullableRelativeOffset<StoredPointer>(metadata.getAddress() +
+                                         classMeta->offsetToDescriptorOffset());
+
+        // Propagate errors reading the offset.
+        if (!descriptorAddress) return 0;
+
+        // If this class has a null descriptor, it's artificial,
+        // and we need to skip it upon request.  Otherwise, we're done.
+        if (*descriptorAddress || !skipArtificialSubclasses)
+          return *descriptorAddress;
+
+        auto superclassMetadataAddress = classMeta->SuperClass;
+        if (!superclassMetadataAddress)
+          return 0;
+
+        auto superMeta = readMetadata(superclassMetadataAddress);
+        if (!superMeta)
+          return 0;
+        auto superclassMeta =
+          dyn_cast<TargetClassMetadata<Runtime>>(superMeta);
+        if (!superclassMeta)
+          return 0;
+
+        classMeta = superclassMeta;
+        metadata = superMeta;
+      }
     }
 
     case MetadataKind::Struct:
@@ -1241,11 +1283,24 @@ class MetadataReader {
     return substitutions;
   }
 
-  BuiltType readNominalTypeFromMetadata(MetadataRef metadata) {
-    auto descriptorAddress = readAddressOfNominalTypeDescriptor(metadata);
+  BuiltType readNominalTypeFromMetadata(MetadataRef origMetadata,
+                                        bool skipArtificialSubclasses = false) {
+    auto metadata = origMetadata;
+    auto descriptorAddress =
+      readAddressOfNominalTypeDescriptor(metadata,
+                                         skipArtificialSubclasses);
     if (!descriptorAddress)
       return BuiltType();
 
+    // If we've skipped an artificial subclasses, check the cache at
+    // the superclass.  (This also protects against recursion.)
+    if (skipArtificialSubclasses &&
+        metadata.getAddress() != origMetadata.getAddress()) {
+      auto it = TypeCache.find(metadata.getAddress());
+      if (it != TypeCache.end())
+        return it->second;
+    }
+
     // Read the nominal type descriptor.
     auto descriptor = readNominalTypeDescriptor(descriptorAddress);
     if (!descriptor)
@@ -1277,6 +1332,14 @@ class MetadataReader {
     if (!nominal) return BuiltType();
 
     TypeCache[metadata.getAddress()] = nominal;
+
+    // If we've skipped an artificial subclass, remove the
+    // recursion-protection entry we made for it.
+    if (skipArtificialSubclasses &&
+        metadata.getAddress() != origMetadata.getAddress()) {
+      TypeCache.erase(origMetadata.getAddress());
+    }
+
     return nominal;
   }
 

include/swift/RemoteAST/RemoteAST.h

@@ -168,7 +168,16 @@ class RemoteASTContext {
 
   /// Given an address which is supposedly of type metadata, try to
   /// resolve it to a specific type in the local AST.
-  Result<Type> getTypeForRemoteTypeMetadata(remote::RemoteAddress address);
+  ///
+  /// \param skipArtificial If true, the address may be an artificial type
+  ///   wrapper that should be ignored.  For example, it could be a
+  ///   dynamic subclass created by (e.g.) CoreData or KVO; if so, and this
+  ///   flag is set, this method will implicitly ignore the subclass
+  ///   and instead attempt to resolve a type for the first non-artificial
+  ///   superclass.
+  Result<Type>
+  getTypeForRemoteTypeMetadata(remote::RemoteAddress address,
+                               bool skipArtificial = false);
 
   /// Given an address which is supposedly of type metadata, try to
   /// resolve it to a specific MetadataKind value for its backing type.
@@ -198,6 +207,10 @@ class RemoteASTContext {
   Result<uint64_t> getOffsetOfMember(Type type,
                                      remote::RemoteAddress optMetadataAddress,
                                      StringRef memberName);
+
+  /// Given a heap object, resolve its heap metadata.
+  Result<remote::RemoteAddress>
+  getHeapMetadataForObject(remote::RemoteAddress address);
 };
 
 } // end namespace remoteAST

lib/RemoteAST/RemoteAST.cpp

@@ -666,11 +666,13 @@ class RemoteASTContextImpl {
   virtual ~RemoteASTContextImpl() = default;
 
   virtual Result<Type>
-  getTypeForRemoteTypeMetadata(RemoteAddress metadata) = 0;
+  getTypeForRemoteTypeMetadata(RemoteAddress metadata, bool skipArtificial) = 0;
   virtual Result<MetadataKind>
   getKindForRemoteTypeMetadata(RemoteAddress metadata) = 0;
   virtual Result<NominalTypeDecl*>
   getDeclForRemoteNominalTypeDescriptor(RemoteAddress descriptor) = 0;
+  virtual Result<RemoteAddress>
+  getHeapMetadataForObject(RemoteAddress object) = 0;
 
   Result<uint64_t>
   getOffsetOfMember(Type type, RemoteAddress optMetadata, StringRef memberName){
@@ -971,8 +973,10 @@ class RemoteASTContextConcreteImpl final : public RemoteASTContextImpl {
                                ASTContext &ctx)
     : Reader(std::move(reader), ctx) {}
 
-  Result<Type> getTypeForRemoteTypeMetadata(RemoteAddress metadata) override {
-    if (auto result = Reader.readTypeFromMetadata(metadata.getAddressData()))
+  Result<Type> getTypeForRemoteTypeMetadata(RemoteAddress metadata,
+                                            bool skipArtificial) override {
+    if (auto result = Reader.readTypeFromMetadata(metadata.getAddressData(),
+                                                  skipArtificial))
       return result;
     return getFailure<Type>();
   }
@@ -1014,6 +1018,13 @@ class RemoteASTContextConcreteImpl final : public RemoteASTContextImpl {
     return fail<uint64_t>(Failure::Unimplemented,
                           "look up field offset by name");
   }
+
+  Result<RemoteAddress>
+  getHeapMetadataForObject(RemoteAddress object) override {
+    auto result = Reader.readMetadataFromInstance(object.getAddressData());
+    if (result.first) return RemoteAddress(result.second);
+    return getFailure<RemoteAddress>();
+  }
 };
 
 } // end anonymous namespace
@@ -1046,8 +1057,9 @@ RemoteASTContext::~RemoteASTContext() {
 }
 
 Result<Type>
-RemoteASTContext::getTypeForRemoteTypeMetadata(RemoteAddress address) {
-  return asImpl(Impl)->getTypeForRemoteTypeMetadata(address);
+RemoteASTContext::getTypeForRemoteTypeMetadata(RemoteAddress address,
+                                               bool skipArtificial) {
+  return asImpl(Impl)->getTypeForRemoteTypeMetadata(address, skipArtificial);
 }
 
 Result<MetadataKind>
@@ -1065,3 +1077,8 @@ RemoteASTContext::getOffsetOfMember(Type type, RemoteAddress optMetadata,
                                     StringRef memberName) {
   return asImpl(Impl)->getOffsetOfMember(type, optMetadata, memberName);
 }
+
+Result<remote::RemoteAddress>
+RemoteASTContext::getHeapMetadataForObject(remote::RemoteAddress address) {
+  return asImpl(Impl)->getHeapMetadataForObject(address);
+}

test/RemoteAST/objc_classes.swift

@@ -8,5 +8,21 @@ import Foundation
 @_silgen_name("printMetadataType")
 func printType(_: Any.Type)
 
+@_silgen_name("printHeapMetadataType")
+func printDynamicType(_: AnyObject)
+
 printType(NSString.self)
 // CHECK: NSString
+
+class A<T> : NSObject {
+  @objc var property: Int
+  override init() { property = 0 }
+}
+let a = A<Int>()
+printDynamicType(a)
+// CHECK: A<Int>
+
+let observer = NSObject()
+a.addObserver(observer, forKeyPath: "property", options: [], context: nil)
+printDynamicType(a)
+// CHECK: A<Int>

tools/swift-remoteast-test/swift-remoteast-test.cpp

@@ -52,6 +52,36 @@ extern "C" void printMetadataType(const Metadata *typeMetadata) {
   }
 }
 
+// FIXME: swiftcall
+/// func printDynamicType(_: AnyObject)
+LLVM_ATTRIBUTE_USED
+extern "C" void printHeapMetadataType(void *object) {
+  assert(Context && "context was not set");
+
+  std::shared_ptr<MemoryReader> reader(new InProcessMemoryReader());
+  RemoteASTContext remoteAST(*Context, std::move(reader));
+
+  auto &out = llvm::outs();
+
+  auto metadataResult =
+    remoteAST.getHeapMetadataForObject(RemoteAddress(object));
+  if (!metadataResult) {
+    out << metadataResult.getFailure().render() << '\n';
+    return;
+  }
+  auto metadata = metadataResult.getValue();
+
+  auto result =
+    remoteAST.getTypeForRemoteTypeMetadata(metadata, /*skipArtificial*/ true);
+  if (result) {
+    out << "found type: ";
+    result.getValue().print(out);
+    out << '\n';
+  } else {
+    out << result.getFailure().render() << '\n';
+  }
+}
+
 static void printMemberOffset(const Metadata *typeMetadata,
                               StringRef memberName, bool passMetadata) {
   assert(Context && "context was not set");