[lldb] Add --show-tags option to "memory find"

[DavidSpickett]

Summary

This is off by default. If you get a result and that
memory has memory tags, when --show-tags is given you'll
see the tags inline with the memory content.

(lldb) memory read mte_buf mte_buf+64 --show-tags
<...>
0xfffff7ff8020: 00 00 00 00 00 00 00 00 0d f0 fe ca 00 00 00 00 ................ (tag: 0x2)
<...>
(lldb) memory find -e 0xcafef00d mte_buf mte_buf+64 --show-tags
data found at location: 0xfffff7ff8028
0xfffff7ff8028: 0d f0 fe ca 00 00 00 00 00 00 00 00 00 00 00 00 ................ (tags: 0x2 0x3)
0xfffff7ff8038: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................ (tags: 0x3 0x4)

The logic for handling alignments is the same as for memory read
so in the above example because the line starts misaligned to the
granule it covers 2 granules.

Depends on D125089

[DavidSpickett]

Test that show-tags without finding anything doesn't do anything strange.

[DavidSpickett]

The logic for handling misalignment is all done in DumpDataExtractor so that is covered by the "memory read --show-tags" tests.

[DavidSpickett]

Add a release note.

lldb/include/lldb/Interpreter/OptionGroupMemoryTag.h

 
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/Options.h"
 
 namespace lldb_private {
 
 class OptionGroupMemoryTag : public OptionGroup {
 public:
-  OptionGroupMemoryTag();
+  OptionGroupMemoryTag(
+      // Whether to note that --show-tags does not apply to binary output.
+      // "memory read" wants this but "memory find" does not.
+      bool note_binary = false);
 
   ~OptionGroupMemoryTag() override = default;
 
   llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
 
   Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
                         ExecutionContext *execution_context) override;
 
   void OptionParsingStarting(ExecutionContext *execution_context) override;
 
   bool AnyOptionWasSet() const { return m_show_tags.OptionWasSet(); }
 
   OptionValueBoolean GetShowTags() { return m_show_tags; };
 
 protected:
   OptionValueBoolean m_show_tags;
+  OptionDefinition m_option_definition;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONGROUPMEMORYTAG_H

lldb/source/Commands/CommandObjectMemory.cpp

 class CommandObjectMemoryRead : public CommandObjectParsed {
 public:
   CommandObjectMemoryRead(CommandInterpreter &interpreter)
       : CommandObjectParsed(
             interpreter, "memory read",
             "Read from the memory of the current target process.", nullptr,
             eCommandRequiresTarget | eCommandProcessMustBePaused),
         m_format_options(eFormatBytesWithASCII, 1, 8),
-
+        m_memory_tag_options(/*note_binary=*/true),
         m_prev_format_options(eFormatBytesWithASCII, 1, 8) {
     CommandArgumentEntry arg1;
     CommandArgumentEntry arg2;
     CommandArgumentData start_addr_arg;
     CommandArgumentData end_addr_arg;
 
     // Define the first (and only) variant of this arg.
     start_addr_arg.arg_type = eArgTypeAddressOrExpression;
CommandObjectMemoryFind(CommandInterpreter &interpreter)
     // argument entry.
     arg2.push_back(value_arg);
 
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back(arg1);
     m_arguments.push_back(arg2);
 
     m_option_group.Append(&m_memory_options);
+    m_option_group.Append(&m_memory_tag_options, LLDB_OPT_SET_ALL,
+                          LLDB_OPT_SET_ALL);
     m_option_group.Finalize();
   }
 
   ~CommandObjectMemoryFind() override = default;
 
   Options *GetOptions() override { return &m_option_group; }
 
 protected:
while (count) {
           dumpbuffer.GetBytes(), dumpbuffer.GetByteSize(), error);
       if (!error.Fail()) {
         DataExtractor data(dumpbuffer.GetBytes(), dumpbuffer.GetByteSize(),
                            process->GetByteOrder(),
                            process->GetAddressByteSize());
         DumpDataExtractor(
             data, &result.GetOutputStream(), 0, lldb::eFormatBytesWithASCII, 1,
             dumpbuffer.GetByteSize(), 16,
-            found_location + m_memory_options.m_offset.GetCurrentValue(), 0, 0);
+            found_location + m_memory_options.m_offset.GetCurrentValue(), 0, 0,
+            m_exe_ctx.GetBestExecutionContextScope(),
+            m_memory_tag_options.GetShowTags().GetCurrentValue());
         result.GetOutputStream().EOL();
       }
 
       --count;
       found_location++;
       ever_found = true;
     }
 
