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

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>
@@ -229,7 +231,8 @@ 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;
@@ -295,7 +298,8 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
   }
 
   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()
@@ -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() != 0)
+    return P;
+
+  auto ptrauth_mask = getPtrauthMask();
+  return P & ptrauth_mask;
+}
+
 MemoryReaderLocalBufferHolder::~MemoryReaderLocalBufferHolder() {
   if (m_memory_reader)
   m_memory_reader->popLocalBuffer();
@@ -540,7 +579,7 @@ LLDBMemoryReader::addModuleToAddressMap(ModuleSP module,
   if (module_end_address !=
       signedPointerStripper(
           swift::remote::RemoteAbsolutePointer{
-              swift::remote::RemoteAddress{module_end_address}})
+              swift::remote::RemoteAddress{module_end_address, 0}})
           .getResolvedAddress()
           .getAddressData()) {
     LLDB_LOG(GetLog(LLDBLog::Types),
@@ -620,7 +659,7 @@ LLDBMemoryReader::resolveRemoteAddress(
     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, 0);
   return {};
 }
 

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

@@ -51,8 +51,6 @@ class MemoryReaderLocalBufferHolder {
 
 class LLDBMemoryReader : public swift::remote::MemoryReader {
 public:
-
-
   LLDBMemoryReader(Process &p,
                    std::function<swift::remote::RemoteAbsolutePointer(
                        swift::remote::RemoteAbsolutePointer)>
@@ -86,6 +84,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 +123,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 +149,8 @@ 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;
 
+  uint64_t m_ptrauth_mask;
+
   /// 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);
 

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

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

@@ -1438,7 +1438,7 @@ llvm::Expected<std::string> SwiftLanguageRuntime::GetEnumCaseName(
 
   auto *eti = llvm::cast<EnumTypeInfo>(ti);
   auto buffer_holder = PushLocalBuffer((int64_t)data.GetDataStart(), data.GetByteSize());
-  RemoteAddress addr(data.GetDataStart());
+  RemoteAddress addr = RemoteAddress((uint64_t)data.GetDataStart(), 0);
   int case_index;
   if (eti->projectEnumValue(*GetMemoryReader(), addr, &case_index))
     return eti->getCases()[case_index].Name;
@@ -1551,7 +1551,7 @@ SwiftLanguageRuntime::ProjectEnum(ValueObject &valobj) {
     }
   }
 
-  swift::reflection::RemoteAddress remote_addr(addr);
+  auto remote_addr = swift::reflection::RemoteAddress(addr, 0);
   int case_index;
   auto *eti = llvm::cast<swift::reflection::EnumTypeInfo>(ti);
   if (!eti->projectEnumValue(*GetMemoryReader(), remote_addr, &case_index))
@@ -2292,7 +2292,8 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Existential(
           existential_address,
           llvm::expectedToOptional(in_value.GetByteSize()).value_or(0));
 
-    swift::remote::RemoteAddress remote_existential(existential_address);
+    auto remote_existential = swift::remote::RemoteAddress(
+        existential_address, swift::remote::RemoteAddress::DefaultAddressSpace);
 
     ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
     if (!reflection_ctx)
@@ -2317,7 +2318,7 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Existential(
       }
 
       const swift::reflection::TypeRef *typeref;
-      swift::remote::RemoteAddress out_address(nullptr);
+      swift::remote::RemoteAddress out_address;
       std::tie(typeref, out_address) = *pair;
 
       auto ts = tss->GetTypeSystemSwiftTypeRef();
@@ -2829,7 +2830,9 @@ Value::ValueType SwiftLanguageRuntime::GetValueType(
 
       // Read the value witness table and check if the data is inlined in
       // the existential container or not.
-      swift::remote::RemoteAddress remote_existential(existential_address);
+      auto remote_existential = swift::remote::RemoteAddress(
+          existential_address,
+          swift::remote::RemoteAddress::DefaultAddressSpace);
       if (ThreadSafeReflectionContext reflection_ctx = GetReflectionContext()) {
         std::optional<bool> is_inlined =
             reflection_ctx->IsValueInlinedInExistentialContainer(