Merge pull request #7243 from jasonmolenda/cp/qhostinfo-lcnote-multiple-address-bits-plus-uuid-in-lowmemory-corefile-1013-3

Cp/qhostinfo lcnote multiple address bits plus UUID in lowmemory corefile 1013 3

Author: jasonmolenda

lldb/docs/lldb-gdb-remote.txt

@@ -978,6 +978,14 @@ addressing_bits: optional, specifies how many bits in addresses are
 		 v8.3 ABIs that use pointer authentication, so lldb
 		 knows which bits to clear/set to get the actual
 		 addresses.
+low_mem_addressing_bits: optional, specifies how many bits in 
+     addresses in low memory are significant for addressing, base 10.  
+     AArch64 can have different page table setups for low and high
+     memory, and therefore a different number of bits used for addressing.
+high_mem_addressing_bits: optional, specifies how many bits in 
+     addresses in high memory are significant for addressing, base 10.  
+     AArch64 can have different page table setups for low and high
+     memory, and therefore a different number of bits used for addressing.
 
 //----------------------------------------------------------------------
 // "qGDBServerVersion"

lldb/include/lldb/Symbol/ObjectFile.h

@@ -14,6 +14,7 @@
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/UnwindTable.h"
+#include "lldb/Utility/AddressableBits.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
@@ -517,13 +518,18 @@ class ObjectFile : public std::enable_shared_from_this<ObjectFile>,
 
   /// Some object files may have the number of bits used for addressing
   /// embedded in them, e.g. a Mach-O core file using an LC_NOTE.  These
-  /// object files can return the address mask that should be used in
-  /// the Process.
+  /// object files can return an AddressableBits object that can can be
+  /// used to set the address masks in the Process.
+  ///
+  /// \param[out] address_bits
+  ///     Can be used to set the Process address masks.
+  ///
   /// \return
-  ///     The mask will have bits set which aren't used for addressing --
-  ///     typically, the high bits.
-  ///     Zero is returned when no address bits mask is available.
-  virtual lldb::addr_t GetAddressMask() { return 0; }
+  ///     Returns true if addressable bits metadata was found.
+  virtual bool GetAddressableBits(lldb_private::AddressableBits &address_bits) {
+    address_bits.Clear();
+    return false;
+  }
 
   /// When the ObjectFile is a core file, lldb needs to locate the "binary" in
   /// the core file.  lldb can iterate over the pages looking for a valid

lldb/include/lldb/Utility/AddressableBits.h

