[NFC][lldb] Adapt LLDB to RemoteInspection's RemoteAddress changes

Adapts LLDB to the new field in RemoteAddress. This is an NFC that
maintains the current behavior. A follow up patch will be introduced
later that takes advantage of the new behavior to fix a bug in reading
metadata from files instead of the process.

rdar://148361743

Author: augusto2112

lldb/source/Plugins/LanguageRuntime/Swift/LLDBMemoryReader.cpp

@@ -84,7 +84,7 @@ swift::remote::RemoteAddress
 LLDBMemoryReader::getSymbolAddress(const std::string &name) {
   lldbassert(!name.empty());
   if (name.empty())
-    return swift::remote::RemoteAddress(nullptr);
+    return swift::remote::RemoteAddress();
 
   Log *log = GetLog(LLDBLog::Types);
 
@@ -97,7 +97,7 @@ LLDBMemoryReader::getSymbolAddress(const std::string &name) {
       name_cs, lldb::eSymbolTypeAny, sc_list);
   if (!sc_list.GetSize()) {
     LLDB_LOGV(log, "[MemoryReader] symbol resolution failed {0}", name);
-    return swift::remote::RemoteAddress(nullptr);
+    return swift::remote::RemoteAddress();
   }
 
   SymbolContext sym_ctx;
@@ -118,14 +118,15 @@ LLDBMemoryReader::getSymbolAddress(const std::string &name) {
     if (sym_ctx.symbol) {
       auto load_addr = sym_ctx.symbol->GetLoadAddress(&m_process.GetTarget());
       LLDB_LOGV(log, "[MemoryReader] symbol resolved to {0:x}", load_addr);
-      return swift::remote::RemoteAddress(load_addr);
+      return swift::remote::RemoteAddress(
+          load_addr, swift::remote::RemoteAddress::DefaultAddressSpace);
     }
   }
 
   // Empty list, resolution failed.
   if (sc_list.GetSize() == 0) {
     LLDB_LOGV(log, "[MemoryReader] symbol resolution failed {0}", name);
-    return swift::remote::RemoteAddress(nullptr);
+    return swift::remote::RemoteAddress();
   }
 
   // If there's a single symbol, then we're golden. If there's more than
@@ -140,11 +141,12 @@ LLDBMemoryReader::getSymbolAddress(const std::string &name) {
             load_addr, m_process.GetAddressByteSize(), 0, error, true);
     if (sym_value != other_sym_value) {
       LLDB_LOGV(log, "[MemoryReader] symbol resolution failed {0}", name);
-      return swift::remote::RemoteAddress(nullptr);
+      return swift::remote::RemoteAddress();
     }
   }
   LLDB_LOGV(log, "[MemoryReader] symbol resolved to {0}", load_addr);
-  return swift::remote::RemoteAddress(load_addr);
+  return swift::remote::RemoteAddress(
+      load_addr, swift::remote::RemoteAddress::DefaultAddressSpace);
 }
 
 static std::unique_ptr<swift::SwiftObjectFileFormat>
@@ -180,7 +182,7 @@ LLDBMemoryReader::resolvePointerAsSymbol(swift::remote::RemoteAddress address) {
     return {};
 
   std::optional<Address> maybeAddr =
-      resolveRemoteAddress(address.getAddressData());
+      resolveRemoteAddress(address.getRawAddress());
   // This is not an assert, but should never happen.
   if (!maybeAddr)
     return {};
@@ -191,7 +193,7 @@ LLDBMemoryReader::resolvePointerAsSymbol(swift::remote::RemoteAddress address) {
     addr = *maybeAddr;
   } else {
     // `address` is a real load address.
-    if (!target.ResolveLoadAddress(address.getAddressData(), addr))
+    if (!target.ResolveLoadAddress(address.getRawAddress(), addr))
       return {};
   }
 
@@ -229,23 +231,24 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
   // to a tagged address so further memory reads originating from it benefit
   // from the file-cache optimization.
   swift::remote::RemoteAbsolutePointer process_pointer{
-      swift::remote::RemoteAddress{readValue}};
+      swift::remote::RemoteAddress{
+          readValue, swift::remote::RemoteAddress::DefaultAddressSpace}};
 
   if (!readMetadataFromFileCacheEnabled())
     return process_pointer;
 
   // Try to strip the pointer before checking if we have it mapped.
   auto strippedPointer = signedPointerStripper(process_pointer);
   if (auto resolved = strippedPointer.getResolvedAddress())
