"""
Test "memory tag read" and "memory tag write" commands
on AArch64 Linux with MTE.
"""
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
class AArch64LinuxMTEMemoryTagAccessTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True
def setup_mte_test(self):
if not self.isAArch64MTE():
self.skipTest("Target must support MTE.")
# Required to check that commands remove non-address bits
# other than the memory tags.
if not self.isAArch64PAuth():
self.skipTest("Target must support pointer authentication")
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"],
)
@skipUnlessArch("aarch64")
@skipUnlessPlatform(["linux"])
@skipUnlessAArch64MTELinuxCompiler
def test_mte_tag_read(self):
self.setup_mte_test()
# 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 mte_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 mte_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 mte_buf mte_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 mte_buf mte_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 mte_buf",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0 \(mismatch\)$"
],
)
# Range of <1 granule is rounded up to 1 granule
self.expect(
"memory tag read mte_buf mte_buf+8",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0 \(mismatch\)$"
],
)
# Start address is aligned down, end aligned up
self.expect(
"memory tag read mte_buf+8 mte_buf+24",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+10, 0x[0-9A-Fa-f]+20\): 0x1 \(mismatch\)$"
],
)
# You may read up to the end of the tagged region
# Layout is mte_buf, mte_buf_2, non_mte_buf.
# So we read from the end of mte_buf_2 here.
self.expect(
"memory tag read mte_buf_2+page_size-16 mte_buf_2+page_size",
patterns=[
"Logical tag: 0x0\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+, 0x[0-9A-Fa-f]+\): 0x0$"
],
)
# Ranges with any part outside the region will error
self.expect(
"memory tag read mte_buf_2+page_size-16 mte_buf_2+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 mte_buf_2+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,
)
# You can read a range that spans more than one mapping
# This spills into mte_buf2 which is also MTE
self.expect(
"memory tag read mte_buf+page_size-16 mte_buf+page_size+16",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+f0, 0x[0-9A-Fa-f]+00\): 0xf \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0 \(mismatch\)$"
],
)
# Top byte is ignored when creating the range, not just the 4 tag bits.
# So even though these two pointers have different top bytes
# and the start's is > the end's, this is not an error.
self.expect(
"memory tag read mte_buf_alt_tag mte_buf+16",
patterns=[
"Logical tag: 0xa\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x0 \(mismatch\)$"
],
)
# Mismatched tags are marked. The logical tag is taken from the start address.
self.expect(
"memory tag read mte_buf+(8*16) mte_buf_alt_tag+(8*16)+48",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+80, 0x[0-9A-Fa-f]+90\): 0x8 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+90, 0x[0-9A-Fa-f]+a0\): 0x9\n"
"\[0x[0-9A-Fa-f]+a0, 0x[0-9A-Fa-f]+b0\): 0xa \(mismatch\)$"
],
)
@skipUnlessArch("aarch64")
@skipUnlessPlatform(["linux"])
@skipUnlessAArch64MTELinuxCompiler
def test_mte_tag_write(self):
self.setup_mte_test()
# Argument validation
self.expect(
"memory tag write",
substrs=[
" wrong number of arguments; expected "
"<address-expression> <tag> [<tag> [...]]"
],
error=True,
)
self.expect(
"memory tag write mte_buf",
substrs=[
" wrong number of arguments; expected "
"<address-expression> <tag> [<tag> [...]]"
],
error=True,
)
self.expect(
"memory tag write not_a_symbol 9",
substrs=[
'error: Invalid address expression, address expression "not_a_symbol" '
"evaluation failed"
],
error=True,
)
# Can't write to a region without tagging
self.expect(
"memory tag write non_mte_buf 9",
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,
)
# Start address is aligned down so we write to the granule that contains it
self.expect("memory tag write mte_buf+8 9")
# Make sure we only modified the first granule
self.expect(
"memory tag read mte_buf mte_buf+32",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x9\n"
"\[0x[0-9A-Fa-f]+10, 0x[0-9A-Fa-f]+20\): 0x1 \(mismatch\)$"
],
)
# You can write multiple tags, range calculated for you
self.expect("memory tag write mte_buf 10 11 12")
self.expect(
"memory tag read mte_buf mte_buf+48",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0xa \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+10, 0x[0-9A-Fa-f]+20\): 0xb \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+20, 0x[0-9A-Fa-f]+30\): 0xc \(mismatch\)$"
],
)
# You may write up to the end of a tagged region
# (mte_buf_2's intial tags will all be 0)
self.expect("memory tag write mte_buf_2+page_size-16 0xe")
self.expect(
"memory tag read mte_buf_2+page_size-16 mte_buf_2+page_size",
patterns=[
"Logical tag: 0x0\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+, 0x[0-9A-Fa-f]+\): 0xe \(mismatch\)$"
],
)
# Ranges with any part outside the region will error
self.expect(
"memory tag write mte_buf_2+page_size-16 6 7",
patterns=[
"error: Address range 0x[0-9A-Fa-f]+f0:0x[0-9A-Fa-f]+10 "
"is not in a memory tagged region"
],
error=True,
)
self.expect(
"memory tag write mte_buf_2+page_size 6",
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,
)
self.expect(
"memory tag write mte_buf_2+page_size 6 7 8",
patterns=[
"error: Address range 0x[0-9A-Fa-f]+00:0x[0-9A-Fa-f]+30 "
"is not in a memory tagged region"
],
error=True,
)
# You can write to a range that spans two mappings, as long
# as they are both tagged.
# buf and buf2 are next to each other so this wirtes into buf2.
self.expect("memory tag write mte_buf+page_size-16 1 2")
self.expect(
"memory tag read mte_buf+page_size-16 mte_buf+page_size+16",
patterns=[
"Logical tag: 0x9\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+f0, 0x[0-9A-Fa-f]+00\): 0x1 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x2 \(mismatch\)$"
],
)
# Even if a page is read only the debugger can still write to it
self.expect("memory tag write mte_read_only 1")
self.expect(
"memory tag read mte_read_only",
patterns=[
"Logical tag: 0x0\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x1 \(mismatch\)$"
],
)
# Trying to write a value > maximum tag value is an error
self.expect(
"memory tag write mte_buf 99",
patterns=["error: Found tag 0x63 which is > max MTE tag value of 0xf."],
error=True,
)
# You can provide an end address and have lldb repeat the tags as needed
# The range is checked in the same way it is for "memory tag read"
self.expect(
"memory tag write mte_buf 9 -e",
patterns=["error: last option requires an argument"],
error=True,
)
self.expect(
"memory tag write mte_buf 9 -e food",
patterns=['error: address expression "food" evaluation failed'],
error=True,
)
self.expect(
"memory tag write mte_buf_2 9 --end-addr mte_buf_2",
patterns=[
"error: End address \(0x[A-Fa-f0-9]+\) must be "
"greater than the start address \(0x[A-Fa-f0-9]+\)"
],
error=True,
)
self.expect(
"memory tag write mte_buf_2 9 --end-addr mte_buf_2-16",
patterns=[
"error: End address \(0x[A-Fa-f0-9]+\) must be "
"greater than the start address \(0x[A-Fa-f0-9]+\)"
],
error=True,
)
self.expect(
"memory tag write mte_buf_2 9 --end-addr mte_buf_2+page_size+16",
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 are repeated across the range
# For these we'll read one extra to make sure we don't over write
self.expect("memory tag write mte_buf_2 4 5 --end-addr mte_buf_2+48")
self.expect(
"memory tag read mte_buf_2 mte_buf_2+64",
patterns=[
"Logical tag: 0x0\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x4 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+10, 0x[0-9A-Fa-f]+20\): 0x5 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+20, 0x[0-9A-Fa-f]+30\): 0x4 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+30, 0x[0-9A-Fa-f]+40\): 0x0$"
],
)
# Since this aligns like tag read does, the start is aligned down and the end up.
# Meaning that start/end tells you the start/end granule that will be written.
# This matters particularly if either are misaligned.
# Here start moves down so the final range is mte_buf_2 -> mte_buf_2+32
self.expect("memory tag write mte_buf_2+8 6 -end-addr mte_buf_2+32")
self.expect(
"memory tag read mte_buf_2 mte_buf_2+48",
patterns=[
"Logical tag: 0x0\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x6 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+10, 0x[0-9A-Fa-f]+20\): 0x6 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+20, 0x[0-9A-Fa-f]+30\): 0x4 \(mismatch\)$"
],
)
# If we do the same with a misaligned end, it also moves but upward.
# The intial range is 2 granules but the final range is mte_buf_2 -> mte_buf_2+48
self.expect("memory tag write mte_buf_2+8 3 -end-addr mte_buf_2+32+8")
self.expect(
"memory tag read mte_buf_2 mte_buf_2+64",
patterns=[
"Logical tag: 0x0\n"
"Allocation tags:\n"
"\[0x[0-9A-Fa-f]+00, 0x[0-9A-Fa-f]+10\): 0x3 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+10, 0x[0-9A-Fa-f]+20\): 0x3 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+20, 0x[0-9A-Fa-f]+30\): 0x3 \(mismatch\)\n"
"\[0x[0-9A-Fa-f]+30, 0x[0-9A-Fa-f]+40\): 0x0$"
],
)
@skipUnlessArch("aarch64")
@skipUnlessPlatform(["linux"])
@skipUnlessAArch64MTELinuxCompiler
def test_mte_memory_read_tag_display(self):
self.setup_mte_test()
# Reading from an untagged range should not be any different
self.expect(
"memory read non_mte_buf non_mte_buf+16", substrs=["tag"], matching=False
)
# show-tags option is required
self.expect(
'memory read mte_buf mte_buf+32 -f "x" -l 1 -s 16',
patterns=["tag"],
matching=False,
)
# Reading 16 bytes per line means 1 granule and so 1 tag per line
self.expect(
'memory read mte_buf mte_buf+32 -f "x" -l 1 -s 16 --show-tags',
patterns=[
"0x[0-9A-Fa-f]+00: 0x0+ \(tag: 0x0\)\n"
"0x[0-9A-Fa-f]+10: 0x0+ \(tag: 0x1\)"
],
)
# If bytes per line is > granule size then you get multiple tags
# per line.
self.expect(
'memory read mte_buf mte_buf+32 -f "x" -l 1 -s 32 --show-tags',
patterns=["0x[0-9A-Fa-f]+00: 0x0+ \(tags: 0x0 0x1\)\n"],
)
# Reading half a granule still shows you the tag for that granule
self.expect(
'memory read mte_buf mte_buf+8 -f "x" -l 1 -s 8 --show-tags',
patterns=["0x[0-9A-Fa-f]+00: 0x0+ \(tag: 0x0\)\n"],
)
# We can read a whole number of granules but split them over more lines
# than there are granules. Tags are shown repeated for each applicable line.
self.expect(
'memory read mte_buf+32 mte_buf+64 -f "x" -l 1 -s 8 --show-tags',
patterns=[
"0x[0-9A-Fa-f]+20: 0x0+ \(tag: 0x2\)\n"
"0x[0-9A-Fa-f]+28: 0x0+ \(tag: 0x2\)\n"
"0x[0-9A-Fa-f]+30: 0x0+ \(tag: 0x3\)\n"
"0x[0-9A-Fa-f]+38: 0x0+ \(tag: 0x3\)"
],
)
# Also works if we misalign the start address. Note the first tag is shown
# only once here and we have a new tag on the last line.
# (bytes per line == the misalignment here)
self.expect(
'memory read mte_buf+32+8 mte_buf+64+8 -f "x" -l 1 -s 8 --show-tags',
patterns=[
"0x[0-9A-Fa-f]+28: 0x0+ \(tag: 0x2\)\n"
"0x[0-9A-Fa-f]+30: 0x0+ \(tag: 0x3\)\n"
"0x[0-9A-Fa-f]+38: 0x0+ \(tag: 0x3\)\n"
"0x[0-9A-Fa-f]+40: 0x0+ \(tag: 0x4\)"
],
)
# We can do the same thing but where the misaligment isn't equal to
# bytes per line. This time, some lines cover multiple granules and
# so show multiple tags.
self.expect(
'memory read mte_buf+32+4 mte_buf+64+4 -f "x" -l 1 -s 8 --show-tags',
patterns=[
"0x[0-9A-Fa-f]+24: 0x0+ \(tag: 0x2\)\n"
"0x[0-9A-Fa-f]+2c: 0x0+ \(tags: 0x2 0x3\)\n"
"0x[0-9A-Fa-f]+34: 0x0+ \(tag: 0x3\)\n"
"0x[0-9A-Fa-f]+3c: 0x0+ \(tags: 0x3 0x4\)"
],
)
# If you read a range that includes non tagged areas those areas
# simply aren't annotated.
# Initial part of range is untagged
self.expect(
'memory read mte_buf-16 mte_buf+32 -f "x" -l 1 -s 16 --show-tags',
patterns=[
"0x[0-9A-Fa-f]+f0: 0x0+\n"
"0x[0-9A-Fa-f]+00: 0x0+ \(tag: 0x0\)\n"
"0x[0-9A-Fa-f]+10: 0x0+ \(tag: 0x1\)"
],
)
# End of range is untagged
self.expect(
'memory read mte_buf+page_size-16 mte_buf+page_size+16 -f "x" -l 1 -s 16 --show-tags',
patterns=["0x[0-9A-Fa-f]+f0: 0x0+ \(tag: 0xf\)\n" "0x[0-9A-Fa-f]+00: 0x0+"],
)
# The smallest MTE range we can get is a single page so we just check
# parts of this result. Where we read from before the tagged page to after it.
# Add --force here because we're reading just over 4k.
self.expect(
'memory read mte_read_only-16 mte_read_only+page_size+16 -f "x" -l 1 -s 16 --force --show-tags',
patterns=[
"0x[0-9A-Fa-f]+f0: 0x0+\n" "0x[0-9A-Fa-f]+00: 0x0+ \(tag: 0x0\)\n",
"0x[0-9A-Fa-f]+f0: 0x0+ \(tag: 0x0\)\n" "0x[0-9A-Fa-f]+00: 0x0+",
],
)
# Some parts of a line might be tagged and others untagged.
# <no tag> is shown in where the tag would be, to keep the order intact.
self.expect(
'memory read mte_buf-16 mte_buf+32 -f "x" -l 1 -s 32 --show-tags',
patterns=["0x[0-9A-Fa-f]+f0: 0x0+ \(tags: <no tag> 0x0\)"],
)
self.expect(
'memory read mte_read_only+page_size-16 mte_read_only+page_size+16 -f "x" -l 1 -s 32 --show-tags',
patterns=["0x[0-9A-Fa-f]+f0: 0x0+ \(tags: 0x0 <no tag>\)"],
)
# Here the start address is unaligned so we cover 3 granules instead of 2
self.expect(
'memory read mte_buf-16+4 mte_buf+32+4 -f "x" -l 1 -s 32 --show-tags',
patterns=["0x[0-9A-Fa-f]+f4: 0x0+ \(tags: <no tag> 0x0 0x1\)"],
)
self.expect(
'memory read mte_read_only+page_size-16+4 mte_read_only+page_size+16+4 -f "x" -l 1 -s 32 --show-tags',
patterns=["0x[0-9A-Fa-f]+f4: 0x0+ \(tags: 0x0 <no tag> <no tag>\)"],
)
# Some formats call DumpDataExtractor multiple times,
# check that those print tags only once per line.
self.expect(
'memory read mte_buf mte_buf+32 -f "x" --show-tags',
patterns=[
"0x[0-9A-Fa-f]+00: 0x0+ 0x0+ 0x0+ 0x0+ \(tag: 0x0\)\n",
"0x[0-9A-Fa-f]+10: 0x0+ 0x0+ 0x0+ 0x0+ \(tag: 0x1\)",
],
)
self.expect(
'memory read mte_buf mte_buf+32 -f "bytes with ASCII" --show-tags',
patterns=[
"0x[0-9A-Fa-f]+00: (00 ){16} \.{16} \(tag: 0x0\)\n",
"0x[0-9A-Fa-f]+10: (00 ){16} \.{16} \(tag: 0x1\)",
],
)
self.expect(
'memory read mte_buf mte_buf+32 -f "uint8_t[]" -s 16 -l 1 --show-tags',
patterns=[
"0x[0-9A-Fa-f]+00: \{(0x00 ){15}0x00\} \(tag: 0x0\)\n"
"0x[0-9A-Fa-f]+10: \{(0x00 ){15}0x00\} \(tag: 0x1\)"
],
)
@skipUnlessArch("aarch64")
@skipUnlessPlatform(["linux"])
@skipUnlessAArch64MTELinuxCompiler
def test_mte_memory_read_tag_display_repeated(self):
"""Test that the --show-tags option is kept when repeating the memory read command."""
self.setup_mte_test()
self.expect(
'memory read mte_buf mte_buf+16 -f "x" --show-tags',
patterns=["0x[0-9A-fa-f]+00: 0x0+ 0x0+ 0x0+ 0x0+ \(tag: 0x0\)"],
)
# Equivalent to just pressing enter on the command line.
self.expect(
"memory read",
patterns=["0x[0-9A-fa-f]+10: 0x0+ 0x0+ 0x0+ 0x0+ \(tag: 0x1\)"],
)
# You can add the argument to an existing repetition without resetting
# the whole command. Though all other optional arguments will reset to
# their default values when you do this.
self.expect(
'memory read mte_buf mte_buf+16 -f "x"',
patterns=["0x[0-9A-fa-f]+00: 0x0+ 0x0+ 0x0+ 0x0+"],
)
self.expect("memory read", patterns=["0x[0-9A-fa-f]+10: 0x0+ 0x0+ 0x0+ 0x0+"])
# Note that the formatting returns to default here.
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\)",
],
)
Codebase Browser
llvm