@@ -0,0 +1,43 @@
+//===-- AddressableBits.h ---------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_ADDRESSABLEBITS_H
+#define LLDB_UTILITY_ADDRESSABLEBITS_H
+
+#include "lldb/lldb-forward.h"
+
+namespace lldb_private {
+
+/// \class AddressableBits AddressableBits.h "lldb/Core/AddressableBits.h"
+/// A class which holds the metadata from a remote stub/corefile note
+/// about how many bits are used for addressing on this target.
+///
+class AddressableBits {
+public:
+  AddressableBits() : m_low_memory_addr_bits(0), m_high_memory_addr_bits(0) {}
+
+  /// When a single value is available for the number of bits.
+  void SetAddressableBits(uint32_t addressing_bits);
+
+  /// When we have separate values for low memory addresses and high memory
+  /// addresses.
+  void SetAddressableBits(uint32_t lowmem_addressing_bits,
+                          uint32_t highmem_addressing_bits);
+
+  void SetProcessMasks(lldb_private::Process &process);
+
+  void Clear();
+
+private:
+  uint32_t m_low_memory_addr_bits;
+  uint32_t m_high_memory_addr_bits;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_UTILITY_ADDRESSABLEBITS_H

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

@@ -5533,8 +5533,9 @@ std::string ObjectFileMachO::GetIdentifierString() {
   return result;
 }
 
-addr_t ObjectFileMachO::GetAddressMask() {
-  addr_t mask = 0;
+bool ObjectFileMachO::GetAddressableBits(AddressableBits &address_bits) {
+  address_bits.Clear();
+
   Log *log(GetLog(LLDBLog::Process));
   ModuleSP module_sp(GetModule());
   if (module_sp) {
@@ -5561,21 +5562,32 @@ addr_t ObjectFileMachO::GetAddressMask() {
             if (version == 3) {
               uint32_t num_addr_bits = m_data.GetU32_unchecked(&offset);
               if (num_addr_bits != 0) {
-                mask = ~((1ULL << num_addr_bits) - 1);
+                address_bits.SetAddressableBits(num_addr_bits);
               }
               LLDB_LOGF(log,
-                        "LC_NOTE 'addrable bits' found, value %d bits, "
-                        "mask 0x%" PRIx64,
-                        num_addr_bits, mask);
-              break;
+                        "LC_NOTE 'addrable bits' v3 found, value %d "
+                        "bits",
+                        num_addr_bits);
+              return true;
+            }
+            if (version == 4) {
+              uint32_t lo_addr_bits = m_data.GetU32_unchecked(&offset);
+              uint32_t hi_addr_bits = m_data.GetU32_unchecked(&offset);
+
+              address_bits.SetAddressableBits(lo_addr_bits, hi_addr_bits);
+              LLDB_LOGF(log,
+                        "LC_NOTE 'addrable bits' v4 found, value %d & %d bits",
+                        lo_addr_bits, hi_addr_bits);
+
+              return true;
             }
           }
         }
       }
       offset = cmd_offset + lc.cmdsize;
     }
   }
