[NFC][RemoteInspection] Add an opaque AddressSpace field to RemoteAddress

Add an extra opaque field to AddressSpace, which can be used by clients
of RemoteInspection to distinguish between different address spaces.

LLDB employs an optimization where it reads memory from files instead of
the running process whenever it can to speed up memory reads (these can
be slow when debugging something over a network). To do this, it needs
to keep track whether an address originated from a process or a file. It
currently distinguishes addresses by setting an unused high bit on the
address, but because of pointer authentication this is not a reliable
solution. In order to keep this optimization working, this patch adds an
extra opaque AddressSpace field to RemoteAddress, which LLDB can use on
its own implementation of MemoryReader to distinguish between addresses.

This patch is NFC for the other RemoteInspection clients, as it adds
extra information to RemoteAddress, which is entirely optional and if
unused should not change the behavior of the library.

Although this patch is quite big the changes are largely mechanical,
replacing threading StoredPointer with RemoteAddress.

rdar://148361743

Author: augusto2112

include/swift/Basic/RelativePointer.h

@@ -132,7 +132,10 @@
 #ifndef SWIFT_BASIC_RELATIVEPOINTER_H
 #define SWIFT_BASIC_RELATIVEPOINTER_H
 
+#include <cassert>
 #include <cstdint>
+#include <type_traits>
+#include <utility>
 
 namespace swift {
 

include/swift/Remote/CMemoryReader.h

@@ -45,7 +45,7 @@ class CMemoryReader final : public MemoryReader {
   // Check to see if an address has bits outside the ptrauth mask. This suggests
   // that we're likely failing to strip a signed pointer when reading from it.
   bool hasSignatureBits(RemoteAddress address) {
-    uint64_t addressData = address.getAddressData();
+    uint64_t addressData = address.getRawAddress();
     uint64_t mask = getPtrAuthMask().value_or(~uint64_t(0));
     return addressData != (addressData & mask);
   }
@@ -66,13 +66,12 @@ class CMemoryReader final : public MemoryReader {
   RemoteAddress getSymbolAddress(const std::string &name) override {
     auto addressData = Impl.getSymbolAddress(Impl.reader_context,
                                              name.c_str(), name.size());
-    return RemoteAddress(addressData);
+    return RemoteAddress(addressData, RemoteAddress::DefaultAddressSpace);
   }
 
   uint64_t getStringLength(RemoteAddress address) {
     assert(!hasSignatureBits(address));
-    return Impl.getStringLength(Impl.reader_context,
-                                address.getAddressData());
+    return Impl.getStringLength(Impl.reader_context, address.getRawAddress());
   }
 
   bool readString(RemoteAddress address, std::string &dest) override {
@@ -97,7 +96,7 @@ class CMemoryReader final : public MemoryReader {
   ReadBytesResult readBytes(RemoteAddress address, uint64_t size) override {
     assert(!hasSignatureBits(address));
     void *FreeContext;
-    auto Ptr = Impl.readBytes(Impl.reader_context, address.getAddressData(),
+    auto Ptr = Impl.readBytes(Impl.reader_context, address.getRawAddress(),
                               size, &FreeContext);
 
     auto Free = Impl.free;
@@ -111,8 +110,7 @@ class CMemoryReader final : public MemoryReader {
     return ReadBytesResult(Ptr, freeLambda);
   }
 };
-
-}
-}
+} // namespace remote
+} // namespace swift
 
 #endif

include/swift/Remote/Failure.h

@@ -288,7 +288,7 @@ class Failure {
       case ArgStorageKind::Address: {
         result += '0';
         result += 'x';
-        uint64_t address = Args[argIndex].Address.getAddressData();
+        uint64_t address = Args[argIndex].Address.getRawAddress();
         unsigned max = ((address >> 32) != 0 ? 16 : 8);
         for (unsigned i = 0; i != max; ++i) {
           result += "0123456789abcdef"[(address >> (max - 1 - i) * 4) & 0xF];

include/swift/Remote/InProcessMemoryReader.h

@@ -105,8 +105,8 @@ class InProcessMemoryReader final : public MemoryReader {
     return ReadBytesResult(address.getLocalPointer<void>(), [](const void *) {});
   }
 };
- 
-}
-}
+
+} // namespace remote
+} // namespace swift
 
 #endif

include/swift/Remote/MemoryReader.h

@@ -128,13 +128,31 @@ class MemoryReader {
   ///
   /// Returns false if the operation failed.
   virtual bool readString(RemoteAddress address, std::string &dest) = 0;
-  
+
+  /// Attempts to read a remote address from the given address in the remote
+  /// process.
+  ///
+  /// Returns false if the operator failed.
+  template <typename IntegerType>
+  bool readRemoteAddress(RemoteAddress address, RemoteAddress &out) {
+    IntegerType buf;
+    if (!readInteger(address, &buf))
+      return false;
+
+    out = RemoteAddress((uint64_t)buf, address.getAddressSpace());
+    return true;
+  }
+
   /// Attempts to read an integer from the given address in the remote
   /// process.
   ///
   /// Returns false if the operation failed.
   template <typename IntegerType>
   bool readInteger(RemoteAddress address, IntegerType *dest) {
+    static_assert(!std::is_same<RemoteAddress, IntegerType>(),
+                  "RemoteAddress cannot be read in directly, use "
+                  "readRemoteAddress instead.");
+
     return readBytes(address, reinterpret_cast<uint8_t*>(dest),
                      sizeof(IntegerType));
   }
@@ -218,7 +236,8 @@ class MemoryReader {
   virtual RemoteAbsolutePointer resolvePointer(RemoteAddress address,
                                                uint64_t readValue) {
     // Default implementation returns the read value as is.
-    return RemoteAbsolutePointer(RemoteAddress(readValue));
+    return RemoteAbsolutePointer(
+        RemoteAddress(readValue, address.getAddressSpace()));
   }
 
   /// Performs the inverse operation of \ref resolvePointer.
@@ -321,7 +340,7 @@ class MemoryReader {
   virtual ~MemoryReader() = default;
 };
 
-} // end namespace reflection
+} // end namespace remote
 } // end namespace swift
 
 #endif // SWIFT_REFLECTION_READER_H