[lldb][AArch64] Add memory-tagging qSupported feature

[DavidSpickett]

Summary

This feature "memory-tagging+" indicates that lldb-server
supports memory tagging packets. (added in a later patch)

We check HWCAP2_MTE to decide whether to enable this
feature for Linux.

[DavidSpickett]

This feature name matches the one GDB is planning to use: https://sourceware.org/pipermail/gdb-patches/2021-January/175514.html

Also described in my RFC: https://lists.llvm.org/pipermail/lldb-dev/2020-August/016402.html

[DavidSpickett]

Rebase

[DavidSpickett]

• Rebase onto main

Same code just moved around since qSupported parsing was refactored.

[DavidSpickett]

Rebase onto main.

[DavidSpickett]

• Rebase onto new qSupported functions
• Check AUXV for enabling feature, instead of enabling for all AArch64

[DavidSpickett]

@mgorny Can you take a quick look and see if I'm adding this new feature correctly?

And thanks for working on qSupported. I skipped checking HWCAP in my first revision because the features were added in generic code, now I can be more accurate in the Linux specific method.

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

300

There is a mechanism to get auvx from a process but I don't think we have one at this point.

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

1034

For the moment my MTE test target is in fact, a remote platform in QEMU. But at least this checks that no one else gets the feature incorrectly.

[mgorny]

In D97282#2722937, @DavidSpickett wrote:

@mgorny Can you take a quick look and see if I'm adding this new feature correctly?

Everything looks good from my perspective.

And thanks for working on qSupported. I skipped checking HWCAP in my first revision because the features were added in generic code, now I can be more accurate in the Linux specific method.

Thanks!

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

300

You may want to add an explicit comment about that.

[DavidSpickett]

• Add comment to explain reading auxv.

[DavidSpickett]

asm/hwcap.h is not available on x86 (riscv/arm/aarch64 have it at least)
so #ifdef the includes and auxval call.

[DavidSpickett]

Rebase, fix missed clang-format-ing.

[DavidSpickett]

Rebase

[DavidSpickett]

This comment was removed by DavidSpickett.

[DavidSpickett]

Rebase.

[DavidSpickett]

Rebase, this is good to land as is.

lldb/include/lldb/Host/common/NativeProcessProtocol.h

public:
   /// and passed to SetEnabledExtension()
   enum class Extension {
     multiprocess = (1u << 0),
     fork = (1u << 1),
     vfork = (1u << 2),
     pass_signals = (1u << 3),
     auxv = (1u << 4),
     libraries_svr4 = (1u << 5),
+    memory_tagging = (1u << 6),
 
-    LLVM_MARK_AS_BITMASK_ENUM(libraries_svr4)
+    LLVM_MARK_AS_BITMASK_ENUM(memory_tagging)
   };
 
   class Factory {
   public:
     virtual ~Factory();
     /// Launch a process for debugging.
     ///
     /// \param[in] launch_info

lldb/include/lldb/Target/Process.h

protected:
   ///                                   const StructuredData::ObjectSP
   ///                                   &object_sp)
   ///
   /// \return
   ///     True if the structured data was routed to a plugin; otherwise,
   ///     false.
   bool RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp);
 
+  /// Check whether the process supports memory tagging.
+  ///
+  /// \return
+  ///     true if the process supports memory tagging,
+  ///     false otherwise.
+  virtual bool SupportsMemoryTagging() { return false; }
+
   // Type definitions
   typedef std::map<lldb::LanguageType, lldb::LanguageRuntimeSP>
       LanguageRuntimeCollection;
   typedef std::unordered_set<const void *> WarningsPointerSet;
   typedef std::map<uint64_t, WarningsPointerSet> WarningsCollection;
 
   struct PreResumeCallbackAndBaton {
     bool (*callback)(void *);

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

_KNOWN_QSUPPORTED_STUB_FEATURES = [
         "qXfer:libraries:read",
         "qXfer:libraries-svr4:read",
         "qXfer:features:read",
         "qEcho",
         "QPassSignals",
         "multiprocess",
         "fork-events",
         "vfork-events",
+        "memory-tagging",
     ]
 
     def parse_qSupported_response(self, context):
         self.assertIsNotNone(context)
 
         raw_response = context.get("qSupported_response")
         self.assertIsNotNone(raw_response)
 

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 
 #include <linux/unistd.h>
 #include <sys/socket.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 
+#ifdef __aarch64__
+#include <asm/hwcap.h>
+#include <sys/auxv.h>
+#endif
+
 // Support hardware breakpoints in case it has not been defined
 #ifndef TRAP_HWBKPT
 #define TRAP_HWBKPT 4
 #endif
 
+#ifndef HWCAP2_MTE
+#define HWCAP2_MTE (1 << 18)
+#endif
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 using namespace llvm;
 
 // Private bits we only need internally.
 
 static bool ProcessVmReadvSupported() {
if (!tids_or)
     return tids_or.takeError();
 
   return std::unique_ptr<NativeProcessLinux>(new NativeProcessLinux(
       pid, -1, native_delegate, Info.GetArchitecture(), mainloop, *tids_or));
 }
 
 NativeProcessLinux::Extension
 NativeProcessLinux::Factory::GetSupportedExtensions() const {
-  return Extension::multiprocess | Extension::fork | Extension::vfork |
-         Extension::pass_signals | Extension::auxv | Extension::libraries_svr4;
+  NativeProcessLinux::Extension supported =
+      Extension::multiprocess | Extension::fork | Extension::vfork |
+
+#ifdef __aarch64__
+  // At this point we do not have a process so read auxv directly.
+  if ((getauxval(AT_HWCAP2) & HWCAP2_MTE))
+    supported |= Extension::memory_tagging;
+#endif
+
+  return supported;
 }
 
 // Public Instance Methods
 
 NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
                                        NativeDelegate &delegate,
                                        const ArchSpec &arch, MainLoop &mainloop,
                                        llvm::ArrayRef<::pid_t> tids)

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