for (size_t s = 0; s <= (region_size - buffer_size);) {
         s += bad_char_heuristic[iterator[s + buffer_size - 1]];
     }
 
     return LLDB_INVALID_ADDRESS;
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupFindMemory m_memory_options;
+  OptionGroupMemoryTag m_memory_tag_options;
 };
 
 #define LLDB_OPTIONS_memory_write
 #include "CommandOptions.inc"
 
 // Write memory to the inferior process
 class CommandObjectMemoryWrite : public CommandObjectParsed {
 public:

lldb/source/Interpreter/OptionGroupMemoryTag.cpp

 //===-- OptionGroupMemoryTag.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/Interpreter/OptionGroupMemoryTag.h"
 
 #include "lldb/Host/OptionParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-OptionGroupMemoryTag::OptionGroupMemoryTag() : m_show_tags(false, false) {}
-
 static const uint32_t SHORT_OPTION_SHOW_TAGS = 0x54414753; // 'tags'
 
-static constexpr OptionDefinition g_option_table[] = {
-    {LLDB_OPT_SET_1,
+OptionGroupMemoryTag::OptionGroupMemoryTag(bool note_binary /*=false*/)
+    : m_show_tags(false, false), m_option_definition{
+                                     LLDB_OPT_SET_1,
                                      false,
                                      "show-tags",
                                      SHORT_OPTION_SHOW_TAGS,
                                      OptionParser::eNoArgument,
                                      nullptr,
                                      {},
                                      0,
                                      eArgTypeNone,
-     "Include memory tags in output (does not apply to binary output)."},
-};
+                                     note_binary
+                                         ? "Include memory tags in output "
+                                           "(does not apply to binary output)."
+                                         : "Include memory tags in output."} {}
 
 llvm::ArrayRef<OptionDefinition> OptionGroupMemoryTag::GetDefinitions() {
-  return llvm::makeArrayRef(g_option_table);
+  return llvm::makeArrayRef(m_option_definition);
 }
 
 Status
 OptionGroupMemoryTag::SetOptionValue(uint32_t option_idx,
                                      llvm::StringRef option_arg,
                                      ExecutionContext *execution_context) {
   assert(option_idx == 0 && "Only one option in memory tag group!");
 
-  switch (g_option_table[0].short_option) {
+  switch (m_option_definition.short_option) {
   case SHORT_OPTION_SHOW_TAGS:
     m_show_tags.SetCurrentValue(true);
     m_show_tags.SetOptionWasSet();
     break;
 
   default:
     llvm_unreachable("Unimplemented option");
   }
 
   return {};
 }
 
 void OptionGroupMemoryTag::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_show_tags.Clear();
 }

lldb/test/API/commands/help/TestHelp.py

def test_help_detailed_information_ordering(self):
             line = line.strip()
             # The order of -- only options is not enforced so ignore their position.
             if not line.startswith("--"):
                 # Save its short char name.
                 short_options.append(line[1])
 
         self.assertEqual(sorted(short_options), short_options,
                          "Short option help displayed in an incorrect order!")
+
+    @no_debug_info_test
+    def test_help_show_tags(self):
+        """ Check that memory find and memory read have the --show-tags option
+            but only memory read mentions binary output. """
+        self.expect("help memory read", patterns=[
+                    "--show-tags\n\s+Include memory tags in output "
+                    "\(does not apply to binary output\)."])
+        self.expect("help memory find", patterns=[
+                    "--show-tags\n\s+Include memory tags in output."])

lldb/test/API/linux/aarch64/mte_tag_access/TestAArch64LinuxMTEMemoryTagAccess.py

def test_mte_memory_read_tag_display_repeated(self):
         self.expect("memory read --show-tags",
                     patterns=["0x[0-9A-fa-f]+20: (00 )+ \.+ \(tag: 0x2\)"])
         self.expect("memory read",
                     patterns=["0x[0-9A-fa-f]+30: (00 )+ \.+ \(tag: 0x3\)"])
 
         # A fresh command reverts to the default of tags being off.
         self.expect("memory read mte_buf mte_buf+16 -f \"x\"",
                     patterns=["0x[0-9A-fa-f]+00: 0x0+ 0x0+ 0x0+ 0x0+"])
+
+    @skipUnlessArch("aarch64")
+    @skipUnlessPlatform(["linux"])
+    @skipUnlessAArch64MTELinuxCompiler
+    def test_mte_memory_find(self):
+        """Test the --show-tags option with memory find."""
+        self.setup_mte_test()
+
+        # No result, nothing changes.
+        self.expect("memory find -s \"foo\" mte_buf mte_buf+32 --show-tags",
+            substrs=["data not found within the range."])
+
+        cmd = "memory find -s \"LLDB\" mte_buf+64 mte_buf+512"
+        found_pattern = "data found at location: 0x[0-9A-Fa-f]+80"
+        results_patterns = [
+            "0x[0-9A-Fa-f]+80: 4c 4c 44 42 (00 )+ LLDB\.+",
+            "0x[0-9A-Fa-f]+90: 00 00 00 00 (00 )+ \.+"
+        ]
+
+        # Default is not to show tags
+        self.expect(cmd, patterns=[found_pattern, *results_patterns])
+        self.expect(cmd + " --show-tags", patterns=[found_pattern,
+                    results_patterns[0] + " \(tag: 0x8\)",
+                    results_patterns[1] + " \(tag: 0x9\)"])
+
+        # Uses the same logic as memory read to handle misalignment.
+        self.expect("memory find -s \"DB\" mte_buf+64 mte_buf+512 --show-tags",
+            patterns=[
+                "data found at location: 0x[0-9A-Fa-f]+82\n"
+                "0x[0-9A-Fa-f]+82: 44 42 (00 )+ DB\.+ \(tags: 0x8 0x9\)\n",
+                "0x[0-9A-Fa-f]+92: 00 00 (00 )+ ..\.+ \(tags: 0x9 0xa\)"])

lldb/test/API/linux/aarch64/mte_tag_access/main.c

 #include <arm_acle.h>
 #include <asm/hwcap.h>
 #include <asm/mman.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/auxv.h>
 #include <sys/mman.h>
 #include <sys/prctl.h>
 #include <unistd.h>
 
 // This file uses ACLE intrinsics as detailed in:
 // https://developer.arm.com/documentation/101028/0012/10--Memory-tagging-intrinsics?lang=en
 
int main(int argc, char const *argv[]) {
   char *mte_buf = checked_mmap(page_size, mte_prot | PROT_WRITE | PROT_EXEC);
   // We expect the mappings to be next to each other
   if (mte_buf_2 - mte_buf != page_size)
     return 1;
 
   char *non_mte_buf = checked_mmap(page_size, PROT_READ);
   char *mte_read_only = checked_mmap(page_size, mte_prot);
 
+  // Target value for "memory find" testing.
+  strncpy(mte_buf+128, "LLDB", 4);
+
   // Set incrementing tags until end of the first page
   char *tagged_ptr = mte_buf;
   // This ignores tag bits when subtracting the addresses
   while (__arm_mte_ptrdiff(tagged_ptr, mte_buf) < page_size) {
     // Set the allocation tag for this location
     __arm_mte_set_tag(tagged_ptr);
     // + 16 for 16 byte granules
     // Earlier we allowed all tag values, so this will give us an

llvm/docs/ReleaseNotes.rst

 
 Changes to LLDB
 ---------------------------------
 
 * The "memory region" command now has a "--all" option to list all
   memory regions (including unmapped ranges). This is the equivalent
   of using address 0 then repeating the command until all regions
   have been listed.
+* Added "--show-tags" option to the "memory find" command. This is off by default.
+  When enabled, if the target value is found in tagged memory, the tags for that
+  memory will be shown inline with the memory contents.
 
 Changes to Sanitizers
 ---------------------
 
 
 Other Changes
 -------------
 * The code for the `LLVM Visual Studio integration