Merge pull request swiftlang#27383 from jckarter/type-ref-builder-remote-metadata-reader

Reflection: Share demangler with MetadataReader.

Author: jckarter

include/swift/Reflection/ReflectionContext.h

@@ -107,9 +107,8 @@ class ReflectionContext
   using typename super::StoredPointer;
 
   explicit ReflectionContext(std::shared_ptr<MemoryReader> reader)
-    : super(std::move(reader)) {
-    getBuilder().setMetadataReader(*this);
-  }
+    : super(std::move(reader), *this)
+  {}
 
   ReflectionContext(const ReflectionContext &other) = delete;
   ReflectionContext &operator=(const ReflectionContext &other) = delete;

include/swift/Reflection/TypeRefBuilder.h

@@ -65,6 +65,21 @@ class ReflectionSection {
   size_t size() const {
     return Size;
   }
+  
+  bool containsRemoteAddress(uint64_t remoteAddr,
+                             uint64_t size) const {
+    return Start.getAddressData() <= remoteAddr
+      && remoteAddr + size <= Start.getAddressData() + Size;
+  }
+  
+  template<typename U>
+  RemoteRef<U> getRemoteRef(uint64_t remoteAddr) const {
+    assert(containsRemoteAddress(remoteAddr, sizeof(U)));
+    auto localAddr = (uint64_t)(uintptr_t)Start.getLocalBuffer()
+      + (remoteAddr - Start.getAddressData());
+    
+    return RemoteRef<U>(remoteAddr, (const U*)localAddr);
+  }
 };
 
 template<typename Self, typename Descriptor>
