[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;
@@ -539,10 +543,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 +620,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)>
@@ -122,7 +121,6 @@ class LLDBMemoryReader : public swift::remote::MemoryReader {
   std::optional<Address>
   resolveRemoteAddressFromSymbolObjectFile(uint64_t address) const;
 
-private:
   Process &m_process;
   size_t m_max_read_amount;
 

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);
 

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

@@ -584,8 +584,11 @@ bool SwiftLanguageRuntime::AddJitObjectFileToReflectionContext(
 
             auto *Buf = malloc(size);
             std::memcpy(Buf, data.begin(), size);
-            swift::remote::RemoteRef<void> remote_ref(section->GetFileAddress(),
-                                                      Buf);
+            swift::remote::RemoteRef<void> remote_ref(
+                swift::remote::RemoteAddress(
+                    section->GetFileAddress(),
+                    swift::remote::RemoteAddress::DefaultAddressSpace),
+                Buf);
 
             return {remote_ref, size};
           }
@@ -723,7 +726,10 @@ std::optional<uint32_t> SwiftLanguageRuntime::AddObjectFileToReflectionContext(
                        section_list->GetSectionAtIndex(0)->GetFileAddress();
         assert(address <= end_address && "Address outside of range!");
 
-        swift::remote::RemoteRef<void> remote_ref(address, Buf);
+        swift::remote::RemoteRef<void> remote_ref(
+            swift::remote::RemoteAddress(
+                address, swift::remote::RemoteAddress::DefaultAddressSpace),
+            Buf);
         return {remote_ref, size};
       }
     }
@@ -794,18 +800,23 @@ bool SwiftLanguageRuntime::AddModuleToReflectionContext(
     const uint8_t *file_data = extractor.GetDataStart();
     llvm::sys::MemoryBlock file_buffer((void *)file_data, size);
     info_id = m_reflection_ctx->ReadELF(
-        swift::remote::RemoteAddress(load_ptr),
+        swift::remote::RemoteAddress(
+            load_ptr, swift::remote::RemoteAddress::DefaultAddressSpace),
         std::optional<llvm::sys::MemoryBlock>(file_buffer),
         likely_module_names);
   } else if (read_from_file_cache &&
              obj_file->GetPluginName() == "mach-o") {
     info_id = AddObjectFileToReflectionContext(module_sp, likely_module_names);
     if (!info_id)
-      info_id = m_reflection_ctx->AddImage(swift::remote::RemoteAddress(load_ptr),
-                                 likely_module_names);
+      info_id = m_reflection_ctx->AddImage(
+          swift::remote::RemoteAddress(
+              load_ptr, swift::remote::RemoteAddress::DefaultAddressSpace),
+          likely_module_names);
   } else {
-    info_id = m_reflection_ctx->AddImage(swift::remote::RemoteAddress(load_ptr),
-                               likely_module_names);
+    info_id = m_reflection_ctx->AddImage(
+        swift::remote::RemoteAddress(
+            load_ptr, swift::remote::RemoteAddress::DefaultAddressSpace),
+        likely_module_names);
   }
 
   if (!info_id) {