Merge pull request #14916 from mikeash/remotemirror-hide-reflection-sections

[RemoteMirrors] Improve the API to no longer require clients to know about section names, and make it easier to interoperate with multiple versions of the library.

Author: mikeash

include/swift/Reflection/ReflectionContext.h

@@ -18,6 +18,10 @@
 #ifndef SWIFT_REFLECTION_REFLECTIONCONTEXT_H
 #define SWIFT_REFLECTION_REFLECTIONCONTEXT_H
 
+#if defined(__APPLE__) && defined(__MACH__)
+#include <mach-o/getsect.h>
+#endif
+
 #include "swift/Remote/MemoryReader.h"
 #include "swift/Remote/MetadataReader.h"
 #include "swift/Reflection/Records.h"
@@ -30,6 +34,32 @@
 #include <set>
 #include <vector>
 #include <unordered_map>
+#include <utility>
+
+#if defined(__APPLE__) && defined(__MACH__)
+#ifndef __LP64__
+typedef const struct mach_header MachHeader;
+#else
+typedef const struct mach_header_64 MachHeader;
+#endif
+#endif
+
+#if defined(__APPLE__) && defined(__MACH__)
+template <typename Section>
+static std::pair<Section, bool> findSection(MachHeader *Header,
+                                            const char *Name) {
+  unsigned long Size;
+  auto Address = getsectiondata(Header, "__TEXT", Name, &Size);
+  if (!Address)
+    return {{nullptr, nullptr}, false};
+
+  auto End = reinterpret_cast<uintptr_t>(Address) + Size;
+
+  return {{reinterpret_cast<const void *>(Address),
+           reinterpret_cast<const void *>(End)},
+          true};
+}
+#endif
 
 namespace swift {
 namespace reflection {
@@ -46,6 +76,11 @@ class ReflectionContext
 
   std::unordered_map<typename super::StoredPointer, const TypeInfo *> Cache;
 
+  /// All buffers we need to keep around long term. This will automatically free them
+  /// when this object is destroyed.
+  std::vector<MemoryReader::ReadBytesResult> savedBuffers;
+  std::vector<std::tuple<RemoteAddress, RemoteAddress>> dataSegments;
+
 public:
   using super::getBuilder;
   using super::readDemanglingForContextDescriptor;
@@ -62,7 +97,7 @@ class ReflectionContext
 
   ReflectionContext(const ReflectionContext &other) = delete;
   ReflectionContext &operator=(const ReflectionContext &other) = delete;
-
+  
   MemoryReader &getReader() {
     return *this->Reader;
   }
@@ -76,10 +111,108 @@ class ReflectionContext
     getBuilder().dumpAllSections();
   }
 
+#if defined(__APPLE__) && defined(__MACH__)
+  bool addImage(RemoteAddress ImageStart) {
+    auto Buf = this->getReader().readBytes(ImageStart, sizeof(MachHeader));
+    if (!Buf)
+      return false;
+
+    auto Header = reinterpret_cast<MachHeader *>(Buf.get());
+    if (Header->magic != MH_MAGIC && Header->magic != MH_MAGIC_64) {
+      return false;
+    }
+    auto Length = Header->sizeofcmds;
+
+    // Read the commands.
+    Buf = this->getReader().readBytes(ImageStart, Length);
+    if (!Buf)
+      return false;
+
+    // Find the TEXT segment and figure out where the end is.
+    Header = reinterpret_cast<MachHeader *>(Buf.get());
+    unsigned long TextSize;
+    auto *TextSegment = getsegmentdata(Header, "__TEXT", &TextSize);
+    if (TextSegment == nullptr)
+      return false;
+    
+    auto TextEnd =
+        TextSegment - reinterpret_cast<const uint8_t *>(Buf.get()) + TextSize;
+
+    // Read everything including the TEXT segment.
+    Buf = this->getReader().readBytes(ImageStart, TextEnd);
+    if (!Buf)
+      return false;
+
+    // Read all the metadata parts.
+    Header = reinterpret_cast<MachHeader *>(Buf.get());
+
+    // The docs say "not all sections may be present." We'll succeed if ANY of
+    // them are present. Not sure if that's the right thing to do.
+    auto FieldMd = findSection<FieldSection>(Header, "__swift5_fieldmd");
+    auto AssocTyMd =
+        findSection<AssociatedTypeSection>(Header, "__swift5_assocty");
+    auto BuiltinTyMd =
+        findSection<BuiltinTypeSection>(Header, "__swift5_builtin");
+    auto CaptureMd = findSection<CaptureSection>(Header, "__swift5_capture");
+    auto TyperefMd = findSection<GenericSection>(Header, "__swift5_typeref");
+    auto ReflStrMd = findSection<GenericSection>(Header, "__swift5_reflstr");
+
+    bool success = FieldMd.second || AssocTyMd.second || BuiltinTyMd.second ||
+                   CaptureMd.second || TyperefMd.second || ReflStrMd.second;
+    if (!success)
+      return false;
+
+    auto LocalStartAddress = reinterpret_cast<uintptr_t>(Buf.get());
+    auto RemoteStartAddress = static_cast<uintptr_t>(ImageStart.getAddressData());
+
+    ReflectionInfo info = {
+        {{FieldMd.first.startAddress(), FieldMd.first.endAddress()}, 0},
+        {{AssocTyMd.first.startAddress(), AssocTyMd.first.endAddress()}, 0},
+        {{BuiltinTyMd.first.startAddress(), BuiltinTyMd.first.endAddress()}, 0},
+        {{CaptureMd.first.startAddress(), CaptureMd.first.endAddress()}, 0},
+        {{TyperefMd.first.startAddress(), TyperefMd.first.endAddress()}, 0},
+        {{ReflStrMd.first.startAddress(), ReflStrMd.first.endAddress()}, 0},
+        LocalStartAddress,
+        RemoteStartAddress};
+
+    this->addReflectionInfo(info);
+
+    unsigned long DataSize;
+    auto *DataSegment = getsegmentdata(Header, "__DATA", &DataSize);
+    if (DataSegment != nullptr) {
+      auto DataSegmentStart = DataSegment - reinterpret_cast<const uint8_t *>(Buf.get())
+                            + ImageStart.getAddressData();
+      auto DataSegmentEnd = DataSegmentStart + DataSize;
+      dataSegments.push_back(std::make_tuple(RemoteAddress(DataSegmentStart),
+                                             RemoteAddress(DataSegmentEnd)));
+    }
+    
+    savedBuffers.push_back(std::move(Buf));
+
+    return true;
+  }
+#endif // defined(__APPLE__) && defined(__MACH__)
+  
   void addReflectionInfo(ReflectionInfo I) {
     getBuilder().addReflectionInfo(I);
   }
-
+  
+  bool ownsObject(RemoteAddress ObjectAddress) {
+    auto MetadataAddress = readMetadataFromInstance(ObjectAddress.getAddressData());
+    if (!MetadataAddress)
+      return 0;
+
+    for (auto Segment : dataSegments) {
+      auto Start = std::get<0>(Segment);
+      auto End = std::get<1>(Segment);
+      if (Start.getAddressData() <= *MetadataAddress
+          && *MetadataAddress < End.getAddressData())
+        return 1;
+    }
+  
+    return 0;
+  }
+  
   /// Return a description of the layout of a class instance with the given
   /// metadata as its isa pointer.
   const TypeInfo *getMetadataTypeInfo(StoredPointer MetadataAddress) {

include/swift/Reflection/TypeRefBuilder.h

@@ -57,6 +57,10 @@ class ReflectionSection {
   const void *startAddress() const {
     return Begin;
   }
+  
+  const void *endAddress() const {
+    return End;
+  }
 
   const_iterator begin() const {
     return const_iterator(Begin, End);
@@ -334,6 +338,10 @@ class TypeRefBuilder {
   void addReflectionInfo(ReflectionInfo I) {
     ReflectionInfos.push_back(I);
   }
+  
+  const std::vector<ReflectionInfo> &getReflectionInfos() {
+    return ReflectionInfos;
+  }
 
 private:
   std::vector<ReflectionInfo> ReflectionInfos;

include/swift/Remote/CMemoryReader.h

@@ -62,17 +62,26 @@ class CMemoryReader final : public MemoryReader {
     if (!length)
       return false;
 
-    auto buffer = std::unique_ptr<uint8_t>(new uint8_t[length + 1]);
-    if (!readBytes(address, buffer.get(), length + 1))
+    auto Buf = readBytes(address, length);
+    if (!Buf)
       return false;
-
-    dest = std::string(reinterpret_cast<const char *>(buffer.get()));
+    
+    dest = std::string(reinterpret_cast<const char *>(Buf.get()), length);
     return true;
   }
 
-  bool readBytes(RemoteAddress address, uint8_t *dest, uint64_t size) override {
-    return Impl.readBytes(Impl.reader_context,
-                          address.getAddressData(), dest, size) != 0;
+  ReadBytesResult readBytes(RemoteAddress address, uint64_t size) override {
+      void *FreeContext;
+      auto Ptr = Impl.readBytes(Impl.reader_context, address.getAddressData(), size,
+                                &FreeContext);
+
+      auto Free = Impl.free;
+      if (Free == nullptr)
+        return ReadBytesResult(Ptr, [](const void *) {});
+      
+      auto ReaderContext = Impl.reader_context;
+      auto freeLambda = [=](const void *Ptr) { Free(ReaderContext, Ptr, FreeContext); };
+      return ReadBytesResult(Ptr, freeLambda);
   }
 };
 

include/swift/Remote/InProcessMemoryReader.h

@@ -42,9 +42,8 @@ class InProcessMemoryReader final : public MemoryReader {
     return true;
   }
 
-  bool readBytes(RemoteAddress address, uint8_t *dest, uint64_t size) override {
-    std::memcpy(dest, address.getLocalPointer<void>(), (size_t) size);
-    return true;
+  ReadBytesResult readBytes(RemoteAddress address, uint64_t size) override {
+    return ReadBytesResult(address.getLocalPointer<void>(), [](const void *) {});
   }
 };
 

include/swift/Remote/MemoryReader.h

@@ -20,7 +20,11 @@
 
 #include "swift/Remote/RemoteAddress.h"
 
+#include <cstring>
+#include <functional>
+#include <memory>
 #include <string>
+#include <tuple>
 
 namespace swift {
 namespace remote {
@@ -31,6 +35,9 @@ namespace remote {
 /// representation of the address space of a remote process.
 class MemoryReader {
 public:
+  /// A convenient name for the return type from readBytes.
+  using ReadBytesResult = std::unique_ptr<const void, std::function<void(const void *)>>;
+
   /// Return the size of an ordinary pointer in the remote process, in bytes.
   virtual uint8_t getPointerSize() = 0;
 
@@ -40,19 +47,12 @@ class MemoryReader {
   /// Look up the given public symbol name in the remote process.
   virtual RemoteAddress getSymbolAddress(const std::string &name) = 0;
 
-  /// Attempts to read 'size' bytes from the given address in the
-  /// remote process.
-  ///
-  /// Returns false if the operation failed.
-  virtual bool readBytes(RemoteAddress address, uint8_t *dest,
-                         uint64_t size) = 0;
-
   /// Attempts to read a C string from the given address in the remote
   /// process.
   ///
   /// Returns false if the operation failed.
   virtual bool readString(RemoteAddress address, std::string &dest) = 0;
-
+  
   /// Attempts to read an integer from the given address in the remote
   /// process.
   ///
@@ -63,6 +63,42 @@ class MemoryReader {
                      sizeof(IntegerType));
   }
 
+  /// Attempts to read 'size' bytes from the given address in the remote process.
+  ///
+  /// Returns a pointer to the requested data and a function that must be called to
+  /// free that data when done. The pointer will be NULL if the operation failed.
+  ///
+  /// NOTE: subclasses MUST override at least one of the readBytes functions. The default
+  /// implementation calls through to the other one.
+  virtual ReadBytesResult
+    readBytes(RemoteAddress address, uint64_t size) {
+    auto *Buf = malloc(size);
+    ReadBytesResult Result(Buf, [](const void *ptr) {
+      free(const_cast<void *>(ptr));
+    });
+    bool success = readBytes(address, reinterpret_cast<uint8_t *>(Buf), size);
+    if (!success) {
+      Result.reset();
+    }
+    return Result;
+  }
+
+  /// Attempts to read 'size' bytes from the given address in the
+  /// remote process.
+  ///
+  /// Returns false if the operation failed.
+  ///
+  /// NOTE: subclasses MUST override at least one of the readBytes functions. The default
+  /// implementation calls through to the other one.
+  virtual bool readBytes(RemoteAddress address, uint8_t *dest, uint64_t size) {
+    auto Ptr = readBytes(address, size);
+    if (!Ptr)
+      return false;
+    
+    memcpy(dest, Ptr.get(), size);
+    return true;
+  }
+          
   virtual ~MemoryReader() = default;
 };
 

include/swift/SwiftRemoteMirror/MemoryReaderInterface.h

@@ -32,10 +32,13 @@ extern "C" {
 // in the system library, so we use 'swift_addr_t'.
 typedef uint64_t swift_addr_t;
 
+typedef void (*FreeBytesFunction)(void *reader_context, const void *bytes, void *context);
+
 typedef uint8_t (*PointerSizeFunction)(void *reader_context);
 typedef uint8_t (*SizeSizeFunction)(void *reader_context);
-typedef int (*ReadBytesFunction)(void *reader_context, swift_addr_t address,
-                                 void *dest, uint64_t size);
+typedef const void *(*ReadBytesFunction)(void *reader_context, swift_addr_t address,
+                                         uint64_t size,
+                                         void **outFreeContext);
 typedef uint64_t (*GetStringLengthFunction)(void *reader_context,
                                             swift_addr_t address);
 typedef swift_addr_t (*GetSymbolAddressFunction)(void *reader_context,
@@ -53,16 +56,22 @@ typedef struct MemoryReaderImpl {
   /// Get the size in bytes of the target's size type.
   SizeSizeFunction getSizeSize;
 
+  /// Free memory returned from readBytes. May be NULL if memory never needs to be freed.
+  FreeBytesFunction free;
+
   // FIXME: -Wdocumentation complains about \param and \returns on function pointers.
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
   /// Read a sequence of bytes at an address in the target.
   ///
   /// \param address the address in the target address space
-  /// \param dest the caller-owned buffer into which to store the string
   /// \param size the number of bytes to read
-  /// \returns true if the read was successful
+  /// \param outFreeContext on return, an arbitrary context pointer that the caller will
+  ///                       pass to the free function
+  /// \returns A pointer to the requested memory, or NULL if the memory could not be read.
+  ///          The caller must invoke the free function on the returned pointer once it's
+  ///          done using the memory.
   ReadBytesFunction readBytes;
 
   /// Get the string length at the given address.