@@ -239,17 +254,12 @@ class TypeRefBuilder {
   using BuiltTypeDecl = Optional<std::string>;
   using BuiltProtocolDecl = Optional<std::pair<std::string, bool /*isObjC*/>>;
 
-  TypeRefBuilder();
-
   TypeRefBuilder(const TypeRefBuilder &other) = delete;
   TypeRefBuilder &operator=(const TypeRefBuilder &other) = delete;
 
 private:
   Demangle::Demangler Dem;
 
-  std::function<const TypeRef* (const void*, unsigned)>
-    OpaqueUnderlyingTypeReader;
-  
   /// Makes sure dynamically allocated TypeRefs stick around for the life of
   /// this TypeRefBuilder and are automatically released.
   std::vector<std::unique_ptr<const TypeRef>> TypeRefPool;
@@ -555,106 +565,66 @@ class TypeRefBuilder {
     return ReflectionInfos;
   }
 
+public:
+  enum ForTesting_t { ForTesting };
+  
+  // Only for testing. A TypeRefBuilder built this way will not be able to
+  // decode records in remote memory.
+  explicit TypeRefBuilder(ForTesting_t) : TC(*this) {}
+
 private:
   std::vector<ReflectionInfo> ReflectionInfos;
-  
-  uint64_t getRemoteAddrOfTypeRefPointer(const void *pointer);
-  
-  std::function<auto (SymbolicReferenceKind kind,
-                      Directness directness,
-                      int32_t offset, const void *base) -> Demangle::Node *>
-    SymbolicReferenceResolver;
-  
+    
   std::string normalizeReflectionName(RemoteRef<char> name);
   bool reflectionNameMatches(RemoteRef<char> reflectionName,
                              StringRef searchName);
 
 public:
+  RemoteRef<char> readTypeRef(uint64_t remoteAddr);
+  
   template<typename Record, typename Field>
   RemoteRef<char> readTypeRef(RemoteRef<Record> record,
                               const Field &field) {
     uint64_t remoteAddr = record.resolveRelativeFieldData(field);
-    // TODO: This assumes the remote and local buffer addresses are contiguous,
-    // which should not be a guarantee that MemoryReaders need to maintain.
-    // Ultimately this should use the MemoryReader to read the string.
-    auto localAddr = (uint64_t)(uintptr_t)record.getLocalBuffer()
-      + (int64_t)(remoteAddr - record.getAddressData());
-    
-    // Skip the mangling prefix, if any.
-    auto localPtr = (const char *)localAddr;
-    if (localPtr[0] == '$' && localPtr[1] == 's') {
-      remoteAddr += 2;
-      localPtr += 2;
-    }
 
-    return RemoteRef<char>(remoteAddr, localPtr);
+    return readTypeRef(remoteAddr);
   }
-  
+
   StringRef getTypeRefString(RemoteRef<char> record) {
     return Demangle::makeSymbolicMangledNameStringRef(record.getLocalBuffer());
   }
 
-  Demangle::Node *demangleTypeRef(RemoteRef<char> string) {
-    // TODO: Use the remote addr in the RemoteRef to resolve and read from
-    // remote addresses in the resolver function.
-    return Dem.demangleType(getTypeRefString(string),
-                            SymbolicReferenceResolver);
-  }
+private:
+  // These fields are captured from the MetadataReader template passed into the
+  // TypeRefBuilder struct, to isolate its template-ness from the rest of
+  // TypeRefBuilder.
+  unsigned PointerSize;
+  std::function<Demangle::Node * (RemoteRef<char>)>
+    TypeRefDemangler;
+  std::function<const TypeRef* (const void*, unsigned)>
+    OpaqueUnderlyingTypeReader;
 
+public:
   template<typename Runtime>
-  void setMetadataReader(
-                      remote::MetadataReader<Runtime, TypeRefBuilder> &reader) {
-    // Have the TypeRefBuilder demangle symbolic references by reading their
-    // demangling out of the referenced context descriptors in the target
-    // process.
-    SymbolicReferenceResolver =
-    [this, &reader](SymbolicReferenceKind kind,
-                    Directness directness,
-                    int32_t offset, const void *base) -> Demangle::Node * {
-      // Resolve the reference to a remote address.
-      auto remoteAddress = getRemoteAddrOfTypeRefPointer(base);
-      if (remoteAddress == 0)
-        return nullptr;
-      
-      auto address = remoteAddress + offset;
-      if (directness == Directness::Indirect) {
-        if (auto indirectAddress = reader.readPointerValue(address)) {
-          address = *indirectAddress;
-        } else {
-          return nullptr;
-        }
-      }
-      
-      switch (kind) {
-      case Demangle::SymbolicReferenceKind::Context: {
-        auto context = reader.readContextDescriptor(address);
-        if (!context)
-          return nullptr;
-        // Try to preserve a reference to an OpaqueTypeDescriptor symbolically,
-        // since we'd like to read out and resolve the type ref to the
-        // underlying type if available.
-        if (context->getKind() == ContextDescriptorKind::OpaqueType) {
-          return Dem.createNode(
-                            Node::Kind::OpaqueTypeDescriptorSymbolicReference,
-                            context.getAddressData());
-        }
-          
-        return reader.buildContextMangling(context, Dem);
-      }
-      case Demangle::SymbolicReferenceKind::AccessorFunctionReference:
-        // The symbolic reference points at a resolver function, but we can't
-        // execute code in the target process to resolve it from here.
-        return nullptr;
-      }
-      
-      return nullptr;
-    };
-    
-    OpaqueUnderlyingTypeReader =
-    [&reader](const void *descriptor, unsigned ordinal) -> const TypeRef* {
-      auto context = (typename Runtime::StoredPointer)descriptor;
-      return reader.readUnderlyingTypeForOpaqueTypeDescriptor(context, ordinal);
-    };
+  TypeRefBuilder(remote::MetadataReader<Runtime, TypeRefBuilder> &reader)
+    : TC(*this),
+      PointerSize(sizeof(typename Runtime::StoredPointer)),
+      TypeRefDemangler(
+      [this, &reader](RemoteRef<char> string) -> Demangle::Node * {
+        return reader.demangle(string,
+                               remote::MangledNameKind::Type,
+                               Dem, /*useOpaqueTypeSymbolicReferences*/ true);
+      }),
+      OpaqueUnderlyingTypeReader(
+      [&reader](const void *descriptor, unsigned ordinal) -> const TypeRef* {
+        auto context = (typename Runtime::StoredPointer)descriptor;
+        return reader.readUnderlyingTypeForOpaqueTypeDescriptor(context,
+                                                                ordinal);
+      })
+  {}
+
+  Demangle::Node *demangleTypeRef(RemoteRef<char> string) {
+    return TypeRefDemangler(string);
   }
 
   TypeConverter &getTypeConverter() { return TC; }

include/swift/Remote/MetadataReader.h

@@ -41,6 +41,12 @@ using FunctionParam = swift::Demangle::FunctionParam<BuiltType>;
 template <typename BuilderType>
 using TypeDecoder = swift::Demangle::TypeDecoder<BuilderType>;
 
+/// The kind of mangled name to read.
+enum class MangledNameKind {
+  Type,
+  Symbol,
+};
+
 /// A pointer to the local buffer of an object that also remembers the
 /// address at which it was stored remotely.
 template <typename T>
@@ -287,6 +293,75 @@ class MetadataReader {
     ContextDescriptorCache.clear();
   }
 
+  /// Demangle a mangled name that was read from the given remote address.
+  Demangle::NodePointer demangle(RemoteRef<char> mangledName,
+                                 MangledNameKind kind,
+                                 Demangler &dem,
+                                 bool useOpaqueTypeSymbolicReferences = false) {
+    // Symbolic reference resolver for the demangle operation below.
+    auto symbolicReferenceResolver = [&](SymbolicReferenceKind kind,
+                                         Directness directness,
+                                         int32_t offset,
+                                         const void *base) ->
+        swift::Demangle::NodePointer {
+      // Resolve the reference to a remote address.
+      auto offsetInMangledName =
+            (const char *)base - mangledName.getLocalBuffer();
+      auto remoteAddress =
+        mangledName.getAddressData() + offsetInMangledName + offset;
+
+      if (directness == Directness::Indirect) {
+        if (auto indirectAddress = readPointerValue(remoteAddress)) {
+          remoteAddress = *indirectAddress;
+        } else {
+          return nullptr;
+        }
+      }
+
+      switch (kind) {
+      case Demangle::SymbolicReferenceKind::Context: {
+          auto context = readContextDescriptor(remoteAddress);
+          if (!context)
+            return nullptr;
+          // Try to preserve a reference to an OpaqueTypeDescriptor
+          // symbolically, since we'd like to read out and resolve the type ref
+          // to the underlying type if available.
+          if (useOpaqueTypeSymbolicReferences
+              && context->getKind() == ContextDescriptorKind::OpaqueType) {
+            return dem.createNode(
+                              Node::Kind::OpaqueTypeDescriptorSymbolicReference,
+                              context.getAddressData());
+          }
+            
+          return buildContextMangling(context, dem);
+      }
+      case Demangle::SymbolicReferenceKind::AccessorFunctionReference: {
+        // The symbolic reference points at a resolver function, but we can't
+        // execute code in the target process to resolve it from here.
+        return nullptr;
+      }
+      }
+
+      return nullptr;
+    };
+    
+    auto mangledNameStr =
+      Demangle::makeSymbolicMangledNameStringRef(mangledName.getLocalBuffer());
+
+    swift::Demangle::NodePointer result;
+    switch (kind) {
+    case MangledNameKind::Type:
+      result = dem.demangleType(mangledNameStr, symbolicReferenceResolver);
+      break;
+
+    case MangledNameKind::Symbol:
+      result = dem.demangleSymbol(mangledNameStr, symbolicReferenceResolver);
+      break;
+    }
+
+    return result;
+  }
+
   /// Given a demangle tree, attempt to turn it into a type.
   BuiltType decodeMangledType(NodePointer Node) {
     return swift::Demangle::decodeMangledType(Builder, Node);
@@ -1630,12 +1705,6 @@ class MetadataReader {
     return name;
   }
 
-  /// The kind of mangled name to read.
-  enum class MangledNameKind {
-    Type,
-    Symbol,
-  };
-
   /// Clone the given demangle node into the demangler \c dem.
   static Demangle::NodePointer cloneDemangleNode(Demangle::NodePointer node,
                                                  Demangler &dem) {
@@ -1655,7 +1724,7 @@ class MetadataReader {
     }
     return newNode;
   }
-
+  
   /// Read a mangled name at the given remote address and return the
   /// demangle tree.
   Demangle::NodePointer readMangledName(RemoteAddress address,
@@ -1709,55 +1778,9 @@ class MetadataReader {
       break;
     }
 
-    // Symbolic reference resolver for the demangle operation below.
-    auto symbolicReferenceResolver = [&](SymbolicReferenceKind kind,
-                                         Directness directness,
-                                         int32_t offset,
-                                         const void *base) ->
-        swift::Demangle::NodePointer {
-      // Resolve the reference to a remote address.
-      auto offsetInMangledName = (const char *)base - mangledName.data();
-      auto remoteAddress =
-        address.getAddressData() + offsetInMangledName + offset;
-
-      if (directness == Directness::Indirect) {
-        if (auto indirectAddress = readPointerValue(remoteAddress)) {
-          remoteAddress = *indirectAddress;
-        } else {
-          return nullptr;
-        }
-      }
-
-      switch (kind) {
-      case Demangle::SymbolicReferenceKind::Context: {
-        Demangler innerDemangler;
-        auto result = readDemanglingForContextDescriptor(
-          remoteAddress, innerDemangler);
-
-        return cloneDemangleNode(result, dem);
-      }
-      case Demangle::SymbolicReferenceKind::AccessorFunctionReference: {
-        // The symbolic reference points at a resolver function, but we can't
-        // execute code in the target process to resolve it from here.
-        return nullptr;
-      }
-      }
-
-      return nullptr;
-    };
-
-    swift::Demangle::NodePointer result;
-    switch (kind) {
-    case MangledNameKind::Type:
-      result = dem.demangleType(mangledName, symbolicReferenceResolver);
-      break;
-
-    case MangledNameKind::Symbol:
-      result = dem.demangleSymbol(mangledName, symbolicReferenceResolver);
-      break;
-    }
-
-    return result;
+    return demangle(RemoteRef<char>(address.getAddressData(),
+                                    mangledName.data()),
+                    kind, dem);
   }
 
   /// Read and demangle the name of an anonymous context.

include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h

@@ -72,20 +72,20 @@ SWIFT_REMOTE_MIRROR_LINKAGE
 void
 swift_reflection_destroyReflectionContext(SwiftReflectionContextRef Context);
 
-/// Add reflection sections for a loaded Swift image.
+/// DEPRECATED. Add reflection sections for a loaded Swift image.
+///
+/// You probably want to use \c swift_reflection_addImage instead.
 SWIFT_REMOTE_MIRROR_LINKAGE
 void
 swift_reflection_addReflectionInfo(SwiftReflectionContextRef ContextRef,
                                    swift_reflection_info_t Info);
 
-#if defined(__APPLE__) && defined(__MACH__)
 /// Add reflection information from a loaded Swift image.
 /// Returns true on success, false if the image's memory couldn't be read.
 SWIFT_REMOTE_MIRROR_LINKAGE
 int
 swift_reflection_addImage(SwiftReflectionContextRef ContextRef,
                           swift_addr_t imageStart);
-#endif
 
 /// Returns a boolean indicating if the isa mask was successfully
 /// read, in which case it is stored in the isaMask out parameter.