[lldb] Try to map a real address to a tagged one in resolvePointer

If we read a real process address, try to map that back as a tagged
LLDBMLLDBMemoryReader address, so further reads originating from it
benefit from the file-cache optimization.

Author: augusto2112

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

@@ -160,6 +160,70 @@ LLDBMemoryReader::resolvePointerAsSymbol(swift::remote::RemoteAddress address) {
   return {};
 }
 
+swift::remote::RemoteAbsolutePointer
+LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
+                                 uint64_t readValue) {
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES));
+
+  // We may have gotten a pointer to a process address, try to map it back
+  // to a tagged address so further memory reads originating from it benefit
+  // from the file-cache optimization.
+  swift::remote::RemoteAbsolutePointer process_pointer("", readValue);
+
+  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());
+    return process_pointer;
+  }
+
+  auto module_containing_pointer = addr.GetSection()->GetModule();
+
+  // Check if the module containing the pointer is registered with
+  // LLDBMemoryReader.
+  auto pair_iterator = std::find_if(
+      m_range_module_map.begin(), m_range_module_map.end(), [&](auto pair) {
+        return std::get<ModuleSP>(pair) == module_containing_pointer;
+      });
+
+  // We haven't registered the image that contains the pointer.
+  if (pair_iterator == m_range_module_map.end()) {
+    LLDB_LOG(log,
+              "[MemoryReader] Could not resolve find module containing pointer "
+              "{0:x} read from {1:x}.",
+              readValue, address.getAddressData());
+    return process_pointer;
+  }
+
+  // If the containing image is the first registered one, the image's tagged
+  // start address for it is the first tagged address. Otherwise, the previous
+  // pair's address is the start tagged address.
+  uint64_t start_tagged_address = pair_iterator == m_range_module_map.begin()
+                                      ? LLDB_FILE_ADDRESS_BIT
+                                      : std::prev(pair_iterator)->first;
+
+  uint64_t tagged_address = start_tagged_address + addr.GetFileAddress();
+
+  if (tagged_address >= std::get<uint64_t>(*pair_iterator)) {
+    // If the tagged address invades the next image's tagged address space,
+    // something went wrong. Log it and just return the process 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);
+    return process_pointer;
+  }
+
+  LLDB_LOGV(log,
+            "[MemoryReader] Successfully resolved pointer {0:x} read from "
+            "{1:x} to tagged address {2:x}.",
+            readValue, address.getAddressData(), tagged_address);
+  return swift::remote::RemoteAbsolutePointer("", tagged_address);
+}
+
 bool LLDBMemoryReader::readBytes(swift::remote::RemoteAddress address,
                                  uint8_t *dest, uint64_t size) {
   if (m_local_buffer) {

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

@@ -26,6 +26,10 @@ class LLDBMemoryReader : public swift::remote::MemoryReader {
   llvm::Optional<swift::remote::RemoteAbsolutePointer>
   resolvePointerAsSymbol(swift::remote::RemoteAddress address) override;
 
+  swift::remote::RemoteAbsolutePointer
+  resolvePointer(swift::remote::RemoteAddress address,
+                 uint64_t readValue) override;
+
   bool readBytes(swift::remote::RemoteAddress address, uint8_t *dest,
                  uint64_t size) override;