Reflection: Share demangler with MetadataReader.

TypeRefBuilder and MetadataReader had nearly identical symbolic reference resolvers,
but diverged because TypeRefBuilder had its own local/remote address management mechanism,
and because TypeRefBuilder tries to resolve opaque types to their underlying types, whereas
other MetadataReader clients want to preserve them as written in source. The first problem
has been addressed by making TypeRefBuilder use `RemoteRef` everywhere, and the second
can be handled with a flag (and might be able to be handled more elegantly with some more
refactoring of general opaque type handling in 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.