-  return mask;
+  return false;
 }
 
 bool ObjectFileMachO::GetCorefileMainBinaryInfo(addr_t &value,
@@ -6783,10 +6795,12 @@ bool ObjectFileMachO::SaveCore(const lldb::ProcessSP &process_sp,
           addrable_bits_lcnote_up->name = "addrable bits";
           addrable_bits_lcnote_up->payload_file_offset = file_offset;
           int bits = std::bitset<64>(~address_mask).count();
-          addrable_bits_lcnote_up->payload.PutHex32(3); // version
+          addrable_bits_lcnote_up->payload.PutHex32(4); // version
+          addrable_bits_lcnote_up->payload.PutHex32(
+              bits); // # of bits used for low addresses
           addrable_bits_lcnote_up->payload.PutHex32(
-              bits); // # of bits used for addressing
-          addrable_bits_lcnote_up->payload.PutHex64(0); // unused
+              bits); // # of bits used for high addresses
+          addrable_bits_lcnote_up->payload.PutHex32(0); // reserved
 
           file_offset += addrable_bits_lcnote_up->payload.GetSize();
 

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

@@ -121,7 +121,7 @@ class ObjectFileMachO : public lldb_private::ObjectFile {
 
   std::string GetIdentifierString() override;
 
-  lldb::addr_t GetAddressMask() override;
+  bool GetAddressableBits(lldb_private::AddressableBits &address_bits) override;
 
   bool GetCorefileMainBinaryInfo(lldb::addr_t &value, bool &value_is_offset,
                                  lldb_private::UUID &uuid,

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

@@ -1260,7 +1260,15 @@ bool GDBRemoteCommunicationClient::GetHostInfo(bool force) {
             if (!value.getAsInteger(0, pointer_byte_size))
               ++num_keys_decoded;
           } else if (name.equals("addressing_bits")) {
-            if (!value.getAsInteger(0, m_addressing_bits))
+            if (!value.getAsInteger(0, m_low_mem_addressing_bits)) {
+              m_high_mem_addressing_bits = m_low_mem_addressing_bits;
+              ++num_keys_decoded;
+            }
+          } else if (name.equals("high_mem_addressing_bits")) {
+            if (!value.getAsInteger(0, m_high_mem_addressing_bits))
+              ++num_keys_decoded;
+          } else if (name.equals("low_mem_addressing_bits")) {
+            if (!value.getAsInteger(0, m_low_mem_addressing_bits))
               ++num_keys_decoded;
           } else if (name.equals("os_version") ||
                      name.equals("version")) // Older debugserver binaries used
@@ -1404,11 +1412,19 @@ GDBRemoteCommunicationClient::GetHostArchitecture() {
   return m_host_arch;
 }
 
-uint32_t GDBRemoteCommunicationClient::GetAddressingBits() {
+bool GDBRemoteCommunicationClient::GetAddressableBits(
+    lldb_private::AddressableBits &addressable_bits) {
+  addressable_bits.Clear();
   if (m_qHostInfo_is_valid == eLazyBoolCalculate)
     GetHostInfo();
-  return m_addressing_bits;
+  if (m_low_mem_addressing_bits != 0 || m_high_mem_addressing_bits != 0) {
+    addressable_bits.SetAddressableBits(m_low_mem_addressing_bits,
+                                        m_high_mem_addressing_bits);
+    return true;
+  }
+  return false;
 }
+
 seconds GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout() {
   if (m_qHostInfo_is_valid == eLazyBoolCalculate)
     GetHostInfo();

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "lldb/Host/File.h"
+#include "lldb/Utility/AddressableBits.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/GDBRemote.h"
 #include "lldb/Utility/ProcessInfo.h"
@@ -237,7 +238,7 @@ class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
 
   ArchSpec GetSystemArchitecture();
 
-  uint32_t GetAddressingBits();
+  bool GetAddressableBits(lldb_private::AddressableBits &addressable_bits);
 
   bool GetHostname(std::string &s);
 
@@ -580,7 +581,8 @@ class GDBRemoteCommunicationClient : public GDBRemoteClientBase {
   lldb::tid_t m_curr_tid_run = LLDB_INVALID_THREAD_ID;
 
   uint32_t m_num_supported_hardware_watchpoints = 0;
-  uint32_t m_addressing_bits = 0;
+  uint32_t m_low_mem_addressing_bits = 0;
+  uint32_t m_high_mem_addressing_bits = 0;
 
   ArchSpec m_host_arch;
   ArchSpec m_process_arch;

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

@@ -892,10 +892,9 @@ void ProcessGDBRemote::DidLaunchOrAttach(ArchSpec &process_arch) {
              process_arch.GetTriple().getTriple());
   }
 
-  if (int addressable_bits = m_gdb_comm.GetAddressingBits()) {
-    lldb::addr_t address_mask = ~((1ULL << addressable_bits) - 1);
-    SetCodeAddressMask(address_mask);
-    SetDataAddressMask(address_mask);
+  AddressableBits addressable_bits;
+  if (m_gdb_comm.GetAddressableBits(addressable_bits)) {
+    addressable_bits.SetProcessMasks(*this);
   }
 
   if (process_arch.IsValid()) {

lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

@@ -28,10 +28,12 @@
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
+#include "lldb/Utility/UUID.h"
 
 #include "ProcessMachCore.h"
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "ThreadMachCore.h"
+#include "Utility/UuidCompatibility.h"
 
 // Needed for the plug-in names for the dynamic loaders.
 #include "lldb/Host/SafeMachO.h"
@@ -223,6 +225,66 @@ void ProcessMachCore::CreateMemoryRegions() {
   }
 }
 
+// Some corefiles have a UUID stored in a low memory
+// address.  We inspect a set list of addresses for
+// the characters 'uuid' and 16 bytes later there will
+// be a uuid_t UUID.  If we can find a binary that
+// matches the UUID, it is loaded with no slide in the target.
+bool ProcessMachCore::LoadBinaryViaLowmemUUID() {
+  Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
+  ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
+
+  uint64_t lowmem_uuid_addresses[] = {0x2000204, 0x1000204, 0x1000020, 0x4204,
+                                      0x1204,    0x1020,    0x4020,    0xc00,
+                                      0xC0,      0};
+
+  for (uint64_t addr : lowmem_uuid_addresses) {
+    const VMRangeToFileOffset::Entry *core_memory_entry =
+        m_core_aranges.FindEntryThatContains(addr);
+    if (core_memory_entry) {
+      const addr_t offset = addr - core_memory_entry->GetRangeBase();
+      const addr_t bytes_left = core_memory_entry->GetRangeEnd() - addr;
+      // (4-bytes 'uuid' + 12 bytes pad for align + 16 bytes uuid_t) == 32 bytes
+      if (bytes_left >= 32) {
+        char strbuf[4];
+        if (core_objfile->CopyData(
+                core_memory_entry->data.GetRangeBase() + offset, 4, &strbuf) &&
+            strncmp("uuid", (char *)&strbuf, 4) == 0) {
+          uuid_t uuid_bytes;
+          if (core_objfile->CopyData(core_memory_entry->data.GetRangeBase() +
+                                         offset + 16,
+                                     sizeof(uuid_t), uuid_bytes)) {
+            UUID uuid(uuid_bytes, sizeof(uuid_t));
+            if (uuid.IsValid()) {
+              LLDB_LOGF(log,
+                        "ProcessMachCore::LoadBinaryViaLowmemUUID: found "
+                        "binary uuid %s at low memory address 0x%" PRIx64,
+                        uuid.GetAsString().c_str(), addr);
+              // We have no address specified, only a UUID.  Load it at the file
+              // address.
+              const bool value_is_offset = true;
+              const bool force_symbol_search = true;
+              const bool notify = true;
+              const bool set_address_in_target = true;
+              const bool allow_memory_image_last_resort = false;
+              if (DynamicLoader::LoadBinaryWithUUIDAndAddress(
+                      this, llvm::StringRef(), uuid, 0, value_is_offset,
+                      force_symbol_search, notify, set_address_in_target,
+                      allow_memory_image_last_resort)) {
+                m_dyld_plugin_name = DynamicLoaderStatic::GetPluginNameStatic();
+              }
+              // We found metadata saying which binary should be loaded; don't
+              // try an exhaustive search.
+              return true;
+            }
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+
 bool ProcessMachCore::LoadBinariesViaMetadata() {
   Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
   ObjectFile *core_objfile = m_core_module_sp->GetObjectFile();
@@ -338,6 +400,9 @@ bool ProcessMachCore::LoadBinariesViaMetadata() {
     m_dyld_plugin_name = DynamicLoaderStatic::GetPluginNameStatic();
   }
 
+  if (!found_binary_spec_in_metadata && LoadBinaryViaLowmemUUID())
+    found_binary_spec_in_metadata = true;
+
   // LoadCoreFileImges may have set the dynamic loader, e.g. in
   // PlatformDarwinKernel::LoadPlatformBinaryAndSetup().
   // If we now have a dynamic loader, save its name so we don't 
@@ -509,10 +574,9 @@ Status ProcessMachCore::DoLoadCore() {
 
   CleanupMemoryRegionPermissions();
 
-  addr_t address_mask = core_objfile->GetAddressMask();
-  if (address_mask != 0) {
-    SetCodeAddressMask(address_mask);
-    SetDataAddressMask(address_mask);
+  AddressableBits addressable_bits;
+  if (core_objfile->GetAddressableBits(addressable_bits)) {
+    addressable_bits.SetProcessMasks(*this);
   }
   return error;
 }

lldb/source/Plugins/Process/mach-core/ProcessMachCore.h

@@ -87,6 +87,8 @@ class ProcessMachCore : public lldb_private::PostMortemProcess {
 private:
   void CreateMemoryRegions();
 
+  bool LoadBinaryViaLowmemUUID();
+
   /// \return
   ///   True if any metadata were found indicating the binary that should
   ///   be loaded, regardless of whether the specified binary could be found.