Define qHostInfo and Mach-O LC_NOTE "addrable bits" methods to describe high and low memory addressing bits

[jasonmolenda]

Summary

To recap, on AArch64 where we need to strip pointer authentication bits off of addresses, it can have a different number of bits in use for high and low memory (you can have a different page table setup for high and low memory, so different number of addressing bits for virtual addresses). I added this to Process and defined a new setting so these can be done manually in https://reviews.llvm.org/D151292 a few months ago.

This patch defines keys for qHostInfo and a new "addrable bits" LC_NOTE format for mach-o corefiles to define both of them.

qHostInfo gains low_mem_addressing_bits and high_mem_addressing_bits keys. The previous addressing_bits is still accepted for a value that is used for both regions of memory (this is by far the most common case).

For Mach-O corefile, I've needed to update the "addrable bits" LC_NOTE. The previous definition was

struct addressing_bit_count_v3    // ** DEPRECATED **
{
    uint32_t version;             // currently 3
    uint32_t addressing_bits;     // # of bits used for addressing
    uint64_t unused;
};

The new definition is

struct addressing_bit_count
{
    // currently 4
    uint32_t version;

    // Number of bits used for addressing in low
    // memory (addresses starting with 0)
    uint32_t low_memory_addressing_bits;

    // Number of bits used for addressing in high
    // memory (addresses starting with f)
    uint32_t high_memory_addressing_bits;

    // set to zero
    uint32_t reserved;
};

The changes in this patchset are to GDBRemoteCommunicationClient (read the new qHostInfo keys), ProcessGDBRemote (set both in the Process when they are specified). And ObjectFileMachO (read and write the new LC_NOTE in mach-o corefiles), ProcessMachCore (set both in Process when they are specified).

I still accept the previous formats of a single value, and only initialize the base CodeAddressMask and DataAddressMask. Only when both high and low memory addressing bits are specified and are different, do we set the Process' HighmemCodeAddressMask, HighmemDataAddressMask.

This is the final part of adding support for the different address masks that can be used on AArch64 targets.

[jasonmolenda]

update comments a tiny bit.

[bulbazord]

lldb/include/lldb/Symbol/ObjectFile.h

500–503

/param -> \param

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

917–918

These should be SetHighmemCodeAddressMask and SetHighmemDataAddressMask right?

[jasonmolenda]

Fix the problems Alex found on review, thanks Alex.

[bulbazord]

LGTM. You may want to wait for Jonas to take a look before landing though.

[JDevlieghere]

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

125–126

I would prefer this to return a struct with the two masks, possibly living in Utility. The struct would centralize default values, which values are meaningful, etc and could be stored as a member in GDBRemoteCommunicationClient.

[jasonmolenda]

Incorporate Jonas' suggestion of a AddressableBits class that GDBRemoteCommunicationClient and ObjectFileMachO could use to store the zero/one/two addressable bits values back to a Process, and centralizing the logic for how those 0-2 values are used to set the Process address masks.

lldb/docs/lldb-gdb-remote.txt

vm-page-size: optional, specifies the target system VM page size, base 10.
            stub.  This page size tells lldb how large each dirty page is.
 addressing_bits: optional, specifies how many bits in addresses are
      significant for addressing, base 10.  If bits 38..0
      in a 64-bit pointer are significant for addressing,
      then the value is 39.  This is needed on e.g. AArch64
      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"
 //
 // BRIEF
 //  Get version information about this implementation of the gdb-remote
 //  protocol.
 //

lldb/include/lldb/Symbol/ObjectFile.h

 //===-- ObjectFile.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_SYMBOL_OBJECTFILE_H
 #define LLDB_SYMBOL_OBJECTFILE_H
 
 #include "lldb/Core/ModuleChild.h"
 #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"
 #include "lldb/Utility/FileSpecList.h"
 #include "lldb/Utility/UUID.h"
 #include "lldb/lldb-private.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/VersionTuple.h"
public:
   ///     Returns the identifier string if one exists, else an empty
   ///     string.
   virtual std::string GetIdentifierString () {
       return std::string();
   }
 
   /// 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
   /// binary, but some core files may have metadata  describing where the main
   /// binary is exactly which removes ambiguity when there are multiple
   /// binaries present in the captured memory pages.
   ///
   /// \param[out] value

