[lldb] Fix LLDBMemoryReader resolving GOT pointers incorrectly

The DYLD shared cache, as an optimization, can merge GOT pointers from
multiple images into one location, and fix all relative offsets to point
to the new updated location.  When reading metadata, LLDB tries,
as an optimization, to read memory from local files instead of live
memory. This means that the relative offset will point to the old
location in the GOT section. In this case, LLDB needs to re-read the
offset from live memory, to get the correct offset in live memory.

rdar://160837587

Author: augusto2112

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

@@ -316,6 +316,150 @@ LLDBMemoryReader::resolvePointer(swift::remote::RemoteAddress address,
   return tagged_pointer;
 }
 
+swift::reflection::RemoteAddress
+LLDBMemoryReader::resolveIndirectAddressAtOffset(
+    swift::reflection::RemoteAddress address, uint64_t offset,
+    bool directnessEncodedInOffset) {
+  // Usually, simply adding the address with the offset will produce the correct
+  // remote address.
+  //
+  // However, on Apple platforms, the shared cache can coalesce pointers in the
+  // global offset table from multiple images into one location, patch all the
+  // uses to point to the new location, and zero out the original pointer. In
+  // this case, LLDBMemoryReader needs to be conservative and re-fetch the
+  // offset from live memory to ensure it points to the new, coalesced location
+  // instead.
+  Log *log = GetLog(LLDBLog::Types);
+
+  LLDB_LOGV(log,
+            "[MemoryReader::resolveAddressAtOffset] Asked to resolve address "
+            "{0:x} at offset {1:x}",
+            address.getRawAddress(), offset);
+
+  auto offset_address = address + offset;
+
+  if (!readMetadataFromFileCacheEnabled())
+    return offset_address;
+
+  // Addresses in the process don't apply.
+  if (offset_address.getAddressSpace() ==
+      swift::reflection::RemoteAddress::DefaultAddressSpace)
+    return offset_address;
+
+  // Check if offset_address points to a GOT entry.
+  std::optional<Address> maybeAddr =
+      resolveRemoteAddressFromSymbolObjectFile(offset_address);
+
+  if (!maybeAddr)
+    maybeAddr = remoteAddressToLLDBAddress(offset_address);
+
+  if (!maybeAddr) {
+    LLDB_LOGV(log,
+              "[MemoryReader::resolveAddressAtOffset] could not resolve "
+              "address {0:x}",
+              offset_address.getRawAddress());
+    return offset_address;
+  }
+
+  auto lldb_offset_address = *maybeAddr;
+  if (!lldb_offset_address.IsSectionOffset()) {
+    LLDB_LOGV(
+        log,
+        "[MemoryReader::resolveAddressAtOffset] lldb offset address has no "
+        "section {0:x}",
+        offset_address.getRawAddress());
+    return offset_address;
+  }
+
+  // This is only necessary on Apple platforms.
+  auto *obj_file = lldb_offset_address.GetModule()->GetObjectFile();
+  if (!obj_file || !obj_file->GetArchitecture().GetTriple().isAppleMachO())
+    return offset_address;
+
+  auto section = lldb_offset_address.GetSection();
+  auto segment = section->GetParent();
+  if (!segment) {
+    LLDB_LOGV(
+        log,
+        "[MemoryReader::resolveAddressAtOffset] lldb offset address has no "
+        "section {0:x}",
+        offset_address.getRawAddress());
+    return offset_address;
+  }
+
+  // The segment/section pair has to be:
+  //__DATA_CONST,__got, __AUTH_CONST,__auth_got or __AUTH_CONST,__auth_ptr.
+  bool is_data_const_got =
+      segment->GetName() == "__DATA_CONST" && section->GetName() == "__got";
+  bool is_auth_const_ptr = segment->GetName() == "__AUTH_CONST" &&
+                           (section->GetName() == "__auth_got" ||
+                            section->GetName() == "__auth_ptr");
+
+  if (!is_data_const_got && !is_auth_const_ptr)
+    return offset_address;
+
+  // offset_address is in a GOT section. Re-read the offset from the base
+  // address in live memory, since the offset in live memory can have been
+  // patched in the shared cache to point somewhere else.
+  std::optional<Address> maybe_lldb_addr =
+      resolveRemoteAddressFromSymbolObjectFile(address);
+
+  if (!maybe_lldb_addr)
+    maybe_lldb_addr = remoteAddressToLLDBAddress(address);
+
+  if (!maybe_lldb_addr) {
+    LLDB_LOGV(log,
+              "[MemoryReader::resolveAddressAtOffset] could not resolve offset "
+              "address {0:x}",
+              address.getRawAddress());
+    return offset_address;
+  }
+
+  auto lldb_addr = *maybe_lldb_addr;
+  Target &target(m_process.GetTarget());
+  Status error;
+  const bool force_live_memory = true;
+  bool did_read_live_memory = false;
+
+  // Relative offsets are always 4 bytes long, regardless of target.
+  uint32_t live_offset = 0;
+  auto size = sizeof(live_offset);
+  if (size !=
+      target.ReadMemory(lldb_addr, &live_offset, size, error, force_live_memory,
+                        /*load_addr_ptr=*/nullptr, &did_read_live_memory)) {
+    LLDB_LOG(log,
+             "[MemoryReader::resolveAddressAtOffset] Resolve address returned "
+             "different bytes than asked "
+             "for {0:x}",
+             lldb_addr.GetLoadAddress(&target));
+    return offset_address;
+  }
+  if (error.Fail()) {
+    LLDB_LOG(log,
+             "[MemoryReader::resolveAddressAtOffset] memory read returned "
+             "error: {0}",
+             error.AsCString());
+    return offset_address;
+  }
+  // Some Swift metadata encodes the directness directly into the offset,
+  // in that case clear the directness bit.
+  if (directnessEncodedInOffset)
+    live_offset &= ~1u;
+
+  // Now, get the live address counterpart of the lldb address this function
+  // started with, and add the live offset we just read to it.
+  auto live_address = lldb_addr.GetLoadAddress(&target);
+  LLDB_LOGV(
+      log,
+      "[MemoryReader::resolveAddressAtOffset] Succesfully resolved address "
+      "into live address {0:x} and offset {1:x} resulting in address {2:x}",
+      live_address, live_offset, live_address + live_offset);
+
+  return swift::remote::RemoteAddress(
+      live_address + live_offset,
+      swift::remote::RemoteAddress::DefaultAddressSpace);
+}
+
 bool LLDBMemoryReader::readBytes(swift::remote::RemoteAddress address,
                                  uint8_t *dest, uint64_t size) {
   auto read_bytes_result = readBytesImpl(address, dest, size);

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

@@ -87,6 +87,11 @@ class LLDBMemoryReader : public swift::remote::MemoryReader {
   std::optional<swift::remote::RemoteAddress>
   resolveRemoteAddress(swift::remote::RemoteAddress address) const override;
 
+  swift::reflection::RemoteAddress
+  resolveIndirectAddressAtOffset(swift::reflection::RemoteAddress address,
+                                 uint64_t offset,
+                                 bool directnessEncodedInOffset) override;
+
   bool readBytes(swift::remote::RemoteAddress address, uint8_t *dest,
                  uint64_t size) override;