[Reflection] Add error messages to the new Remote Mirror calls and plumb them through swiftdt.

mikeash · airspeedswift · commit d9805ca4ebb1 · 2020-05-29T08:31:03.000-07:00
rdar://problem/55481578
diff --git a/include/swift/Reflection/ReflectionContext.h b/include/swift/Reflection/ReflectionContext.h
@@ -24,6 +24,7 @@
 #include "llvm/Object/COFF.h"
 
 #include "swift/ABI/Enum.h"
+#include "swift/Basic/TaggedUnion.h"
 #include "swift/Remote/MemoryReader.h"
 #include "swift/Remote/MetadataReader.h"
 #include "swift/Reflection/Records.h"
@@ -815,16 +816,16 @@ class ReflectionContext
     iterateConformanceTree(NodeData->Right, Call);
   }
 
-  bool iterateConformances(
+  llvm::Optional<std::string> iterateConformances(
     std::function<void(StoredPointer Type, StoredPointer Proto)> Call) {
     std::string ConformancesName = "__ZL12Conformances";
     auto ConformancesAddr = getReader().getSymbolAddress(ConformancesName);
     if (!ConformancesAddr)
-      return false;
+      return "unable to look up conformances cache symbol " + ConformancesName;
 
     auto Root = getReader().readPointer(ConformancesAddr, sizeof(StoredPointer));
     iterateConformanceTree(Root->getResolvedAddress().getAddressData(), Call);
-    return true;
+    return llvm::None;
   }
   
   void iterateModules(Demangle::NodePointer Ptr, std::function<void(llvm::StringRef)> Call) {
@@ -864,11 +865,12 @@ class ReflectionContext
     return 0;
   }
   
-  bool iterateMetadataAllocations(std::function<void (MetadataAllocation)> Call) {
+  llvm::Optional<std::string>
+  iterateMetadataAllocations(std::function<void (MetadataAllocation)> Call) {
     std::string AllocationPoolName = "__ZL14AllocationPool";
     auto AllocationPoolAddr = getReader().getSymbolAddress(AllocationPoolName);
     if (!AllocationPoolAddr)
-      return false;
+      return "unable to look up allocation pool symbol " + AllocationPoolName;
     
     struct PoolRange {
       StoredPointer Begin;
@@ -887,7 +889,7 @@ class ReflectionContext
       .readBytes(RemoteAddress(AllocationPoolAddr), sizeof(PoolRange));
     auto Pool = reinterpret_cast<const PoolRange *>(PoolBytes.get());
     if (!Pool)
-      return false;
+      return std::string("failure reading allocation pool contents");
 
     auto TrailerPtr = Pool->Begin + Pool->Remaining;
     while (TrailerPtr) {
@@ -921,7 +923,7 @@ class ReflectionContext
       
       TrailerPtr = Trailer->PrevTrailer;
     }
-    return true;
+    return llvm::None;
   }
 
 private:
diff --git a/include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h b/include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h
@@ -289,15 +289,15 @@ size_t swift_reflection_demangle(const char *MangledName, size_t Length,
                                  char *OutDemangledName, size_t MaxLength);
 
 SWIFT_REMOTE_MIRROR_LINKAGE
-int swift_reflection_iterateConformanceCache(
+const char *swift_reflection_iterateConformanceCache(
   SwiftReflectionContextRef ContextRef,
   void (*Call)(swift_reflection_ptr_t Type,
                swift_reflection_ptr_t Proto,
                void *ContextPtr),
   void *ContextPtr);
 
 SWIFT_REMOTE_MIRROR_LINKAGE
-int swift_reflection_iterateMetadataAllocations(
+const char *swift_reflection_iterateMetadataAllocations(
   SwiftReflectionContextRef ContextRef,
   void (*Call)(swift_metadata_allocation_t Allocation,
                void *ContextPtr),
diff --git a/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp b/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp
@@ -40,6 +40,7 @@ struct SwiftReflectionContext {
   NativeReflectionContext *nativeContext;
   std::vector<std::function<void()>> freeFuncs;
   std::vector<std::tuple<swift_addr_t, swift_addr_t>> dataSegments;
+  std::string lastError;
   
   SwiftReflectionContext(MemoryReaderImpl impl) {
     auto Reader = std::make_shared<CMemoryReader>(impl);
@@ -422,6 +423,15 @@ static swift_childinfo_t convertChild(const TypeInfo *TI, unsigned Index) {
   };
 }
 
+static const char *convertError(SwiftReflectionContextRef ContextRef,
+                                llvm::Optional<std::string> Error) {
+  if (Error) {
+    ContextRef->lastError = *Error;
+    return ContextRef->lastError.c_str();
+  }
+  return nullptr;
+}
+
 swift_typeinfo_t
 swift_reflection_infoForTypeRef(SwiftReflectionContextRef ContextRef,
                                 swift_typeref_t OpaqueTypeRef) {
@@ -585,31 +595,33 @@ size_t swift_reflection_demangle(const char *MangledName, size_t Length,
   return Demangled.size();
 }
 
-int swift_reflection_iterateConformanceCache(
+const char *swift_reflection_iterateConformanceCache(
   SwiftReflectionContextRef ContextRef,
   void (*Call)(swift_reflection_ptr_t Type,
                swift_reflection_ptr_t Proto,
                void *ContextPtr),
   void *ContextPtr) {
   auto Context = ContextRef->nativeContext;
-  return Context->iterateConformances([&](auto Type, auto Proto) {
+  auto Error = Context->iterateConformances([&](auto Type, auto Proto) {
     Call(Type, Proto, ContextPtr);
   });
+  return convertError(ContextRef, Error);
 }
 
-int swift_reflection_iterateMetadataAllocations(
+const char *swift_reflection_iterateMetadataAllocations(
   SwiftReflectionContextRef ContextRef,
   void (*Call)(swift_metadata_allocation_t Allocation,
                void *ContextPtr),
   void *ContextPtr) {
   auto Context = ContextRef->nativeContext;
-  return Context->iterateMetadataAllocations([&](auto Allocation) {
+  auto Error = Context->iterateMetadataAllocations([&](auto Allocation) {
     swift_metadata_allocation CAllocation;
     CAllocation.Tag = Allocation.Tag;
     CAllocation.Ptr = Allocation.Ptr;
     CAllocation.Size = Allocation.Size;
     Call(CAllocation, ContextPtr);
   });
+  return convertError(ContextRef, Error);
 }
 
 SWIFT_REMOTE_MIRROR_LINKAGE
diff --git a/tools/swiftdt/RemoteMirrorExtensions.swift b/tools/swiftdt/RemoteMirrorExtensions.swift
@@ -1,6 +1,14 @@
 import SwiftRemoteMirror
 
 extension SwiftReflectionContextRef {
+  struct Error: Swift.Error {
+    var description: String
+
+    init(cString: UnsafePointer<CChar>) {
+      description = String(cString: cString)
+    }
+  }
+
   func name(metadata: swift_reflection_ptr_t) -> String? {
     let tr = swift_reflection_typeRefForMetadata(self, UInt(metadata));
     guard tr != 0 else { return nil }
@@ -19,28 +27,36 @@ extension SwiftReflectionContextRef {
   }
 
   func iterateConformanceCache(
-    call: (swift_reflection_ptr_t, swift_reflection_ptr_t) -> Void) -> Bool {
+    call: (swift_reflection_ptr_t, swift_reflection_ptr_t) -> Void) throws {
     var call = call
-    let success = swift_reflection_iterateConformanceCache(self, {
-      let callPtr = $2!.bindMemory(to: ((swift_reflection_ptr_t, swift_reflection_ptr_t) -> Void).self, capacity: 1)
+    let errStr = swift_reflection_iterateConformanceCache(self, {
+      let callPtr = $2!.bindMemory(to:
+        ((swift_reflection_ptr_t, swift_reflection_ptr_t) -> Void).self,
+        capacity: 1)
       callPtr.pointee($0, $1)
     }, &call)
-    return success != 0
+    try throwError(str: errStr)
   }
 
-  func iterateMetadataAllocations(call: (swift_metadata_allocation_t) -> Void)
-    -> Bool {
+  func iterateMetadataAllocations(
+    call: (swift_metadata_allocation_t) -> Void) throws {
     var call = call
-    let success = swift_reflection_iterateMetadataAllocations(self, {
+    let errStr = swift_reflection_iterateMetadataAllocations(self, {
       let callPtr = $1!.bindMemory(to:
         ((swift_metadata_allocation_t) -> Void).self, capacity: 1)
       callPtr.pointee($0)
     }, &call)
-    return success != 0
+    try throwError(str: errStr)
   }
 
   func metadataPointer(allocation: swift_metadata_allocation_t)
     -> swift_reflection_ptr_t {
     return swift_reflection_allocationMetadataPointer(self, allocation)
   }
+
+  private func throwError(str: UnsafePointer<CChar>?) throws {
+    if let str = str {
+      throw Error(cString: str)
+    }
+  }
 }
diff --git a/tools/swiftdt/main.swift b/tools/swiftdt/main.swift
@@ -22,7 +22,7 @@ guard let executableName = argv.popFirst() else {
 struct Command {
   var name: String
   var help: String
-  var call: (inout ArraySlice<String>) -> Void
+  var call: (inout ArraySlice<String>) throws -> Void
   
   init(name: String, help: String,
        call: @escaping (inout ArraySlice<String>) -> Void) {
@@ -32,10 +32,10 @@ struct Command {
   }
   
   init(name: String, help: String,
-       call: @escaping (SwiftReflectionContextRef) -> Void) {
+       call: @escaping (SwiftReflectionContextRef) throws -> Void) {
     self.name = name
     self.help = help
-    self.call = { withReflectionContext(args: &$0, call: call) }
+    self.call = { try withReflectionContext(args: &$0, call: call) }
   }
 }
 
@@ -54,21 +54,18 @@ let commands = [
     call: printUsage),
 ]
 
-func dumpConformanceCache(context: SwiftReflectionContextRef) {
-  let success = context.iterateConformanceCache(call: { type, proto in
+func dumpConformanceCache(context: SwiftReflectionContextRef) throws {
+  try context.iterateConformanceCache(call: { type, proto in
     let typeName = context.name(metadata: type) ?? "<unknown>"
     let protoName = context.name(proto: proto) ?? "<unknown>"
     print("Conformance: \(typeName): \(protoName)")
   })
-  if !success {
-    print("Error!")
-  }
 }
 
-func dumpMetadataAllocations(context: SwiftReflectionContextRef) {
+func dumpMetadataAllocations(context: SwiftReflectionContextRef) throws {
   var allocations: [swift_metadata_allocation_t] = []
   var metadatas: [swift_reflection_ptr_t] = []
-  let success = context.iterateMetadataAllocations(call: { allocation in
+  try context.iterateMetadataAllocations(call: { allocation in
     allocations.append(allocation)
     print("Metadata allocation at: \(hex: allocation.Ptr) " + 
           "size: \(allocation.Size) tag: \(allocation.Tag)")
@@ -77,10 +74,6 @@ func dumpMetadataAllocations(context: SwiftReflectionContextRef) {
       metadatas.append(ptr)
     }
   })
-  if !success {
-    print("Error!")
-    return
-  }
 
   allocations.sort(by: { $0.Ptr < $1.Ptr })
   for metadata in metadatas {
@@ -138,18 +131,28 @@ func makeReflectionContext(args: inout ArraySlice<String>)
   return (inspector, reflectionContext)
 }
 
-func withReflectionContext(args: inout ArraySlice<String>,
-                           call: (SwiftReflectionContextRef) -> Void) {
+func withReflectionContext(
+  args: inout ArraySlice<String>,
+  call: (SwiftReflectionContextRef) throws -> Void) throws {
   let (inspector, context) = makeReflectionContext(args: &args)
-  call(context)
-  swift_reflection_destroyReflectionContext(context)
-  inspector.destroyContext()
+  defer {
+    swift_reflection_destroyReflectionContext(context)
+    inspector.destroyContext()
+  }
+  try call(context)
 }
 
 let commandName = argv.popFirst()
 for command in commands {
   if command.name == commandName {
-    command.call(&argv)
+    do {
+      try command.call(&argv)
+    } catch let error as SwiftReflectionContextRef.Error {
+      print("Error: \(error.description)", to: &Std.err)
+      exit(1)
+    } catch {
+      print("Unknown error: \(error)")
+    }
     exit(0)
   }
 }