lldb/include/lldb/Utility/AddressableBits.h

+//===-- 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.h

public:
   lldb_private::Address GetEntryPointAddress() override;
 
   lldb_private::Address GetBaseAddress() override;
 
   uint32_t GetNumThreadContexts() override;
 
   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,
                                  ObjectFile::BinaryType &type) override;
 
   bool LoadCoreFileImages(lldb_private::Process &process) override;
 
   lldb::RegisterContextSP
   GetThreadContextAtIndex(uint32_t idx, lldb_private::Thread &thread) override;

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

for (uint32_t i = 0; i < m_header.ncmds; ++i) {
           free(buf);
       }
       offset = cmd_offset + ident_command.cmdsize;
     }
   }
   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) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
     for (uint32_t i = 0; i < m_header.ncmds; ++i) {
       const uint32_t cmd_offset = offset;
       llvm::MachO::load_command lc = {};
for (uint32_t i = 0; i < m_header.ncmds; ++i) {
         // number of bits used in addressing.
         if (strcmp("addrable bits", data_owner) == 0) {
           offset = fileoff;
           uint32_t version;
           if (m_data.GetU32(&offset, &version, 1) != nullptr) {
             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,
                                                 bool &value_is_offset,
                                                 UUID &uuid,
                                                 ObjectFile::BinaryType &type) {
   Log *log(
       GetLog(LLDBLog::Symbols | LLDBLog::Process | LLDBLog::DynamicLoader));
if (make_core) {
 
         // Add "addrable bits" LC_NOTE when an address mask is available
         if (address_mask != 0) {
           std::unique_ptr<LCNoteEntry> addrable_bits_lcnote_up(
               new LCNoteEntry(addr_byte_size, byte_order));
           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();
 
           lc_notes.push_back(std::move(addrable_bits_lcnote_up));
         }
 
         // Add "all image infos" LC_NOTE
         std::unique_ptr<LCNoteEntry> all_image_infos_lcnote_up(

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

 #include <chrono>
 #include <map>
 #include <mutex>
 #include <optional>
 #include <string>
 #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"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/TraceGDBRemotePackets.h"
 #include "lldb/Utility/UUID.h"
 #if defined(_WIN32)
 #include "lldb/Host/windows/PosixApi.h"
public:
   llvm::VersionTuple GetMacCatalystVersion();
 
   std::optional<std::string> GetOSBuildString();
 
   std::optional<std::string> GetOSKernelDescription();
 
   ArchSpec GetSystemArchitecture();
 
-  uint32_t GetAddressingBits();
+  bool GetAddressableBits(lldb_private::AddressableBits &addressable_bits);
 
   bool GetHostname(std::string &s);
 
   lldb::addr_t GetShlibInfoAddr();
 
   bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info);
 
   uint32_t FindProcesses(const ProcessInstanceInfoMatch &process_match_info,
protected:
   /// Current gdb remote protocol process identifier for continue, step, etc
   lldb::pid_t m_curr_pid_run = LLDB_INVALID_PROCESS_ID;
   /// Current gdb remote protocol thread identifier for all other operations
   lldb::tid_t m_curr_tid = LLDB_INVALID_THREAD_ID;
   /// Current gdb remote protocol thread identifier for continue, step, etc
   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;
   std::string m_host_distribution_id;
   ArchSpec m_process_arch;
   UUID m_process_standalone_uuid;
   lldb::addr_t m_process_standalone_value = LLDB_INVALID_ADDRESS;
   bool m_process_standalone_value_is_offset = false;
   std::vector<lldb::addr_t> m_binary_addresses;

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

if (SendPacketAndWaitForResponse("qHostInfo", response) ==
                              .Case("pdp", eByteOrderPDP)
                              .Default(eByteOrderInvalid);
             if (byte_order != eByteOrderInvalid)
               ++num_keys_decoded;
           } else if (name.equals("ptrsize")) {
             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
                                              // the "version" key instead of
                                              // "os_version"...
           {
             if (!m_os_version.tryParse(value))
               ++num_keys_decoded;

 
 const lldb_private::ArchSpec &
 GDBRemoteCommunicationClient::GetHostArchitecture() {
   if (m_qHostInfo_is_valid == eLazyBoolCalculate)
     GetHostInfo();
   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();
   return m_default_packet_timeout;
 }
 
 addr_t GDBRemoteCommunicationClient::AllocateMemory(size_t size,
                                                     uint32_t permissions) {

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

if (remote_process_arch.IsValid()) {
     process_arch = m_gdb_comm.GetHostArchitecture();
     LLDB_LOG(log,
              "gdb-remote did not have process architecture, using gdb-remote "
              "host architecture {0} {1}",
              process_arch.GetArchitectureName(),
              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()) {
     const ArchSpec &target_arch = GetTarget().GetArchitecture();
     if (target_arch.IsValid()) {
       LLDB_LOG(log, "analyzing target arch, currently {0} {1}",
                target_arch.GetArchitectureName(),
                target_arch.GetTriple().getTriple());
 
       // If the remote host is ARM and we have apple as the vendor, then
       // ARM executables and shared libraries can have mixed ARM
       // architectures.
       // You can have an armv6 executable, and if the host is armv7, then the
       // system will load the best possible architecture for all shared
       // libraries it has, so we really need to take the remote host
       // architecture as our defacto architecture in this case.
 
       if ((process_arch.GetMachine() == llvm::Triple::arm ||
            process_arch.GetMachine() == llvm::Triple::thumb) &&
           process_arch.GetTriple().getVendor() == llvm::Triple::Apple) {
         GetTarget().SetArchitecture(process_arch);
         LLDB_LOG(log,

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

if (arch.IsValid())
     GetTarget().SetArchitecture(arch);
 
   CreateMemoryRegions();
 
   LoadBinariesAndSetDYLD();
 
   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_private::DynamicLoader *ProcessMachCore::GetDynamicLoader() {
   if (m_dyld_up.get() == nullptr)
     m_dyld_up.reset(DynamicLoader::FindPlugin(this, m_dyld_plugin_name));
   return m_dyld_up.get();

lldb/source/Utility/AddressableBits.cpp

+//===-- AddressableBits.cpp -----------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/AddressableBits.h"
+#include "lldb/Target/Process.h"
+#include "lldb/lldb-types.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+void AddressableBits::SetAddressableBits(uint32_t addressing_bits) {
+  m_low_memory_addr_bits = m_high_memory_addr_bits = addressing_bits;
+}
+
+void AddressableBits::SetAddressableBits(uint32_t lowmem_addressing_bits,
+                                         uint32_t highmem_addressing_bits) {
+  m_low_memory_addr_bits = lowmem_addressing_bits;
+  m_high_memory_addr_bits = highmem_addressing_bits;
+}
+
+void AddressableBits::Clear() {
+  m_low_memory_addr_bits = m_high_memory_addr_bits = 0;
+}
+
+void AddressableBits::SetProcessMasks(Process &process) {
+  // In case either value is set to 0, indicating it was not set, use the
+  // other value.
+  if (m_low_memory_addr_bits == 0)
+    m_low_memory_addr_bits = m_high_memory_addr_bits;
+  if (m_high_memory_addr_bits == 0)
+    m_high_memory_addr_bits = m_low_memory_addr_bits;
+
+  if (m_low_memory_addr_bits == 0)
+    return;
+
+  addr_t address_mask = ~((1ULL << m_low_memory_addr_bits) - 1);
+  process.SetCodeAddressMask(address_mask);
+  process.SetDataAddressMask(address_mask);
+
+  if (m_low_memory_addr_bits != m_high_memory_addr_bits) {
+    lldb::addr_t hi_address_mask = ~((1ULL << m_high_memory_addr_bits) - 1);
+    process.SetHighmemCodeAddressMask(hi_address_mask);
+    process.SetHighmemDataAddressMask(hi_address_mask);
+  }
+}

lldb/source/Utility/CMakeLists.txt

if (CMAKE_SYSTEM_NAME MATCHES "Windows")
   list(APPEND LLDB_SYSTEM_LIBS ws2_32 rpcrt4)
 endif ()
 
 if (NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB )
     list(APPEND LLDB_SYSTEM_LIBS atomic)
 endif()
 
 add_lldb_library(lldbUtility NO_INTERNAL_DEPENDENCIES
+  AddressableBits.cpp
   ArchSpec.cpp
   Args.cpp
   Baton.cpp
   Broadcaster.cpp
   CompletionRequest.cpp
   Connection.cpp
   ConstString.cpp
   DataBufferHeap.cpp