-    readValue = resolved.getAddressData();
+    readValue = resolved.getRawAddress();
 
   auto &target = m_process.GetTarget();
   Address addr;
   if (!target.ResolveLoadAddress(readValue, addr)) {
     LLDB_LOGV(log,
               "[MemoryReader] Could not resolve load address of pointer {0:x} "
               "read from {1:x}.",
-              readValue, address.getAddressData());
+              readValue, address.getRawAddress());
     return process_pointer;
   }
 
@@ -263,7 +266,7 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
     LLDB_LOG(log,
              "[MemoryReader] Could not resolve find module containing pointer "
              "{0:x} read from {1:x}.",
-             readValue, address.getAddressData());
+             readValue, address.getRawAddress());
     return process_pointer;
   }
 
@@ -290,16 +293,17 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
     LLDB_LOG(log,
              "[MemoryReader] Pointer {0:x} read from {1:x} resolved to tagged "
              "address {2:x}, which is outside its image address space.",
-             readValue, address.getAddressData(), tagged_address);
+             readValue, address.getRawAddress(), tagged_address);
     return process_pointer;
   }
 
   swift::remote::RemoteAbsolutePointer tagged_pointer{
-      swift::remote::RemoteAddress{tagged_address}};
+      swift::remote::RemoteAddress{
+          tagged_address, swift::remote::RemoteAddress::DefaultAddressSpace}};
 
   if (tagged_address != (uint64_t)signedPointerStripper(tagged_pointer)
                             .getResolvedAddress()
-                            .getAddressData()) {
+                            .getRawAddress()) {
     lldbassert(false &&
                "Tagged pointer runs into pointer authentication mask!");
     return process_pointer;
@@ -308,7 +312,7 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
   LLDB_LOGV(log,
             "[MemoryReader] Successfully resolved pointer {0:x} read from "
             "{1:x} to tagged address {2:x}.",
-            readValue, address.getAddressData(), tagged_address);
+            readValue, address.getRawAddress(), tagged_address);
   return tagged_pointer;
 }
 
@@ -317,7 +321,7 @@ bool LLDBMemoryReader::readBytes(swift::remote::RemoteAddress address,
   Log *log = GetLog(LLDBLog::Types);
   if (m_local_buffer) {
     bool overflow = false;
-    auto addr = address.getAddressData();
+    auto addr = address.getRawAddress();
     auto end = llvm::SaturatingAdd(addr, size, &overflow);
     if (overflow) {
       LLDB_LOGV(log, "[MemoryReader] address {0:x} + size {1} overflows", addr,
@@ -335,16 +339,16 @@ bool LLDBMemoryReader::readBytes(swift::remote::RemoteAddress address,
   }
 
   LLDB_LOGV(log, "[MemoryReader] asked to read {0} bytes at address {1:x}",
-            size, address.getAddressData());
+            size, address.getRawAddress());
   std::optional<Address> maybeAddr =
-      resolveRemoteAddressFromSymbolObjectFile(address.getAddressData());
+      resolveRemoteAddressFromSymbolObjectFile(address.getRawAddress());
 
   if (!maybeAddr)
-    maybeAddr = resolveRemoteAddress(address.getAddressData());
+    maybeAddr = resolveRemoteAddress(address.getRawAddress());
 
   if (!maybeAddr) {
     LLDB_LOGV(log, "[MemoryReader] could not resolve address {0:x}",
-              address.getAddressData());
+              address.getRawAddress());
     return false;
   }
   auto addr = *maybeAddr;
@@ -411,17 +415,17 @@ bool LLDBMemoryReader::readString(swift::remote::RemoteAddress address,
     return std::string(stream.GetData());
   };
   LLDB_LOGV(log, "[MemoryReader] asked to read string data at address {0:x}",
-            address.getAddressData());
+            address.getRawAddress());
 
   std::optional<Address> maybeAddr =
-      resolveRemoteAddressFromSymbolObjectFile(address.getAddressData());
+      resolveRemoteAddressFromSymbolObjectFile(address.getRawAddress());
 
   if (!maybeAddr)
-    maybeAddr = resolveRemoteAddress(address.getAddressData());
+    maybeAddr = resolveRemoteAddress(address.getRawAddress());
 
   if (!maybeAddr) {
     LLDB_LOGV(log, "[MemoryReader] could not resolve address {0:x}",
-              address.getAddressData());
+              address.getRawAddress());
     return false;
   }
   auto addr = *maybeAddr;
@@ -455,6 +459,41 @@ bool LLDBMemoryReader::readString(swift::remote::RemoteAddress address,
   return false;
 }
 