public:
   StructuredData::ObjectSP GetThreadsInfo();
 
   bool GetThreadExtendedInfoSupported();
 
   bool GetLoadedDynamicLibrariesInfosSupported();
 
   bool GetSharedCacheInfoSupported();
 
+  bool GetMemoryTaggingSupported();
+
   /// Use qOffsets to query the offset used when relocating the target
   /// executable. If successful, the returned structure will contain at least
   /// one value in the offsets field.
   llvm::Optional<QOffsets> GetQOffsets();
 
   bool GetModuleInfo(const FileSpec &module_file_spec,
                      const ArchSpec &arch_spec, ModuleSpec &module_spec);
 
protected:
   LazyBool m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
   LazyBool m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
   LazyBool m_supports_jThreadExtendedInfo = eLazyBoolCalculate;
   LazyBool m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolCalculate;
   LazyBool m_supports_jGetSharedCacheInfo = eLazyBoolCalculate;
   LazyBool m_supports_QPassSignals = eLazyBoolCalculate;
   LazyBool m_supports_error_string_reply = eLazyBoolCalculate;
   LazyBool m_supports_multiprocess = eLazyBoolCalculate;
+  LazyBool m_supports_memory_tagging = eLazyBoolCalculate;
 
   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
       m_supports_qUserName : 1, m_supports_qGroupName : 1,
       m_supports_qThreadStopInfo : 1, m_supports_z0 : 1, m_supports_z1 : 1,
       m_supports_z2 : 1, m_supports_z3 : 1, m_supports_z4 : 1,
       m_supports_QEnvironment : 1, m_supports_QEnvironmentHexEncoded : 1,
       m_supports_qSymbol : 1, m_qSymbol_requests_done : 1,
       m_supports_qModuleInfo : 1, m_supports_jThreadsInfo : 1,

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

