DavidSpickett created this revision.
Herald added subscribers: danielkiss, kristof.beyls, mgorny.
DavidSpickett requested review of this revision.
Herald added a project: LLDB.
Herald added a subscriber: lldb-commits.
This commit adds a new command "memory tag read".
It looks much like "memory read" and mirrors its basic
behaviour.
(lldb) memory tag read new_buf_ptr new_buf_ptr+32
Logical tag: 0x9
Allocation tags:
[0x900fffff7ffa000, 0x900fffff7ffa010): 0x9
[0x900fffff7ffa010, 0x900fffff7ffa020): 0x0
(end address is optional and we default to reading 1 tag if it is omitted)
This makes use of the MemoryTagHandler previously added.
In lldb the tag handler can be accessed as a sub plugin of
the architecture plugin.
Meaning, to use this command you must have a specific architecture plugin
and that plugin must give you a valid tag handler. Otherwise memory
tagging is not supported.
During transport tags are packed in target specific ways so
lldb uses the handler to unpack those into individual tags.
For MTE ptrace already gives us one tag per byte so this is trivial.
(but you could imagine a situation where you get 2 4 bit tags
per byte and had to split them up in lldb)
In addition to getting a tag handler lldb will check that
the memory range asked for is tagged. It does this by looking
for the "mt" flag on the containing memory region.
(this lookup is done with untagged addresses and the
range is aligned to the effective range we need to read)
Target specific tests have been added to test/API/linux/aarch64/
and a test for targets that do not support memory tagging in
test/API/functionalities/memory/tag/.
The reason to split these is that the target specific test program
needs a specific toolchain, compiler arguments and includes.
It is not possible to write it in such a way that it can be used for
all the tests.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D95602
Files:
lldb/include/lldb/Core/Architecture.h
lldb/include/lldb/Target/MemoryTagHandler.h
lldb/include/lldb/Target/Process.h
lldb/packages/Python/lldbsuite/test/lldbtest.py
lldb/source/Commands/CMakeLists.txt
lldb/source/Commands/CommandObjectMemory.cpp
lldb/source/Commands/CommandObjectMemoryTag.cpp
lldb/source/Commands/CommandObjectMemoryTag.h
lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.cpp
lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.h
lldb/source/Plugins/Architecture/AArch64/CMakeLists.txt
lldb/source/Plugins/Architecture/CMakeLists.txt
lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.cpp
lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.h
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
lldb/source/Target/Process.cpp
lldb/test/API/functionalities/memory/tag/Makefile
lldb/test/API/functionalities/memory/tag/TestMemoryTag.py
lldb/test/API/functionalities/memory/tag/main.cpp
lldb/test/API/linux/aarch64/mte_tag_read/Makefile
lldb/test/API/linux/aarch64/mte_tag_read/TestAArch64LinuxMTEMemoryTagRead.py
lldb/test/API/linux/aarch64/mte_tag_read/main.c
lldb/unittests/Process/Utility/MemoryTagHandlerAArch64MTETest.cpp
lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
Index: lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
===================================================================
--- lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
+++ lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
@@ -657,3 +657,68 @@
EXPECT_EQ(llvm::None, GetQOffsets("TextSeg=0x1234"));
EXPECT_EQ(llvm::None, GetQOffsets("TextSeg=12345678123456789"));
}
+
+static void
+check_qmemtags(TestClient &client, MockServer &server, size_t read_len,
+ const char *packet, llvm::StringRef response,
+ llvm::Optional<std::vector<uint8_t>> expected_tag_data) {
+ const auto &ReadMemoryTags = [&](size_t len, const char *packet,
+ llvm::StringRef response) {
+ std::future<DataBufferSP> result = std::async(std::launch::async, [&] {
+ return client.ReadMemoryTags(0xDEF0, read_len, 1);
+ });
+
+ HandlePacket(server, packet, response);
+ return result.get();
+ };
+
+ auto result = ReadMemoryTags(0, packet, response);
+ if (expected_tag_data) {
+ ASSERT_TRUE(result);
+ llvm::ArrayRef<uint8_t> expected(*expected_tag_data);
+ llvm::ArrayRef<uint8_t> got = result->GetData();
+ ASSERT_THAT(expected, testing::ContainerEq(got));
+ } else {
+ ASSERT_FALSE(result);
+ }
+}
+
+TEST_F(GDBRemoteCommunicationClientTest, ReadMemoryTags) {
+ // Zero length reads are valid
+ check_qmemtags(client, server, 0, "qMemTags:def0,0:1", "m",
+ std::vector<uint8_t>{});
+
+ // The client layer does not check the length of the received data.
+ // All we need is the "m" and for the decode to use all of the chars
+ check_qmemtags(client, server, 32, "qMemTags:def0,20:1", "m09",
+ std::vector<uint8_t>{0x9});
+
+ // Zero length response is fine as long as the "m" is present
+ check_qmemtags(client, server, 0, "qMemTags:def0,0:1", "m",
+ std::vector<uint8_t>{});
+
+ // Normal responses
+ check_qmemtags(client, server, 16, "qMemTags:def0,10:1", "m66",
+ std::vector<uint8_t>{0x66});
+ check_qmemtags(client, server, 32, "qMemTags:def0,20:1", "m0102",
+ std::vector<uint8_t>{0x1, 0x2});
+
+ // Empty response is an error
+ check_qmemtags(client, server, 17, "qMemTags:def0,11:1", "", llvm::None);
+ // Usual error response
+ check_qmemtags(client, server, 17, "qMemTags:def0,11:1", "E01", llvm::None);
+ // Leading m missing
+ check_qmemtags(client, server, 17, "qMemTags:def0,11:1", "01", llvm::None);
+ // Anything other than m is an error
+ check_qmemtags(client, server, 17, "qMemTags:def0,11:1", "z01", llvm::None);
+ // Decoding tag data doesn't use all the chars in the packet
+ check_qmemtags(client, server, 32, "qMemTags:def0,20:1", "m09zz", llvm::None);
+ // Data that is not hex bytes
+ check_qmemtags(client, server, 32, "qMemTags:def0,20:1", "mhello",
+ llvm::None);
+ // Data is not a complete hex char
+ check_qmemtags(client, server, 32, "qMemTags:def0,20:1", "m9", llvm::None);
+ // Data has a trailing hex char
+ check_qmemtags(client, server, 32, "qMemTags:def0,20:1", "m01020",
+ llvm::None);
+}
Index: lldb/unittests/Process/Utility/MemoryTagHandlerAArch64MTETest.cpp
===================================================================
--- lldb/unittests/Process/Utility/MemoryTagHandlerAArch64MTETest.cpp
+++ lldb/unittests/Process/Utility/MemoryTagHandlerAArch64MTETest.cpp
@@ -12,6 +12,46 @@
using namespace lldb_private;
+TEST(MemoryTagHandlerAArch64MTETest, UnpackTags) {
+ MemoryTagHandlerAArch64MTE handler;
+
+ // Error for insufficient tag data
+ std::vector<uint8_t> input;
+ ASSERT_THAT_EXPECTED(
+ handler.UnpackTags(input, 2),
+ llvm::FailedWithMessage(
+ "Packed tag data size does not match expected number of tags. "
+ "Expected 2 tag(s) for 2 granules, got 0 tag(s)."));
+
+ // This is out of the valid tag range
+ input.push_back(0x1f);
+ ASSERT_THAT_EXPECTED(
+ handler.UnpackTags(input, 1),
+ llvm::FailedWithMessage(
+ "Found tag 0x1f which is > max MTE tag value of 0xf."));
+
+ // MTE tags are 1 per byte
+ input.pop_back();
+ input.push_back(0xe);
+ input.push_back(0xf);
+
+ std::vector<lldb::addr_t> expected{0xe, 0xf};
+
+ llvm::Expected<std::vector<lldb::addr_t>> got = handler.UnpackTags(input, 2);
+ ASSERT_THAT_EXPECTED(got, llvm::Succeeded());
+ ASSERT_THAT(expected, testing::ContainerEq(*got));
+}
+
+TEST(MemoryTagHandlerAArch64MTETest, GetLogicalTag) {
+ MemoryTagHandlerAArch64MTE handler;
+
+ // Set surrounding bits to check shift is correct
+ ASSERT_EQ((lldb::addr_t)0, handler.GetLogicalTag(0xe0e00000ffffffff));
+ // Max tag value
+ ASSERT_EQ((lldb::addr_t)0xf, handler.GetLogicalTag(0x0f000000ffffffff));
+ ASSERT_EQ((lldb::addr_t)2, handler.GetLogicalTag(0x02000000ffffffff));
+}
+
TEST(MemoryTagHandlerAArch64MTETest, RemoveLogicalTag) {
MemoryTagHandlerAArch64MTE handler;
@@ -23,6 +63,54 @@
handler.RemoveLogicalTag(0x1034567812345678));
}
+TEST(MemoryTagHandlerAArch64MTETest, SetLogicalTag) {
+ MemoryTagHandlerAArch64MTE handler;
+
+ // Error if tag > mte range
+ ASSERT_THAT_EXPECTED(handler.SetLogicalTag(0x0, 0x1f),
+ llvm::FailedWithMessage(
+ "MTE logical tag value is > MTE max value of 0xf."));
+
+ // Surrounding bits should be unchanged
+ llvm::Expected<lldb::addr_t> got =
+ handler.SetLogicalTag(0xe0e00000ffffffff, 0xf);
+ ASSERT_THAT_EXPECTED(got, llvm::Succeeded());
+ ASSERT_EQ(0xefe00000ffffffff, *got);
+
+ // Old tag removed first, does not change the result
+ llvm::Expected<lldb::addr_t> g1 =
+ handler.SetLogicalTag(0x00000000ffffffff, 0xa);
+ ASSERT_THAT_EXPECTED(g1, llvm::Succeeded());
+ llvm::Expected<lldb::addr_t> g2 =
+ handler.SetLogicalTag(0x0f000000ffffffff, 0xa);
+ ASSERT_THAT_EXPECTED(g2, llvm::Succeeded());
+ ASSERT_EQ(*g1, *g2);
+
+ // Should roundtrip with the other methods
+ lldb::addr_t tag = 0xe;
+ lldb::addr_t addr = 0x1011222233334444;
+ llvm::Expected<lldb::addr_t> set = handler.SetLogicalTag(addr, tag);
+ ASSERT_THAT_EXPECTED(set, llvm::Succeeded());
+
+ ASSERT_EQ(tag, handler.GetLogicalTag(*set));
+ ASSERT_EQ(addr, handler.RemoveLogicalTag(*set));
+}
+
+TEST(MemoryTagHandlerAArch64MTETest, CopyLogicalTag) {
+ MemoryTagHandlerAArch64MTE handler;
+
+ // Round trips
+ lldb::addr_t addr = 0x1111222233334444;
+ ASSERT_EQ(addr, handler.CopyLogicalTag(addr, addr));
+ addr = 0x1011222233334444;
+ ASSERT_EQ(addr, handler.CopyLogicalTag(addr, addr));
+
+ ASSERT_EQ((lldb::addr_t)0xf0ffeeeeddddcccc,
+ handler.CopyLogicalTag(0x1011222233334444, 0xffffeeeeddddcccc));
+ ASSERT_EQ((lldb::addr_t)0x0e00111122223333,
+ handler.CopyLogicalTag(0xfeffffffffffffff, 0x0000111122223333));
+}
+
TEST(MemoryTagHandlerAArch64MTETest, AlignToGranules) {
MemoryTagHandlerAArch64MTE handler;
// Reading nothing, no alignment needed
@@ -62,4 +150,17 @@
ASSERT_EQ(
MemoryTagHandlerAArch64MTE::TagRange(16, 16),
handler.AlignToGranules(MemoryTagHandlerAArch64MTE::TagRange(18, 4)));
-}
\ No newline at end of file
+}
+
+TEST(MemoryTagHandlerAArch64MTETest, AddressDiff) {
+ MemoryTagHandlerAArch64MTE handler;
+
+ ASSERT_EQ(0, handler.AddressDiff(0, 0));
+ // Result is signed
+ ASSERT_EQ(10, handler.AddressDiff(10, 0));
+ ASSERT_EQ(-10, handler.AddressDiff(0, 10));
+ // Tag bits ignored
+ ASSERT_EQ(0, handler.AddressDiff(0x1911222233334444, 0x1811222233334444));
+ ASSERT_EQ(-32, handler.AddressDiff(0x1911222233334400, 0x1811222233334420));
+ ASSERT_EQ(65, handler.AddressDiff(0x1011222233334441, 0x1711222233334400));
+}
Index: lldb/test/API/linux/aarch64/mte_tag_read/main.c
===================================================================
--- /dev/null
+++ lldb/test/API/linux/aarch64/mte_tag_read/main.c
@@ -0,0 +1,50 @@
+#include <arm_acle.h>
+#include <asm/hwcap.h>
+#include <asm/mman.h>
+#include <sys/auxv.h>
+#include <sys/mman.h>
+#include <sys/prctl.h>
+#include <unistd.h>
+
+int main(int argc, char const *argv[]) {
+ // We assume that the test runner has checked we're on an MTE system
+
+ if (prctl(PR_SET_TAGGED_ADDR_CTRL,
+ PR_TAGGED_ADDR_ENABLE | PR_MTE_TCF_SYNC |
+ // Allow all tags to be generated by the addg
+ // instruction __arm_mte_increment_tag produces.
+ (0xffff << PR_MTE_TAG_SHIFT),
+ 0, 0, 0)) {
+ return 1;
+ }
+
+ size_t page_size = sysconf(_SC_PAGESIZE);
+
+ // Allocate memory with MTE
+ char *buf = mmap(0, sysconf(_SC_PAGESIZE), PROT_READ | PROT_WRITE | PROT_MTE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (buf == MAP_FAILED)
+ return 1;
+
+ // And without MTE
+ char *non_mte_buf = mmap(0, sysconf(_SC_PAGESIZE), PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ if (non_mte_buf == MAP_FAILED)
+ return 1;
+
+ // Set incrementing tags until end of the page
+ char *tagged_ptr = buf;
+ while (__arm_mte_ptrdiff(tagged_ptr, buf) < page_size) {
+ __arm_mte_set_tag(tagged_ptr);
+ // 16 byte granules, tags will wrap at 0xF
+ tagged_ptr = __arm_mte_increment_tag(tagged_ptr + 16, 1);
+ }
+
+ // Tag the original pointer with 9
+ buf = __arm_mte_create_random_tag(buf, ~(1 << 9));
+ // A different tag so that buf_alt_tag > buf if you don't handle the tag
+ char *buf_alt_tag = __arm_mte_create_random_tag(buf, ~(1 << 10));
+
+ // Breakpoint here
+ return 0;
+}
Index: lldb/test/API/linux/aarch64/mte_tag_read/TestAArch64LinuxMTEMemoryTagRead.py
===================================================================
--- /dev/null
+++ lldb/test/API/linux/aarch64/mte_tag_read/TestAArch64LinuxMTEMemoryTagRead.py
@@ -0,0 +1,116 @@
+"""
+Test "memory tag read" command on AArch64 Linux with MTE.
+"""
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class AArch64LinuxMTEMemoryTagReadTestCase(TestBase):
+
+ mydir = TestBase.compute_mydir(__file__)
+
+ NO_DEBUG_INFO_TESTCASE = True
+
+ @skipUnlessArch("aarch64")
+ @skipUnlessPlatform(["linux"])
+ @skipUnlessAArch64MTELinuxToolchain
+ def test_mte_tag_read(self):
+ if not self.isAArch64MTE():
+ self.skipTest('Target must support MTE.')
+
+ self.build()
+ self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+
+ lldbutil.run_break_set_by_file_and_line(self, "main.c",
+ line_number('main.c', '// Breakpoint here'),
+ num_expected_locations=1)
+
+ self.runCmd("run", RUN_SUCCEEDED)
+
+ if self.process().GetState() == lldb.eStateExited:
+ self.fail("Test program failed to run.")
+
+ self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+ substrs=['stopped',
+ 'stop reason = breakpoint'])
+
+ # Argument validation
+ self.expect("memory tag read",
+ substrs=["error: wrong number of arguments; expected at least <address-expression>, "
+ "at most <address-expression> <end-address-expression>"],
+ error=True)
+ self.expect("memory tag read buf buf+16 32",
+ substrs=["error: wrong number of arguments; expected at least <address-expression>, "
+ "at most <address-expression> <end-address-expression>"],
+ error=True)
+ self.expect("memory tag read not_a_symbol",
+ substrs=["error: Invalid address expression, address expression \"not_a_symbol\" "
+ "evaluation failed"],
+ error=True)
+ self.expect("memory tag read buf not_a_symbol",
+ substrs=["error: Invalid end address expression, address expression \"not_a_symbol\" "
+ "evaluation failed"],
+ error=True)
+ # Inverted range
+ self.expect("memory tag read buf buf-16",
+ patterns=["error: End address \(0x[A-Fa-f0-9]+\) must be "
+ "greater than the start address \(0x[A-Fa-f0-9]+\)"],
+ error=True)
+ # Range of length 0
+ self.expect("memory tag read buf buf",
+ patterns=["error: End address \(0x[A-Fa-f0-9]+\) must be "
+ "greater than the start address \(0x[A-Fa-f0-9]+\)"],
+ error=True)
+
+
+ # Can't read from a region without tagging
+ self.expect("memory tag read non_mte_buf",
+ patterns=["error: Address range 0x[0-9A-Fa-f]+00:0x[0-9A-Fa-f]+10 is not "
+ "in a memory tagged region"],
+ error=True)
+
+ # If there's no end address we assume 1 granule
+ self.expect("memory tag read buf",
+ patterns=["Logical tag: 0x9\n"
+ "Allocation tags:\n"
+ "\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0$"])
+
+ # Range of <1 granule is rounded up to 1 granule
+ self.expect("memory tag read buf buf+8",
+ patterns=["Logical tag: 0x9\n"
+ "Allocation tags:\n"
+ "\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0$"])
+
+ # Start address is aligned down, end aligned up
+ self.expect("memory tag read buf+8 buf+24",
+ patterns=["Logical tag: 0x9\n"
+ "Allocation tags:\n"
+ "\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0\n"
+ "\[0x[0-9A-Fa-f]+10, 0x[0-9A-Fa-f]+20\): 0x1$"])
+
+ # You may read up to the end of the tagged region
+ self.expect("memory tag read buf+page_size-16 buf+page_size",
+ patterns=["Logical tag: 0x9\n"
+ "Allocation tags:\n"
+ "\[0x[0-9A-Fa-f]+, 0x[0-9A-Fa-f]+\): 0x[0-9A-Fa-f]$"])
+
+ # Ranges with any part outside the region will error
+ self.expect("memory tag read buf+page_size-16 buf+page_size+32",
+ patterns=["error: Address range 0x[0-9A-fa-f]+f0:0x[0-9A-Fa-f]+20 "
+ "is not in a memory tagged region"],
+ error=True)
+ self.expect("memory tag read buf+page_size",
+ patterns=["error: Address range 0x[0-9A-fa-f]+00:0x[0-9A-Fa-f]+10 "
+ "is not in a memory tagged region"],
+ error=True)
+
+ # Tags in start/end are ignored when creating the range.
+ # So this is not an error despite start/end having different tags
+ self.expect("memory tag read buf buf_alt_tag+16 ",
+ patterns=["Logical tag: 0x9\n"
+ "Allocation tags:\n"
+ "\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0$"])
Index: lldb/test/API/linux/aarch64/mte_tag_read/Makefile
===================================================================
--- /dev/null
+++ lldb/test/API/linux/aarch64/mte_tag_read/Makefile
@@ -0,0 +1,4 @@
+C_SOURCES := main.c
+CFLAGS_EXTRAS := -march=armv8.5-a+memtag
+
+include Makefile.rules
Index: lldb/test/API/functionalities/memory/tag/main.cpp
===================================================================
--- /dev/null
+++ lldb/test/API/functionalities/memory/tag/main.cpp
@@ -0,0 +1,4 @@
+int main(int argc, char const *argv[]) {
+ // Breakpoint here
+ return 0;
+}
Index: lldb/test/API/functionalities/memory/tag/TestMemoryTag.py
===================================================================
--- /dev/null
+++ lldb/test/API/functionalities/memory/tag/TestMemoryTag.py
@@ -0,0 +1,35 @@
+"""
+Test errors from 'memory tag' commands on unsupported platforms.
+Tests for the only supported platform, AArch64 Linux, are in
+API/linux/aarch64/.
+"""
+
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+
+
+class MemoryTagTestCase(TestBase):
+
+ mydir = TestBase.compute_mydir(__file__)
+
+ NO_DEBUG_INFO_TESTCASE = True
+
+ def test_memory_tag_read_unsupported(self):
+ """Test that "memory tag read" errors on unsupported platforms"""
+ if self.isAArch64MTE():
+ self.skipTest("Requires a target without AArch64 MTE.")
+
+ self.build()
+ exe = self.getBuildArtifact("a.out")
+ self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+ lldbutil.run_break_set_by_file_and_line(self, "main.cpp",
+ line_number('main.cpp', '// Breakpoint here'),
+ num_expected_locations=1)
+ self.runCmd("run", RUN_SUCCEEDED)
+
+ self.expect("memory tag read 0 1",
+ substrs=["error: This architecture does not support memory tagging"],
+ error=True)
Index: lldb/test/API/functionalities/memory/tag/Makefile
===================================================================
--- /dev/null
+++ lldb/test/API/functionalities/memory/tag/Makefile
@@ -0,0 +1,3 @@
+CXX_SOURCES := main.cpp
+
+include Makefile.rules
Index: lldb/source/Target/Process.cpp
===================================================================
--- lldb/source/Target/Process.cpp
+++ lldb/source/Target/Process.cpp
@@ -6023,3 +6023,70 @@
return false;
}
+
+llvm::Expected<const MemoryTagHandler *>
+Process::GetMemoryTagHandler(lldb::addr_t addr, lldb::addr_t end_addr) {
+ Architecture *arch = GetTarget().GetArchitecturePlugin();
+ const MemoryTagHandler *tag_handler =
+ arch ? arch->GetMemoryTagHandler() : nullptr;
+ if (!arch || !tag_handler) {
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "This architecture does not support memory tagging",
+ GetPluginName().GetCString());
+ }
+
+ if (!SupportsMemoryTagging()) {
+ return llvm::createStringError(llvm::inconvertibleErrorCode(),
+ "Process does not support memory tagging");
+ }
+
+ ptrdiff_t len = tag_handler->AddressDiff(end_addr, addr);
+ if (len <= 0) {
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "End address (0x%x) must be greater than the start address (0x%x)",
+ end_addr, addr);
+ }
+
+ MemoryRegionInfo region;
+ // Region lookup is not tag aware so untag here
+ lldb::addr_t untagged_addr = tag_handler->RemoveLogicalTag(addr);
+ Status status = GetMemoryRegionInfo(untagged_addr, region);
+
+ MemoryRegionInfo::RangeType tag_range(untagged_addr, len);
+ tag_range = tag_handler->AlignToGranules(tag_range);
+
+ if (status.Fail() || region.GetMemoryTagged() != MemoryRegionInfo::eYes ||
+ !region.GetRange().Contains(tag_range)) {
+ // Addresses here will be untagged
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "Address range 0x%lx:0x%lx is not in a memory tagged region",
+ tag_range.GetRangeBase(), tag_range.GetRangeEnd());
+ }
+
+ return tag_handler;
+}
+
+llvm::Expected<std::vector<lldb::addr_t>>
+Process::ReadMemoryTags(const MemoryTagHandler *tag_handler, lldb::addr_t addr,
+ size_t len) {
+ if (!tag_handler) {
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "A memory tag handler is required for reading memory tags.");
+ }
+
+ MemoryTagHandler::TagRange range(tag_handler->RemoveLogicalTag(addr), len);
+ range = tag_handler->AlignToGranules(range);
+
+ llvm::Expected<std::vector<uint8_t>> tag_data =
+ DoReadMemoryTags(range.GetRangeBase(), range.GetByteSize(),
+ tag_handler->GetAllocationTagType());
+ if (!tag_data)
+ return tag_data.takeError();
+
+ return tag_handler->UnpackTags(*tag_data, range.GetByteSize() /
+ tag_handler->GetGranuleSize());
+}
Index: lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
===================================================================
--- lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
+++ lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
@@ -239,6 +239,8 @@
friend class GDBRemoteCommunicationClient;
friend class GDBRemoteRegisterContext;
+ bool SupportsMemoryTagging() override;
+
/// Broadcaster event bits definitions.
enum {
eBroadcastBitAsyncContinue = (1 << 0),
@@ -410,6 +412,9 @@
bool HasErased(FlashRange range);
+ llvm::Expected<std::vector<uint8_t>>
+ DoReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type) override;
+
private:
// For ProcessGDBRemote only
std::string m_partial_profile_data;
Index: lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
===================================================================
--- lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -2757,6 +2757,29 @@
return 0;
}
+bool ProcessGDBRemote::SupportsMemoryTagging() {
+ return m_gdb_comm.GetMemoryTaggingSupported();
+}
+
+llvm::Expected<std::vector<uint8_t>>
+ProcessGDBRemote::DoReadMemoryTags(lldb::addr_t addr, size_t len,
+ int32_t type) {
+ // By this point ReadMemoryTags has validated that tagging is enabled
+ // for this target/process/address.
+ DataBufferSP buffer_sp = m_gdb_comm.ReadMemoryTags(addr, len, type);
+ if (!buffer_sp) {
+ return llvm::createStringError(llvm::inconvertibleErrorCode(),
+ "Error reading memory tags from remote");
+ }
+
+ // Return the raw tag data
+ llvm::ArrayRef<uint8_t> tag_data = buffer_sp->GetData();
+ std::vector<uint8_t> got;
+ got.reserve(tag_data.size());
+ std::copy(tag_data.begin(), tag_data.end(), std::back_inserter(got));
+ return got;
+}
+
Status ProcessGDBRemote::WriteObjectFile(
std::vector<ObjectFile::LoadableData> entries) {
Status error;
Index: lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
===================================================================
--- lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
+++ lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
@@ -446,6 +446,11 @@
bool GetSharedCacheInfoSupported();
+ bool GetMemoryTaggingSupported();
+
+ lldb::DataBufferSP ReadMemoryTags(lldb::addr_t addr, size_t len,
+ int32_t type);
+
/// 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.
@@ -558,6 +563,7 @@
LazyBool m_supports_jGetSharedCacheInfo;
LazyBool m_supports_QPassSignals;
LazyBool m_supports_error_string_reply;
+ LazyBool m_supports_memory_tagging;
bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
m_supports_qUserName : 1, m_supports_qGroupName : 1,
Index: lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
===================================================================
--- lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
+++ lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
@@ -89,6 +89,7 @@
m_supports_jGetSharedCacheInfo(eLazyBoolCalculate),
m_supports_QPassSignals(eLazyBoolCalculate),
m_supports_error_string_reply(eLazyBoolCalculate),
+ m_supports_memory_tagging(eLazyBoolCalculate),
m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
m_supports_qUserName(true), m_supports_qGroupName(true),
m_supports_qThreadStopInfo(true), m_supports_z0(true),
@@ -342,6 +343,7 @@
m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
m_supports_qXfer_features_read = eLazyBoolNo;
m_supports_qXfer_memory_map_read = 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
@@ -433,6 +435,9 @@
else
m_supports_QPassSignals = eLazyBoolNo;
+ if (::strstr(response_cstr, "memory-tagging+"))
+ m_supports_memory_tagging = eLazyBoolYes;
+
const char *packet_size_str = ::strstr(response_cstr, "PacketSize=");
if (packet_size_str) {
StringExtractorGDBRemote packet_response(packet_size_str +
@@ -646,6 +651,57 @@
return m_supports_jGetSharedCacheInfo;
}
+bool GDBRemoteCommunicationClient::GetMemoryTaggingSupported() {
+ if (m_supports_memory_tagging == eLazyBoolCalculate) {
+ GetRemoteQSupported();
+ }
+ return m_supports_memory_tagging == eLazyBoolYes;
+}
+
+DataBufferSP GDBRemoteCommunicationClient::ReadMemoryTags(lldb::addr_t addr,
+ size_t len,
+ int32_t type) {
+ StreamString packet;
+ packet.Printf("qMemTags:%lx,%lx:%x", addr, len, type);
+ StringExtractorGDBRemote response;
+
+ Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_MEMORY);
+
+ if (SendPacketAndWaitForResponse(packet.GetString(), response, false) !=
+ PacketResult::Success ||
+ !response.IsNormalResponse()) {
+ LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s: qMemTags packet failed",
+ __FUNCTION__);
+ return nullptr;
+ }
+
+ // We are expecting
+ // m<hex encoded bytes>
+
+ if (response.GetChar() != 'm') {
+ LLDB_LOGF(log,
+ "GDBRemoteCommunicationClient::%s: qMemTags response did not "
+ "begin with \"m\"",
+ __FUNCTION__);
+ return nullptr;
+ }
+
+ size_t expected_bytes = response.GetBytesLeft() / 2;
+ DataBufferSP buffer_sp(new DataBufferHeap(expected_bytes, 0));
+ size_t got_bytes = response.GetHexBytesAvail(buffer_sp->GetData());
+ // Check both because in some situations chars are consumed even
+ // if the decoding fails.
+ if (response.GetBytesLeft() || (expected_bytes != got_bytes)) {
+ LLDB_LOGF(
+ log,
+ "GDBRemoteCommunicationClient::%s: Invalid data in qMemTags response",
+ __FUNCTION__);
+ return nullptr;
+ }
+
+ return buffer_sp;
+}
+
bool GDBRemoteCommunicationClient::GetxPacketSupported() {
if (m_supports_x == eLazyBoolCalculate) {
StringExtractorGDBRemote response;
Index: lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.h
===================================================================
--- lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.h
+++ lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.h
@@ -22,11 +22,19 @@
eMTE_allocation = 1,
};
+ lldb::addr_t GetLogicalTag(lldb::addr_t addr) const override;
lldb::addr_t RemoveLogicalTag(lldb::addr_t addr) const override;
+ llvm::Expected<lldb::addr_t> SetLogicalTag(lldb::addr_t addr,
+ lldb::addr_t tag) const override;
+ lldb::addr_t CopyLogicalTag(lldb::addr_t from,
+ lldb::addr_t to) const override;
+ ptrdiff_t AddressDiff(lldb::addr_t addr1, lldb::addr_t addr2) const override;
lldb::addr_t GetGranuleSize() const override;
TagRange AlignToGranules(TagRange range) const override;
int32_t GetAllocationTagType() const override;
size_t GetBytesPerTag() const override;
+ llvm::Expected<std::vector<lldb::addr_t>>
+ UnpackTags(const std::vector<uint8_t> &tags, size_t granules) const override;
};
} // namespace lldb_private
Index: lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.cpp
===================================================================
--- lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.cpp
+++ lldb/source/Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.cpp
@@ -15,10 +15,36 @@
static const unsigned MTE_GRANULE_SIZE = 16;
lldb::addr_t
+MemoryTagHandlerAArch64MTE::GetLogicalTag(lldb::addr_t addr) const {
+ return (addr >> MTE_START_BIT) & MTE_TAG_MAX;
+}
+
+lldb::addr_t
MemoryTagHandlerAArch64MTE::RemoveLogicalTag(lldb::addr_t addr) const {
return addr & (~((lldb::addr_t)MTE_TAG_MAX << MTE_START_BIT));
}
+llvm::Expected<lldb::addr_t>
+MemoryTagHandlerAArch64MTE::SetLogicalTag(lldb::addr_t addr,
+ lldb::addr_t tag) const {
+ if (tag > MTE_TAG_MAX)
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "MTE logical tag value is > MTE max value of 0x%x.", MTE_TAG_MAX);
+
+ return RemoveLogicalTag(addr) | (tag << MTE_START_BIT);
+}
+
+lldb::addr_t MemoryTagHandlerAArch64MTE::CopyLogicalTag(lldb::addr_t from,
+ lldb::addr_t to) const {
+ return RemoveLogicalTag(to) | (GetLogicalTag(from) << MTE_START_BIT);
+}
+
+ptrdiff_t MemoryTagHandlerAArch64MTE::AddressDiff(lldb::addr_t addr1,
+ lldb::addr_t addr2) const {
+ return RemoveLogicalTag(addr1) - RemoveLogicalTag(addr2);
+}
+
lldb::addr_t MemoryTagHandlerAArch64MTE::GetGranuleSize() const {
return MTE_GRANULE_SIZE;
}
@@ -49,4 +75,35 @@
new_len += (granule - (new_len % granule));
return TagRange(new_start, new_len);
-}
\ No newline at end of file
+}
+
+llvm::Expected<std::vector<lldb::addr_t>>
+MemoryTagHandlerAArch64MTE::UnpackTags(const std::vector<uint8_t> &tags,
+ size_t granules) const {
+ size_t num_tags = tags.size() / GetBytesPerTag();
+ if (num_tags != granules) {
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "Packed tag data size does not match expected number of tags. "
+ "Expected %" PRIu64 " tag(s) for %" PRIu64 " granules, got %" PRIu64
+ " tag(s).",
+ granules, granules, num_tags);
+ }
+
+ // (if bytes per tag was not 1, we would reconstruct them here)
+
+ std::vector<lldb::addr_t> unpacked;
+ unpacked.reserve(tags.size());
+ for (auto it = tags.begin(); it != tags.end(); ++it) {
+ // Check all tags are in range
+ if (*it > MTE_TAG_MAX) {
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "Found tag 0x%x which is > max MTE tag value of 0x%x.", *it,
+ MTE_TAG_MAX);
+ }
+ unpacked.push_back(*it);
+ }
+
+ return unpacked;
+}
Index: lldb/source/Plugins/Architecture/CMakeLists.txt
===================================================================
--- lldb/source/Plugins/Architecture/CMakeLists.txt
+++ lldb/source/Plugins/Architecture/CMakeLists.txt
@@ -1,3 +1,4 @@
add_subdirectory(Arm)
add_subdirectory(Mips)
add_subdirectory(PPC64)
+add_subdirectory(AArch64)
Index: lldb/source/Plugins/Architecture/AArch64/CMakeLists.txt
===================================================================
--- /dev/null
+++ lldb/source/Plugins/Architecture/AArch64/CMakeLists.txt
@@ -0,0 +1,11 @@
+add_lldb_library(lldbPluginArchitectureAArch64 PLUGIN
+ ArchitectureAArch64.cpp
+
+ LINK_LIBS
+ lldbPluginProcessUtility
+ lldbCore
+ lldbTarget
+ lldbUtility
+ LINK_COMPONENTS
+ Support
+ )
Index: lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.h
===================================================================
--- /dev/null
+++ lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.h
@@ -0,0 +1,40 @@
+//===-- ArchitectureAArch64.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_SOURCE_PLUGINS_ARCHITECTURE_AARCH64_ARCHITECTUREAARCH64_H
+#define LLDB_SOURCE_PLUGINS_ARCHITECTURE_AARCH64_ARCHITECTUREAARCH64_H
+
+#include "Plugins/Process/Utility/MemoryTagHandlerAArch64MTE.h"
+#include "lldb/Core/Architecture.h"
+
+namespace lldb_private {
+
+class ArchitectureAArch64 : public Architecture {
+public:
+ static ConstString GetPluginNameStatic();
+ static void Initialize();
+ static void Terminate();
+
+ ConstString GetPluginName() override;
+ uint32_t GetPluginVersion() override;
+
+ void OverrideStopInfo(Thread &thread) const override{};
+
+ const MemoryTagHandler *GetMemoryTagHandler() const override {
+ return &m_memory_tag_handler;
+ }
+
+private:
+ static std::unique_ptr<Architecture> Create(const ArchSpec &arch);
+ ArchitectureAArch64() = default;
+ MemoryTagHandlerAArch64MTE m_memory_tag_handler;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_ARCHITECTURE_AARCH64_ARCHITECTUREAARCH64_H
Index: lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.cpp
===================================================================
--- /dev/null
+++ lldb/source/Plugins/Architecture/AArch64/ArchitectureAArch64.cpp
@@ -0,0 +1,45 @@
+//===-- ArchitectureAArch64.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 "Plugins/Architecture/AArch64/ArchitectureAArch64.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Utility/ArchSpec.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+LLDB_PLUGIN_DEFINE(ArchitectureAArch64)
+
+ConstString ArchitectureAArch64::GetPluginNameStatic() {
+ return ConstString("aarch64");
+}
+
+void ArchitectureAArch64::Initialize() {
+ PluginManager::RegisterPlugin(GetPluginNameStatic(),
+ "AArch64-specific algorithms",
+ &ArchitectureAArch64::Create);
+}
+
+void ArchitectureAArch64::Terminate() {
+ PluginManager::UnregisterPlugin(&ArchitectureAArch64::Create);
+}
+
+std::unique_ptr<Architecture>
+ArchitectureAArch64::Create(const ArchSpec &arch) {
+ auto machine = arch.GetMachine();
+ if (machine != llvm::Triple::aarch64 && machine != llvm::Triple::aarch64_be &&
+ machine != llvm::Triple::aarch64_32) {
+ return nullptr;
+ }
+ return std::unique_ptr<Architecture>(new ArchitectureAArch64());
+}
+
+ConstString ArchitectureAArch64::GetPluginName() {
+ return GetPluginNameStatic();
+}
+uint32_t ArchitectureAArch64::GetPluginVersion() { return 1; }
Index: lldb/source/Commands/CommandObjectMemoryTag.h
===================================================================
--- /dev/null
+++ lldb/source/Commands/CommandObjectMemoryTag.h
@@ -0,0 +1,25 @@
+//===-- CommandObjectMemoryTag.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_SOURCE_COMMANDS_COMMANDOBJECTMEMORYTAG_H
+#define LLDB_SOURCE_COMMANDS_COMMANDOBJECTMEMORYTAG_H
+
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+
+namespace lldb_private {
+
+class CommandObjectMemoryTag : public CommandObjectMultiword {
+public:
+ CommandObjectMemoryTag(CommandInterpreter &interpreter);
+
+ ~CommandObjectMemoryTag() override;
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_COMMANDS_COMMANDOBJECTMEMORYTAG_H
Index: lldb/source/Commands/CommandObjectMemoryTag.cpp
===================================================================
--- /dev/null
+++ lldb/source/Commands/CommandObjectMemoryTag.cpp
@@ -0,0 +1,123 @@
+//===-- CommandObjectMemoryTag.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 "CommandObjectMemoryTag.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Target/Process.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+#define LLDB_OPTIONS_memory_tag_read
+#include "CommandOptions.inc"
+
+class CommandObjectMemoryTagRead : public CommandObjectParsed {
+public:
+ CommandObjectMemoryTagRead(CommandInterpreter &interpreter)
+ : CommandObjectParsed(interpreter, "tag",
+ "Read memory tags for the given range of memory.",
+ nullptr,
+ eCommandRequiresTarget | eCommandRequiresProcess |
+ eCommandProcessMustBePaused) {
+ // Address
+ m_arguments.push_back(
+ CommandArgumentEntry{CommandArgumentData(eArgTypeAddressOrExpression)});
+ // Optional end address
+ m_arguments.push_back(CommandArgumentEntry{
+ CommandArgumentData(eArgTypeAddressOrExpression, eArgRepeatOptional)});
+ }
+
+ ~CommandObjectMemoryTagRead() override = default;
+
+protected:
+ bool DoExecute(Args &command, CommandReturnObject &result) override {
+ if ((command.GetArgumentCount() < 1) || (command.GetArgumentCount() > 2)) {
+ result.AppendError(
+ "wrong number of arguments; expected at least <address-expression>, "
+ "at most <address-expression> <end-address-expression>");
+ result.SetStatus(eReturnStatusFailed);
+ return false;
+ }
+
+ Status error;
+ addr_t start_addr = OptionArgParser::ToAddress(
+ &m_exe_ctx, command[0].ref(), LLDB_INVALID_ADDRESS, &error);
+ if (start_addr == LLDB_INVALID_ADDRESS) {
+ result.AppendErrorWithFormatv("Invalid address expression, {0}",
+ error.AsCString());
+ result.SetStatus(eReturnStatusFailed);
+ return false;
+ }
+
+ // Default 1 byte beyond start, rounds up to at most 1 granule later
+ addr_t end_addr = start_addr + 1;
+
+ if (command.GetArgumentCount() > 1) {
+ end_addr = OptionArgParser::ToAddress(&m_exe_ctx, command[1].ref(),
+ LLDB_INVALID_ADDRESS, &error);
+ if (end_addr == LLDB_INVALID_ADDRESS) {
+ result.AppendErrorWithFormatv("Invalid end address expression, {0}",
+ error.AsCString());
+ result.SetStatus(eReturnStatusFailed);
+ return false;
+ }
+ }
+
+ Process *process = m_exe_ctx.GetProcessPtr();
+ llvm::Expected<const MemoryTagHandler *> tag_handler_or_err =
+ process->GetMemoryTagHandler(start_addr, end_addr);
+
+ if (!tag_handler_or_err) {
+ result.SetError(Status(tag_handler_or_err.takeError()));
+ result.SetStatus(eReturnStatusFailed);
+ return false;
+ }
+
+ const MemoryTagHandler *tag_handler = *tag_handler_or_err;
+ ptrdiff_t len = tag_handler->AddressDiff(end_addr, start_addr);
+ llvm::Expected<std::vector<lldb::addr_t>> tags =
+ process->ReadMemoryTags(tag_handler, start_addr, len);
+
+ if (!tags) {
+ result.SetError(Status(tags.takeError()));
+ result.SetStatus(eReturnStatusFailed);
+ return false;
+ }
+
+ result.AppendMessageWithFormatv("Logical tag: {0:x}",
+ tag_handler->GetLogicalTag(start_addr));
+ result.AppendMessage("Allocation tags:");
+
+ MemoryTagHandler::TagRange initial_range(start_addr, len);
+ addr_t addr = tag_handler->AlignToGranules(initial_range).GetRangeBase();
+ auto tags_end = tags->end();
+ for (auto tag = tags->begin(); tag != tags_end; ++tag) {
+ addr_t next_addr = addr + tag_handler->GetGranuleSize();
+ // Showing tagged adresses here until we have non address bit handling
+ result.AppendMessageWithFormatv("[{0:x}, {1:x}): {2:x}", addr, next_addr,
+ *tag);
+ addr = next_addr;
+ }
+
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+};
+
+CommandObjectMemoryTag::CommandObjectMemoryTag(CommandInterpreter &interpreter)
+ : CommandObjectMultiword(
+ interpreter, "tag", "Commands for manipulating memory tags",
+ "memory tag <sub-command> [<sub-command-options>]") {
+ CommandObjectSP read_command_object(
+ new CommandObjectMemoryTagRead(interpreter));
+ read_command_object->SetCommandName("memory tag read");
+ LoadSubCommand("read", read_command_object);
+}
+
+CommandObjectMemoryTag::~CommandObjectMemoryTag() = default;
Index: lldb/source/Commands/CommandObjectMemory.cpp
===================================================================
--- lldb/source/Commands/CommandObjectMemory.cpp
+++ lldb/source/Commands/CommandObjectMemory.cpp
@@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "CommandObjectMemory.h"
+#include "CommandObjectMemoryTag.h"
#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/ValueObjectMemory.h"
@@ -1758,6 +1759,8 @@
CommandObjectSP(new CommandObjectMemoryHistory(interpreter)));
LoadSubCommand("region",
CommandObjectSP(new CommandObjectMemoryRegion(interpreter)));
+ LoadSubCommand("tag",
+ CommandObjectSP(new CommandObjectMemoryTag(interpreter)));
}
CommandObjectMemory::~CommandObjectMemory() = default;
Index: lldb/source/Commands/CMakeLists.txt
===================================================================
--- lldb/source/Commands/CMakeLists.txt
+++ lldb/source/Commands/CMakeLists.txt
@@ -16,6 +16,7 @@
CommandObjectLanguage.cpp
CommandObjectLog.cpp
CommandObjectMemory.cpp
+ CommandObjectMemoryTag.cpp
CommandObjectMultiword.cpp
CommandObjectPlatform.cpp
CommandObjectPlugin.cpp
Index: lldb/packages/Python/lldbsuite/test/lldbtest.py
===================================================================
--- lldb/packages/Python/lldbsuite/test/lldbtest.py
+++ lldb/packages/Python/lldbsuite/test/lldbtest.py
@@ -1269,7 +1269,7 @@
return True
return False
- def isAArch64SVE(self):
+ def hasLinuxCPUInfoFeature(self, feature):
triple = self.dbg.GetSelectedPlatform().GetTriple()
# TODO other platforms, please implement this function
@@ -1290,7 +1290,19 @@
except:
return False
- return " sve " in cpuinfo
+ features = []
+ for line in cpuinfo.splitlines():
+ if line.startswith("Features"):
+ features = line.split(':')[1].split()
+ break
+
+ return feature in features
+
+ def isAArch64SVE(self):
+ return self.hasLinuxCPUInfoFeature("sve")
+
+ def isAArch64MTE(self):
+ return self.hasLinuxCPUInfoFeature("mte")
def hasLinuxVmFlags(self):
""" Check that the target machine has "VmFlags" lines in
Index: lldb/include/lldb/Target/Process.h
===================================================================
--- lldb/include/lldb/Target/Process.h
+++ lldb/include/lldb/Target/Process.h
@@ -1695,6 +1695,44 @@
lldb::addr_t CallocateMemory(size_t size, uint32_t permissions,
Status &error);
+ /// If the address range given is in a memory tagged range and this
+ /// architecture and process supports memory tagging, return a tag
+ /// handler that can be used to maniupulate those memory tags.
+ /// Tags present in the addresses given are ignored.
+ ///
+ /// \param[in] addr
+ /// Start of memory range.
+ ///
+ /// \param[in] end_addr
+ /// End of the memory range. Where end is one beyond the last byte to be
+ /// included.
+ ///
+ /// \return
+ /// Either a valid pointer to a tag handler or an error describing why one
+ /// could not be provided.
+ llvm::Expected<const MemoryTagHandler *>
+ GetMemoryTagHandler(lldb::addr_t addr, lldb::addr_t end_addr);
+
+ /// Expands the range addr to addr+len to align with granule boundaries and
+ /// then calls DoReadMemoryTags to do the target specific operations.
+ /// Tags are returned unpacked so can be used without conversion.
+ ///
+ /// \param[in] tag_handler
+ /// The tag_handler to get memory tagging information from.
+ ///
+ /// \param[in] addr
+ /// Start of memory range to tags for.
+ ///
+ /// \param[in] len
+ /// Length of memory range to read tags for (in bytes).
+ ///
+ /// \return
+ /// Either the unpacked tags or an error describing a failure to read
+ /// or unpack them.
+ llvm::Expected<std::vector<lldb::addr_t>>
+ ReadMemoryTags(const MemoryTagHandler *tag_handler, lldb::addr_t addr,
+ size_t len);
+
/// Resolve dynamically loaded indirect functions.
///
/// \param[in] address
@@ -2708,6 +2746,36 @@
/// false.
bool RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp);
+ /// Check whether the remote supports memory tagging.
+ ///
+ /// \return
+ /// true if the remote supports memory tagging,
+ /// false otherwise.
+ virtual bool SupportsMemoryTagging() { return false; }
+
+ /// Does the final operation to read memory tags. E.g. sending a GDB packet.
+ /// It assumes that ReadMemoryTags has checked that memory tagging is enabled
+ /// and has expanded the memory range as needed.
+ ///
+ /// \param[in] addr
+ /// Start of address range to read memory tags for.
+ ///
+ /// \param[in] len
+ /// Length of the memory range to read tags for (in bytes).
+ ///
+ /// \param[in] type
+ /// Type of tags to read (get this from a MemoryTagHandler)
+ ///
+ /// \return
+ /// The packed tag data received from the remote or an error
+ /// if the read failed.
+ virtual llvm::Expected<std::vector<uint8_t>>
+ DoReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type) {
+ return llvm::createStringError(llvm::inconvertibleErrorCode(),
+ "%s does not support reading memory tags",
+ GetPluginName().GetCString());
+ }
+
// Type definitions
typedef std::map<lldb::LanguageType, lldb::LanguageRuntimeSP>
LanguageRuntimeCollection;
Index: lldb/include/lldb/Target/MemoryTagHandler.h
===================================================================
--- lldb/include/lldb/Target/MemoryTagHandler.h
+++ lldb/include/lldb/Target/MemoryTagHandler.h
@@ -29,9 +29,30 @@
public:
typedef Range<lldb::addr_t, size_t> TagRange;
+ // Extract the logical tag from a pointer
+ // The tag is returned as a plain value, with any shifts removed.
+ // For example if your tags are stored in bits 56-60 then the logical tag
+ // you get will have been shifted down 56 before being returned.
+ virtual lldb::addr_t GetLogicalTag(lldb::addr_t addr) const = 0;
+
// Remove the logical tag, returning the untagged pointer
virtual lldb::addr_t RemoveLogicalTag(lldb::addr_t addr) const = 0;
+ // Set a new logical tag in a pointer, overwriting any existing tag
+ // The new tag does not need to be shifted, that is done for you.
+ // Errors if the tag is out of the valid tag value range
+ virtual llvm::Expected<lldb::addr_t>
+ SetLogicalTag(lldb::addr_t addr, lldb::addr_t tag) const = 0;
+
+ // Copy the logical tag from one pointer to another.
+ virtual lldb::addr_t CopyLogicalTag(lldb::addr_t from,
+ lldb::addr_t to) const = 0;
+
+ // Return the difference between two addresses, ignoring any logical tags they
+ // have.
+ virtual ptrdiff_t AddressDiff(lldb::addr_t addr1,
+ lldb::addr_t addr2) const = 0;
+
// Return the number of bytes a single tag covers
virtual lldb::addr_t GetGranuleSize() const = 0;
@@ -60,6 +81,13 @@
// transport.
virtual size_t GetBytesPerTag() const = 0;
+ // Unpack tags from their stored format (e.g. gdb qMemTags data) into seperate
+ // tags. Checks that each tag is within the expected value range and that the
+ // number of tags found matches the number of granules we originally asked
+ // for.
+ virtual llvm::Expected<std::vector<lldb::addr_t>>
+ UnpackTags(const std::vector<uint8_t> &tags, size_t granules) const = 0;
+
virtual ~MemoryTagHandler() {}
};
Index: lldb/include/lldb/Core/Architecture.h
===================================================================
--- lldb/include/lldb/Core/Architecture.h
+++ lldb/include/lldb/Core/Architecture.h
@@ -10,6 +10,7 @@
#define LLDB_CORE_ARCHITECTURE_H
#include "lldb/Core/PluginInterface.h"
+#include "lldb/Target/MemoryTagHandler.h"
namespace lldb_private {
@@ -97,6 +98,17 @@
Target &target) const {
return addr;
}
+
+ // Returns a pointer to an object that can handle memory tags for this
+ // Architecture E.g. masking out tags, unpacking tag streams etc. Returns
+ // nullptr if the architecture does not have a memory tagging extension.
+ //
+ // The return pointer being valid does not mean that the current process has
+ // memory tagging enabled, just that a tagging technology exists for this
+ // architecture.
+ virtual const MemoryTagHandler *GetMemoryTagHandler() const {
+ return nullptr;
+ }
};
} // namespace lldb_private
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