+uint64_t LLDBMemoryReader::getPtrauthMask() {
+  auto initializePtrauthMask = [&]() -> uint64_t {
+    uint8_t pointerSize = 0;
+    if (!queryDataLayout(DataLayoutQueryType::DLQ_GetPointerSize, nullptr,
+                         &pointerSize))
+      return ~0ull;
+
+    if (pointerSize == 4) {
+      uint32_t ptrauthMask32 = 0;
+      if (queryDataLayout(DataLayoutQueryType::DLQ_GetPtrAuthMask, nullptr,
+                          &ptrauthMask32))
+        return (uint64_t)ptrauthMask32;
+    } else if (pointerSize == 8) {
+      uint64_t ptrauthMask64 = 0;
+      if (queryDataLayout(DataLayoutQueryType::DLQ_GetPtrAuthMask, nullptr,
+                          &ptrauthMask64))
+        return ptrauthMask64;
+    }
+    return ~0ull;
+  };
+  if (!m_ptrauth_mask)
+    m_ptrauth_mask = initializePtrauthMask();
+  return m_ptrauth_mask;
+}
+
+swift::reflection::RemoteAddress
+LLDBMemoryReader::stripSignedPointer(swift::reflection::RemoteAddress P) {
+  // Only virtual addresses are signed.
+  if (P.getAddressSpace() != swift::reflection::RemoteAddress::DefaultAddressSpace)
+    return P;
+
+  auto ptrauth_mask = getPtrauthMask();
+  return P & ptrauth_mask;
+}
+
 MemoryReaderLocalBufferHolder::~MemoryReaderLocalBufferHolder() {
   if (m_memory_reader)
   m_memory_reader->popLocalBuffer();
@@ -539,10 +578,11 @@ LLDBMemoryReader::addModuleToAddressMap(ModuleSP module,
 
   if (module_end_address !=
       signedPointerStripper(
-          swift::remote::RemoteAbsolutePointer{
-              swift::remote::RemoteAddress{module_end_address}})
+          swift::remote::RemoteAbsolutePointer{swift::remote::RemoteAddress{
+              module_end_address,
+              swift::reflection::RemoteAddress::DefaultAddressSpace}})
           .getResolvedAddress()
-          .getAddressData()) {
+          .getRawAddress()) {
     LLDB_LOG(GetLog(LLDBLog::Types),
              "[MemoryReader] module to address map ran into pointer "
              "authentication mask!");
@@ -615,12 +655,12 @@ std::optional<swift::reflection::RemoteAddress>
 LLDBMemoryReader::resolveRemoteAddress(
     swift::reflection::RemoteAddress address) const {
   std::optional<Address> lldb_address =
-      LLDBMemoryReader::resolveRemoteAddress(address.getAddressData());
+      LLDBMemoryReader::resolveRemoteAddress(address.getRawAddress());
   if (!lldb_address)
     return {};
   lldb::addr_t addr = lldb_address->GetLoadAddress(&m_process.GetTarget());
   if (addr != LLDB_INVALID_ADDRESS)
-    return swift::reflection::RemoteAddress(addr);
+    return swift::reflection::RemoteAddress(addr, swift::reflection::RemoteAddress::DefaultAddressSpace);
   return {};
 }
 

lldb/source/Plugins/LanguageRuntime/Swift/LLDBMemoryReader.h

@@ -52,7 +52,6 @@ class MemoryReaderLocalBufferHolder {
 class LLDBMemoryReader : public swift::remote::MemoryReader {
 public:
 
-
   LLDBMemoryReader(Process &p,
                    std::function<swift::remote::RemoteAbsolutePointer(
                        swift::remote::RemoteAbsolutePointer)>
@@ -86,6 +85,9 @@ class LLDBMemoryReader : public swift::remote::MemoryReader {
   bool readString(swift::remote::RemoteAddress address,
                   std::string &dest) override;
 
+  swift::reflection::RemoteAddress
+  stripSignedPointer(swift::reflection::RemoteAddress P) override;
+
   MemoryReaderLocalBufferHolder pushLocalBuffer(uint64_t local_buffer, uint64_t local_buffer_size);
 
   /// Adds the module to the list of modules we're tracking using tagged
@@ -122,7 +124,8 @@ class LLDBMemoryReader : public swift::remote::MemoryReader {
   std::optional<Address>
   resolveRemoteAddressFromSymbolObjectFile(uint64_t address) const;
 
-private:
+  uint64_t getPtrauthMask();
+
   Process &m_process;
   size_t m_max_read_amount;
 
@@ -147,6 +150,9 @@ class LLDBMemoryReader : public swift::remote::MemoryReader {
   /// object file instead of the main object file.
   llvm::SmallSet<lldb::ModuleSP, 8> m_modules_with_metadata_in_symbol_obj_file;
 
+  /// The pointer authentication mask.
+  uint64_t m_ptrauth_mask = 0;
+
   /// The bit used to tag LLDB's virtual addresses as such. See \c
   /// m_range_module_map.
   const static uint64_t LLDB_FILE_ADDRESS_BIT = 0x2000000000000000;

lldb/source/Plugins/LanguageRuntime/Swift/ReflectionContext.cpp

@@ -223,7 +223,10 @@ class TargetReflectionContext : public ReflectionContextInterface {
       lldb::addr_t instance, swift::remote::TypeInfoProvider *provider,
       swift::reflection::DescriptorFinder *descriptor_finder) override {
     auto on_exit = PushDescriptorFinderAndPopOnExit(descriptor_finder);
-    auto *ti = m_reflection_ctx.getInstanceTypeInfo(instance, provider);
+    auto *ti = m_reflection_ctx.getInstanceTypeInfo(
+        swift::remote::RemoteAddress(
+            instance, swift::remote::RemoteAddress::DefaultAddressSpace),
+        provider);
     if (!ti)
       return llvm::createStringError("could not get instance type info");
     return *ti;
@@ -273,7 +276,9 @@ class TargetReflectionContext : public ReflectionContextInterface {
     auto on_exit = PushDescriptorFinderAndPopOnExit(descriptor_finder);
     // Guard against faulty self-referential metadata.
     unsigned limit = 256;
-    auto md_ptr = m_reflection_ctx.readMetadataFromInstance(pointer);
+    auto md_ptr =
+        m_reflection_ctx.readMetadataFromInstance(swift::remote::RemoteAddress(
+            pointer, swift::remote::RemoteAddress::DefaultAddressSpace));
     if (!md_ptr)
       return false;
 
@@ -345,7 +350,10 @@ class TargetReflectionContext : public ReflectionContextInterface {
                        bool skip_artificial_subclasses) override {
     auto on_exit = PushDescriptorFinderAndPopOnExit(descriptor_finder);
     if (auto *tr = m_reflection_ctx.readTypeFromMetadata(
-            metadata_address, skip_artificial_subclasses))
+            swift::remote::RemoteAddress(
+                metadata_address,
+                swift::remote::RemoteAddress::DefaultAddressSpace),
+            skip_artificial_subclasses))
       return *tr;
     return llvm::createStringError("could not read type from metadata");
   }
@@ -356,7 +364,9 @@ class TargetReflectionContext : public ReflectionContextInterface {
                        bool skip_artificial_subclasses) override {
     auto on_exit = PushDescriptorFinderAndPopOnExit(descriptor_finder);
     auto metadata_address =
-        m_reflection_ctx.readMetadataFromInstance(instance_address);
+        m_reflection_ctx.readMetadataFromInstance(swift::remote::RemoteAddress(
+            instance_address,
+            swift::remote::RemoteAddress::DefaultAddressSpace));
     if (!metadata_address)
       return llvm::createStringError(
           llvm::formatv("could not read heap metadata for object at {0:x}",
@@ -370,7 +380,8 @@ class TargetReflectionContext : public ReflectionContextInterface {
 
   std::optional<swift::remote::RemoteAbsolutePointer>
   ReadPointer(lldb::addr_t instance_address) override {
-    auto ptr = m_reflection_ctx.readPointer(instance_address);
+    auto ptr = m_reflection_ctx.readPointer(swift::remote::RemoteAddress(
+        instance_address, swift::remote::RemoteAddress::DefaultAddressSpace));
     return ptr;
   }
 
@@ -399,7 +410,9 @@ class TargetReflectionContext : public ReflectionContextInterface {
   asyncTaskInfo(lldb::addr_t AsyncTaskPtr, unsigned ChildTaskLimit,
                 unsigned AsyncBacktraceLimit) override {
     auto [error, task_info] = m_reflection_ctx.asyncTaskInfo(
-        AsyncTaskPtr, ChildTaskLimit, AsyncBacktraceLimit);
+        swift::remote::RemoteAddress(
+            AsyncTaskPtr, swift::remote::RemoteAddress::DefaultAddressSpace),
+        ChildTaskLimit, AsyncBacktraceLimit);
     if (error)
       return llvm::createStringError(*error);