[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

@@ -68,8 +68,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();
-    return addressData != (addressData & getPtrauthMask());
+    return address != (address & getPtrauthMask());
   }
 
 public:
@@ -88,7 +87,7 @@ 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) {
@@ -132,9 +131,13 @@ class CMemoryReader final : public MemoryReader {
     };
     return ReadBytesResult(Ptr, freeLambda);
   }
+  RemoteAddress stripSignedPointer(RemoteAddress P) override {
+    assert(P.getAddressSpace() == RemoteAddress::DefaultAddressSpace);
+    auto PtrAuthMask = getPtrauthMask();
+    return P & PtrAuthMask;
+  }
 };
-
-}
-}
+} // namespace remote
+} // namespace swift
 
 #endif

include/swift/Remote/InProcessMemoryReader.h

@@ -104,9 +104,18 @@ class InProcessMemoryReader final : public MemoryReader {
   ReadBytesResult readBytes(RemoteAddress address, uint64_t size) override {
     return ReadBytesResult(address.getLocalPointer<void>(), [](const void *) {});
   }
+
+  RemoteAddress stripSignedPointer(RemoteAddress P) override {
+    assert(P.getAddressSpace() == RemoteAddress::DefaultAddressSpace);
+    uintptr_t PtrAuthMask = 0;
+    if (!queryDataLayout(DataLayoutQueryType::DLQ_GetPtrAuthMask, nullptr,
+                         &PtrAuthMask))
+      return RemoteAddress();
+    return P & PtrAuthMask;
+  }
 };
- 
-}
-}
+
+} // namespace remote
+} // namespace swift
 
 #endif

include/swift/Remote/MemoryReader.h

@@ -57,17 +57,37 @@ 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.getAddressData());
+    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));
   }
 
+  virtual RemoteAddress stripSignedPointer(RemoteAddress P) = 0;
+
   /// Attempts to read an integer of the specified size from the given
   /// address in the remote process.  Following `storeEnumElement`
   /// in EnumImpl.h, this reads arbitrary-size integers by ignoring
@@ -147,7 +167,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.
@@ -263,7 +284,7 @@ class MemoryReader {
   virtual ~MemoryReader() = default;
 };
 
-} // end namespace reflection
+} // end namespace remote
 } // end namespace swift
 
 #endif // SWIFT_REFLECTION_READER_H