Remote Mirrors: Make MemoryReader a real class

Make the reader a class interface internally, with the
bag-of-function pointers via the eventual C API being the
special case.

Author: bitjammer

include/swift/Reflection/Reader.h

@@ -20,6 +20,7 @@
 
 #include "swift/SwiftReflection/MemoryReaderInterface.h"
 
+#include <dlfcn.h>
 #include <cstdint>
 #include <memory>
 #include <vector>
@@ -60,12 +61,52 @@ class ReflectionSection {
 };
 
 class MemoryReader {
+public:
+  virtual uint8_t getPointerSize() = 0;
+  virtual uint8_t getSizeSize() = 0;
+  virtual addr_t getSymbolAddress(const std::string &Name) = 0;
+  virtual std::string readString(addr_t Address) = 0;
+  virtual bool readBytes(addr_t Address, uint8_t *Dest, uint64_t Size) = 0;
+
+  template <typename IntegerType>
+  bool readInteger(addr_t Address, IntegerType *Dest) {
+    return readBytes(Address, (uint8_t*)Dest, sizeof(IntegerType));
+  }
+
+  virtual ~MemoryReader() = default;
+};
+
+class InProcessMemoryReader final : public MemoryReader {
+  uint8_t getPointerSize() override {
+    return sizeof(uintptr_t);
+  }
+
+  uint8_t getSizeSize() override {
+    return sizeof(size_t);
+  }
+
+  addr_t getSymbolAddress(const std::string &Name) override {
+    auto Symbol = dlsym(RTLD_DEFAULT, Name.c_str());
+    auto Pointer = reinterpret_cast<uintptr_t>(Symbol);
+    return static_cast<addr_t>(Pointer);
+  }
+
+  std::string readString(addr_t Address) override {
+    return std::string((char *)Address);
+  }
+
+  bool readBytes(addr_t Address, uint8_t *Dest, uint64_t Size) override {
+    return memmove(Dest, reinterpret_cast<const void *>(Address), Size);
+  }
+};
+
+class CMemoryReader final : public MemoryReader {
   std::unique_ptr<MemoryReaderImpl> Impl;
 
 public:
-  MemoryReader() : Impl(nullptr) {}
+  CMemoryReader() : Impl(nullptr) {}
 
-  MemoryReader(std::unique_ptr<MemoryReaderImpl> &&Impl)
+  CMemoryReader(std::unique_ptr<MemoryReaderImpl> &&Impl)
     : Impl(std::move(Impl)) {
       assert(this->Impl && "No Memory reader implementation given!");
       assert(this->Impl->getPointerSize && "No getPointerSize implementation");
@@ -75,32 +116,24 @@ class MemoryReader {
       assert(this->Impl->getPointerSize() != 0 && "Invalid target pointer size");
   }
 
-  uint8_t getPointerSize() {
+  uint8_t getPointerSize() override {
     return Impl->getPointerSize();
   }
 
-  template <typename IntegerType>
-  bool readInteger(addr_t Address, IntegerType *Dest,
-                   size_t Size = sizeof(IntegerType)) {
-    assert(sizeof(IntegerType) == Size);
-    uint64_t Temp;
-    if (Impl->readInteger(Address, &Temp, Size)) {
-      *Dest = (IntegerType)Temp;
-      return true;
-    }
-    return false;
-  }
-
-  addr_t getSymbolAddress(std::string Name) {
+  uint8_t getSizeSize() override {
+    return Impl->getSizeSize();
+  }
+
+  addr_t getSymbolAddress(const std::string &Name) override {
     auto Address = Impl->getSymbolAddress(Name.c_str(), Name.size());
     return static_cast<addr_t>(Address);
   }
 
-  size_t getStringLength(addr_t Address) {
+  uint64_t getStringLength(addr_t Address) {
     return Impl->getStringLength(Address);
   }
 
-  std::string readString(addr_t Address) {
+  std::string readString(addr_t Address) override {
     auto NameSize = getStringLength(Address);
     if (!NameSize)
       return "";
@@ -111,10 +144,9 @@ class MemoryReader {
     return std::string(reinterpret_cast<const char *>(NameBuffer.get()));
   }
 
-  bool readBytes(addr_t Address, uint8_t *Dest, uint64_t Size) {
+  bool readBytes(addr_t Address, uint8_t *Dest, uint64_t Size) override {
     return Impl->readBytes(Address, Dest, Size);
   }
-
 };
 
 } // end namespace reflection