void GDBRemoteCommunicationClient::GetRemoteQSupported() {
   m_supports_qXfer_libraries_read = eLazyBoolNo;
   m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
   m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
   m_supports_qXfer_features_read = eLazyBoolNo;
   m_supports_qXfer_memory_map_read = eLazyBoolNo;
   m_supports_multiprocess = eLazyBoolNo;
   m_supports_qEcho = eLazyBoolNo;
   m_supports_QPassSignals = eLazyBoolNo;
+  m_supports_memory_tagging = eLazyBoolNo;
 
   m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
                                   // not, we assume no limit
 
   // build the qSupported packet
   std::vector<std::string> features = {"xmlRegisters=i386,arm,mips,arc",
                                        "multiprocess+"};
   StreamString packet;
for (llvm::StringRef x : server_features) {
       else if (x == "qXfer:memory-map:read+")
         m_supports_qXfer_memory_map_read = eLazyBoolYes;
       else if (x == "qEcho")
         m_supports_qEcho = eLazyBoolYes;
       else if (x == "QPassSignals+")
         m_supports_QPassSignals = eLazyBoolYes;
       else if (x == "multiprocess+")
         m_supports_multiprocess = eLazyBoolYes;
+      else if (x == "memory-tagging+")
+        m_supports_memory_tagging = eLazyBoolYes;
       // Look for a list of compressions in the features list e.g.
       // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib-
       // deflate,lzma
       else if (x.consume_front("SupportedCompressions=")) {
         llvm::SmallVector<llvm::StringRef, 4> compressions;
         x.split(compressions, ',');
         if (!compressions.empty())
           MaybeEnableCompression(compressions);
if (SendPacketAndWaitForResponse("jGetSharedCacheInfo:", response, false) ==
       if (response.IsOKResponse()) {
         m_supports_jGetSharedCacheInfo = eLazyBoolYes;
       }
     }
   }
   return m_supports_jGetSharedCacheInfo;
 }
 
+bool GDBRemoteCommunicationClient::GetMemoryTaggingSupported() {
+  if (m_supports_memory_tagging == eLazyBoolCalculate) {
+    GetRemoteQSupported();
+  }
+  return m_supports_memory_tagging == eLazyBoolYes;
+}
+
 bool GDBRemoteCommunicationClient::GetxPacketSupported() {
   if (m_supports_x == eLazyBoolCalculate) {
     StringExtractorGDBRemote response;
     m_supports_x = eLazyBoolNo;
     char packet[256];
     snprintf(packet, sizeof(packet), "x0,0");
     if (SendPacketAndWaitForResponse(packet, response, false) ==
         PacketResult::Success) {

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

std::vector<std::string> GDBRemoteCommunicationServerLLGS::HandleFeatures(
   using Extension = NativeProcessProtocol::Extension;
   Extension plugin_features = m_process_factory.GetSupportedExtensions();
   if (bool(plugin_features & Extension::pass_signals))
     ret.push_back("QPassSignals+");
   if (bool(plugin_features & Extension::auxv))
     ret.push_back("qXfer:auxv:read+");
   if (bool(plugin_features & Extension::libraries_svr4))
     ret.push_back("qXfer:libraries-svr4:read+");
+  if (bool(plugin_features & Extension::memory_tagging))
+    ret.push_back("memory-tagging+");
 
   // check for client features
   m_extensions_supported = {};
   for (llvm::StringRef x : client_features)
     m_extensions_supported |=
         llvm::StringSwitch<Extension>(x)
             .Case("multiprocess+", Extension::multiprocess)
             .Case("fork-events+", Extension::fork)

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

public:
   std::string HarmonizeThreadIdsForProfileData(
       StringExtractorGDBRemote &inputStringExtractor);
 
 protected:
   friend class ThreadGDBRemote;
   friend class GDBRemoteCommunicationClient;
   friend class GDBRemoteRegisterContext;
 
+  bool SupportsMemoryTagging() override;
+
   /// Broadcaster event bits definitions.
   enum {
     eBroadcastBitAsyncContinue = (1 << 0),
     eBroadcastBitAsyncThreadShouldExit = (1 << 1),
     eBroadcastBitAsyncThreadDidExit = (1 << 2)
   };
 
   GDBRemoteCommunicationClient m_gdb_comm;

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

else
           "unexpected response to GDB server memory read packet '%s': '%s'",
           packet, response.GetStringRef().data());
   } else {
     error.SetErrorStringWithFormat("failed to send packet: '%s'", packet);
   }
   return 0;
 }
 
+bool ProcessGDBRemote::SupportsMemoryTagging() {
+  return m_gdb_comm.GetMemoryTaggingSupported();
+}
+
 Status ProcessGDBRemote::WriteObjectFile(
     std::vector<ObjectFile::LoadableData> entries) {
   Status error;
   // Sort the entries by address because some writes, like those to flash
   // memory, must happen in order of increasing address.
   std::stable_sort(
       std::begin(entries), std::end(entries),
       [](const ObjectFile::LoadableData a, const ObjectFile::LoadableData b) {

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
     @add_test_categories(["fork"])
     def test_qSupported_vfork_events_without_multiprocess(self):
         supported_dict = (
             self.get_qSupported_dict(['vfork-events+']))
         self.assertEqual(supported_dict.get('multiprocess', '-'), '-')
         self.assertEqual(supported_dict.get('fork-events', '-'), '-')
         self.assertEqual(supported_dict.get('vfork-events', '-'), '-')
 
+    # We need to be able to self.runCmd to get cpuinfo,
+    # which is not possible when using a remote platform.
+    @skipIfRemote
+    def test_qSupported_memory_tagging(self):
+        supported_dict = self.get_qSupported_dict()
+        self.assertEqual(supported_dict.get("memory-tagging", '-'),
+                         '+' if self.isAArch64MTE() else '-')
+
     @skipIfWindows # No pty support to test any inferior output
     def test_written_M_content_reads_back_correctly(self):
         self.build()
         self.set_inferior_startup_launch()
 
         TEST_MESSAGE = "Hello, memory"
 
         # Start up the stub and start/prep the inferior.