gdb/testsuite/gdb.arch/aarch64-mte.exp - binutils-gdb - Git at Google

 # Copyright (C) 2021 Free Software Foundation, Inc.

 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.

 # Test a binary that uses MTE and exercise various MTE-related scenarios.

 global hex
 global decimal

 # Return TAG in hex format with no leading zeroes.
 proc get_hex_tag { tag } {
     return [format "%x" $tag]
 }

 # Return TAG in the NN format where N is 4 bits of the byte.
 proc get_tag_nn { tag } {
     return [format "%02x" $tag]
 }

 # Return the address of PTR with a tag of TAG.
 proc get_tagged_ptr { tag ptr } {
   set addr [get_hexadecimal_valueof $ptr -1]
   return [get_valueof "/x" \
 	      "${addr} & (0xf0ffffffffffffff) | ((unsigned long) ${tag} << 56)" \
 	      "0" "fetch pointer ${ptr} with tag ${tag}"]
 }

 # Return the logical TAG from PTR.
 proc get_ltag_from_ptr { ptr } {
   set addr [get_hexadecimal_valueof $ptr -1]
   return [get_valueof "/x" "${addr} >> 56 & 0xf" -1 \
 		      "fetch tag from pointer ${ptr}"]
 }

 if {![is_aarch64_target]} {
     verbose "Skipping ${gdb_test_file_name}."
     return
 }

 standard_testfile
 if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
     return -1
 }

 if ![runto_main] {
     return -1
 }

 # Targets that don't support memory tagging should not execute the
 # runtime memory tagging tests.
 if {![supports_memtag]} {
     unsupported "memory tagging unsupported"
     return -1
 }

 gdb_breakpoint "access_memory"

 if [gdb_continue "access_memory"] {
     return -1
 }

 # Fetch a known pointer to an area mapped with PROT_MTE.
 set tagged_ptr_symbol "tagged_ptr"
 set tagged_ptr_addr [get_hexadecimal_valueof $tagged_ptr_symbol -1]

 if {$tagged_ptr_addr == -1} {
     unresolved "unexpected pointer or tag value"
     return -1
 }

 # Fetch a known pointer to an area not mapped with PROT_MTE.
 set untagged_ptr_symbol "untagged_ptr"
 set untagged_ptr_addr [get_hexadecimal_valueof $untagged_ptr_symbol -1]

 if {$untagged_ptr_addr == -1} {
     unresolved "unexpected pointer or tag value"
     return -1
 }

 with_test_prefix "literals" {
     # Test inspecting an allocation tag from a pointer to a memory area that
     # is not mapped with PROT_MTE.
     set msg "Address ${untagged_ptr_addr} not in a region mapped with a memory tagging flag\."
     gdb_test "memory-tag print-allocation-tag ${untagged_ptr_addr}" $msg \
 	     "memory-tag print-allocation-tag with an untagged address"

     gdb_test "memory-tag set-allocation-tag ${untagged_ptr_addr} 1 00" $msg \
 	     "memory-tag set-allocation-tag with an untagged address"

     set addr_tagged 0
     set addr_tagged_valid 0

     # Test setting and showing the logical tags for a literal address.
     for {set i 0} {$i < 32} {incr i} {
 	with_test_prefix "tag ${i}" {
 	    set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
 	}

 	set tag_hexnz [get_hex_tag [expr $i % 16]]
 	gdb_test "memory-tag print-logical-tag ${addr_tagged}" \
 		 " = 0x${tag_hexnz}" \
 		 "print-logical-tag with tag ${i}"

 	set tag_hexnn [get_tag_nn $i]
 	gdb_test "memory-tag with-logical-tag ${addr_tagged} ${tag_hexnn}" \
 		 " = \\(void \\*\\) ${addr_tagged}" \
 		 "with-logical-tag with tag ${i}"
     }

     set atag_msg "Allocation tag\\(s\\) updated successfully\."
     # Test setting and showing the allocation tags.
     for {set i 0} {$i < 32} {incr i} {

 	set tag_hexnn [get_tag_nn $i]
 	gdb_test "memory-tag set-allocation-tag ${tagged_ptr_addr} 1 ${tag_hexnn}" \
 		 $atag_msg \
 		 "set-allocation-tag with tag ${i}"

 	set tag_hexnz [get_hex_tag [expr $i % 16]]
 	gdb_test "memory-tag print-allocation-tag ${tagged_ptr_addr}" " = 0x${tag_hexnz}" \
 		 "print-allocation-tag with tag ${i}"
     }

     # Test tag mismatches.
     with_test_prefix "tag mismatches" {
 	for {set i 0} {$i < 32} {incr i} {

 	    # Set the allocation tag to a known value.
 	    set tag_hexnn [get_tag_nn $i]
 	    gdb_test "memory-tag set-allocation-tag ${tagged_ptr_addr} 1 ${tag_hexnn}" \
 		     $atag_msg \
 		     "set-allocation-tag with tag ${i}"

 	    set atag_hexnz [get_hex_tag [expr $i % 16]]

 	    # Validate that the logical tag matches the allocation tag.
 	    with_test_prefix "tag ${i}" {
 		set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
 	    }

 	    gdb_test "memory-tag check ${addr_tagged}" \
 		     "Memory tags for address $hex match \\(0x${atag_hexnz}\\)\." \
 		     "check match with tag ${i}"

 	    # Get a pointer with the logical tag that does not match the
 	    # allocation tag.
 	    set ltag [expr $i + 1]
 	    with_test_prefix "fetch mismatch tag ${i}" {
 		set addr_tagged [get_tagged_ptr $ltag ${tagged_ptr_addr}]
 	    }

 	    # Validate that the logical tag does not match the allocation
 	    # tag.
 	    set ltag_hexnz [get_hex_tag [expr [expr $i + 1]% 16]]
 	    gdb_test "memory-tag check ${addr_tagged}" \
 		     "Logical tag \\(0x${ltag_hexnz}\\) does not match the allocation tag \\(0x${atag_hexnz}\\) for address $hex\." \
 		     "check mismatch with tag ${i}"
 	}
     }
 }

 with_test_prefix "symbolic" {
     # Test inspecting an allocation tag from a pointer to a memory area that
     # is not mapped with PROT_MTE.
     set msg "Address ${untagged_ptr_addr} not in a region mapped with a memory tagging flag\."
     gdb_test "memory-tag print-allocation-tag ${untagged_ptr_symbol}" $msg \
 	     "memory-tag print-allocation-tag with an untagged address"

     gdb_test "memory-tag set-allocation-tag ${untagged_ptr_symbol} 1 00" $msg \
 	     "memory-tag set-allocation-tag with an untagged address"

     # Test setting and showing the logical tags for a literal address.
     for {set i 0} {$i < 32} {incr i} {
 	set addr_tagged 0

 	with_test_prefix "tag ${i}" {
 	    set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
 	    gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
 			       "update value of symbol ${tagged_ptr_symbol}"
 	}

 	set tag_hexnz [get_hex_tag [expr $i % 16]]
 	gdb_test "memory-tag print-logical-tag ${tagged_ptr_symbol}" \
 		 " = 0x${tag_hexnz}" \
 		 "print-logical-tag with tag ${i}"

 	set tag_hexnn [get_tag_nn $i]
 	gdb_test "memory-tag with-logical-tag ${tagged_ptr_symbol} ${tag_hexnn}" \
 		 " = \\(void \\*\\) ${addr_tagged}" \
 		 "with-logical-tag with tag ${i}"
     }

     # Reset the tagged ptr to its original value
     gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${tagged_ptr_addr}" \
 		       "reset ${tagged_ptr_symbol} to ${tagged_ptr_addr}"

     set atag_msg "Allocation tag\\(s\\) updated successfully\."
     # Test setting and showing the allocation tags.
     for {set i 0} {$i < 32} {incr i} {

 	set tag_hexnn [get_tag_nn $i]
 	gdb_test "memory-tag set-allocation-tag ${tagged_ptr_symbol} 1 ${tag_hexnn}" \
 		 $atag_msg \
 		 "set-allocation-tag with tag ${i}"

 	set tag_hexnz [get_hex_tag [expr $i % 16]]
 	gdb_test "memory-tag print-allocation-tag ${tagged_ptr_symbol}" \
 		 " = 0x${tag_hexnz}" \
 		 "print-allocation-tag with tag ${i}"
     }

     # Test tag mismatches.
     with_test_prefix "tag mismatches" {
 	for {set i 0} {$i < 32} {incr i} {

 	    # Set the allocation tag to a known value (0).
 	    set tag_hexnn [get_tag_nn $i]
 	    gdb_test "memory-tag set-allocation-tag ${tagged_ptr_symbol} 1 ${tag_hexnn}" \
 		     $atag_msg \
 		     "set-allocation-tag with tag ${i}"

 	    set atag_hexnz [get_hex_tag [expr $i % 16]]

 	    # Validate that the logical tag matches the allocation tag.
 	    with_test_prefix "tag ${i}" {
 		set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
 	    }

 	    with_test_prefix "tag ${i}" {
 		gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
 				   "set ${tagged_ptr_symbol} to a matching logical tag"
 	    }

 	    gdb_test "memory-tag check ${tagged_ptr_symbol}" \
 		     "Memory tags for address $hex match \\(0x${atag_hexnz}\\)\." \
 		     "check match with tag ${i}"

 	    # Get a pointer with the logical tag that does not match the
 	    # allocation tag.
 	    set ltag [expr $i + 1]
 	    with_test_prefix "fetch mismatch tag ${i}" {
 		set addr_tagged [get_tagged_ptr $ltag ${tagged_ptr_addr}]
 	    }

 	    with_test_prefix "tag ${i}" {
 		gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
 				   "set ${tagged_ptr_symbol} to a mismatching logical tag"
 	    }

 	    # Validate that the logical tag does not match the allocation
 	    # tag.
 	    set ltag_hexnz [get_hex_tag [expr [expr $i + 1]% 16]]
 	    gdb_test "memory-tag check ${tagged_ptr_symbol}" \
 		     "Logical tag \\(0x${ltag_hexnz}\\) does not match the allocation tag \\(0x${atag_hexnz}\\) for address $hex\." \
 		     "check mismatch with tag ${i}"
 	}
 	# Reset the tagged ptr to its original value
 	gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${tagged_ptr_addr}" \
 			   "reset ${tagged_ptr_symbol} to ${tagged_ptr_addr}"
     }
 }

 # Test the memory tagging extensions for the "print" command.
 with_test_prefix "print command" {
     set untagged_ptr [get_tagged_ptr 0 ${tagged_ptr_addr}]

     with_test_prefix "fetch ltag" {
 	set ltag [get_ltag_from_ptr ${tagged_ptr_addr}]
     }

     if {$ltag == -1} {
 	unresolved "unexpected tag value"
 	return -1
     }

     set atag [expr [expr $ltag + 1] % 16]
     set atag_hexnn [get_tag_nn $atag]

     gdb_test "memory-tag set-allocation-tag ${tagged_ptr_symbol} 1 ${atag_hexnn}" \
 	     $atag_msg \
 	     "make atag and ltag different"

     set atag_hexnz [get_hex_tag $atag]
     gdb_test "p/x ${tagged_ptr_symbol}" \
 	[multi_line \
 	    "Logical tag \\(${ltag}\\) does not match the allocation tag \\(0x${atag_hexnz}\\)\." \
 	    "\\\$\[0-9\]+ = ${untagged_ptr}"] \
 	    "show tag mismatch"
 }

 # Test the memory tagging extensions for the "x" command.
 with_test_prefix "x command" {

     # Check if the allocation tags match what we expect.
     gdb_test "x/gxm ${tagged_ptr_symbol}" \
 	[multi_line \
 	    "<Allocation Tag $hex for range \\\[$hex,$hex\\)>" \
 	    "$hex:\[ \t\]+$hex"] \
 	"outputs tag information"

     # Also make sure no tag information is output for memory areas without
     # PROT_MTE mappings.
     gdb_test "x/gxm ${untagged_ptr_symbol}" \
 	     "$hex:\[ \t\]+$hex" \
 	     "does not output tag information"
 }

 # Validate the presence of the MTE registers.
 foreach reg {"tag_ctl" } {
     gdb_test "info registers $reg" \
 	     "$reg\[ \t\]+$hex\[ \t\]+$decimal" \
 	     "register $reg available"
 }

 # Run until a crash and confirm GDB displays memory tag violation
 # information.
 gdb_test "continue" \
     [multi_line \
 	"Program received signal SIGSEGV, Segmentation fault" \
 	"Memory tag violation while accessing address $hex" \
 	"Allocation tag $hex" \
 	"Logical tag $hex\." \
 	"$hex in access_memory \\(.*\\) at .*" \
 	".*tagged_ptr\\\[0\\\] = 'a';"] \
 	 "display tag violation information"

 # Restart to execute the async tag fault test.
 with_test_prefix "async" {
     if ![runto_main] {
 	return -1
     }

     gdb_breakpoint "access_memory"

     if [gdb_continue "access_memory"] {
 	fail "could not run to tagged memory test function"
 	return -1
     }

     # Force a tag fault.
     gdb_test "memory-tag set-allocation-tag tagged_ptr 1 05" \
 	     $atag_msg \
 	     "make atag and ltag different"

     # Force the tag fault to be async.
     gdb_test_no_output "set \$tag_ctl=0x7fff5" "set tag_ctl to async"

     # Run until a crash and confirm GDB displays memory tag violation
     # information for async mode
     gdb_test "continue" \
 	[multi_line \
 	    "Program received signal SIGSEGV, Segmentation fault" \
 	    "Memory tag violation" \
 	    "Fault address unavailable\." \
 	    "$hex in .* \\(.*\\) .*"] \
 	    "display tag violation information"
 }
	# Copyright (C) 2021 Free Software Foundation, Inc.

	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 3 of the License, or
	# (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.

	# Test a binary that uses MTE and exercise various MTE-related scenarios.

	global hex
	global decimal

	# Return TAG in hex format with no leading zeroes.
	proc get_hex_tag { tag } {
	return [format "%x" $tag]
	}

	# Return TAG in the NN format where N is 4 bits of the byte.
	proc get_tag_nn { tag } {
	return [format "%02x" $tag]
	}

	# Return the address of PTR with a tag of TAG.
	proc get_tagged_ptr { tag ptr } {
	set addr [get_hexadecimal_valueof $ptr -1]
	return [get_valueof "/x" \
	"${addr} & (0xf0ffffffffffffff) \| ((unsigned long) ${tag} << 56)" \
	"0" "fetch pointer ${ptr} with tag ${tag}"]
	}

	# Return the logical TAG from PTR.
	proc get_ltag_from_ptr { ptr } {
	set addr [get_hexadecimal_valueof $ptr -1]
	return [get_valueof "/x" "${addr} >> 56 & 0xf" -1 \
	"fetch tag from pointer ${ptr}"]
	}

	if {![is_aarch64_target]} {
	verbose "Skipping ${gdb_test_file_name}."
	return
	}

	standard_testfile
	if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
	return -1
	}

	if ![runto_main] {
	return -1
	}

	# Targets that don't support memory tagging should not execute the
	# runtime memory tagging tests.
	if {![supports_memtag]} {
	unsupported "memory tagging unsupported"
	return -1
	}

	gdb_breakpoint "access_memory"

	if [gdb_continue "access_memory"] {
	return -1
	}

	# Fetch a known pointer to an area mapped with PROT_MTE.
	set tagged_ptr_symbol "tagged_ptr"
	set tagged_ptr_addr [get_hexadecimal_valueof $tagged_ptr_symbol -1]

	if {$tagged_ptr_addr == -1} {
	unresolved "unexpected pointer or tag value"
	return -1
	}

	# Fetch a known pointer to an area not mapped with PROT_MTE.
	set untagged_ptr_symbol "untagged_ptr"
	set untagged_ptr_addr [get_hexadecimal_valueof $untagged_ptr_symbol -1]

	if {$untagged_ptr_addr == -1} {
	unresolved "unexpected pointer or tag value"
	return -1
	}

	with_test_prefix "literals" {
	# Test inspecting an allocation tag from a pointer to a memory area that
	# is not mapped with PROT_MTE.
	set msg "Address ${untagged_ptr_addr} not in a region mapped with a memory tagging flag\."
	gdb_test "memory-tag print-allocation-tag ${untagged_ptr_addr}" $msg \
	"memory-tag print-allocation-tag with an untagged address"

	gdb_test "memory-tag set-allocation-tag ${untagged_ptr_addr} 1 00" $msg \
	"memory-tag set-allocation-tag with an untagged address"

	set addr_tagged 0
	set addr_tagged_valid 0

	# Test setting and showing the logical tags for a literal address.
	for {set i 0} {$i < 32} {incr i} {
	with_test_prefix "tag ${i}" {
	set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
	}

	set tag_hexnz [get_hex_tag [expr $i % 16]]
	gdb_test "memory-tag print-logical-tag ${addr_tagged}" \
	" = 0x${tag_hexnz}" \
	"print-logical-tag with tag ${i}"

	set tag_hexnn [get_tag_nn $i]
	gdb_test "memory-tag with-logical-tag ${addr_tagged} ${tag_hexnn}" \
	" = \\(void \\*\\) ${addr_tagged}" \
	"with-logical-tag with tag ${i}"
	}

	set atag_msg "Allocation tag\\(s\\) updated successfully\."
	# Test setting and showing the allocation tags.
	for {set i 0} {$i < 32} {incr i} {

	set tag_hexnn [get_tag_nn $i]
	gdb_test "memory-tag set-allocation-tag ${tagged_ptr_addr} 1 ${tag_hexnn}" \
	$atag_msg \
	"set-allocation-tag with tag ${i}"

	set tag_hexnz [get_hex_tag [expr $i % 16]]
	gdb_test "memory-tag print-allocation-tag ${tagged_ptr_addr}" " = 0x${tag_hexnz}" \
	"print-allocation-tag with tag ${i}"
	}

	# Test tag mismatches.
	with_test_prefix "tag mismatches" {
	for {set i 0} {$i < 32} {incr i} {

	# Set the allocation tag to a known value.
	set tag_hexnn [get_tag_nn $i]
	gdb_test "memory-tag set-allocation-tag ${tagged_ptr_addr} 1 ${tag_hexnn}" \
	$atag_msg \
	"set-allocation-tag with tag ${i}"

	set atag_hexnz [get_hex_tag [expr $i % 16]]

	# Validate that the logical tag matches the allocation tag.
	with_test_prefix "tag ${i}" {
	set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
	}

	gdb_test "memory-tag check ${addr_tagged}" \
	"Memory tags for address $hex match \\(0x${atag_hexnz}\\)\." \
	"check match with tag ${i}"

	# Get a pointer with the logical tag that does not match the
	# allocation tag.
	set ltag [expr $i + 1]
	with_test_prefix "fetch mismatch tag ${i}" {
	set addr_tagged [get_tagged_ptr $ltag ${tagged_ptr_addr}]
	}

	# Validate that the logical tag does not match the allocation
	# tag.
	set ltag_hexnz [get_hex_tag [expr [expr $i + 1]% 16]]
	gdb_test "memory-tag check ${addr_tagged}" \
	"Logical tag \\(0x${ltag_hexnz}\\) does not match the allocation tag \\(0x${atag_hexnz}\\) for address $hex\." \
	"check mismatch with tag ${i}"
	}
	}
	}

	with_test_prefix "symbolic" {
	# Test inspecting an allocation tag from a pointer to a memory area that
	# is not mapped with PROT_MTE.
	set msg "Address ${untagged_ptr_addr} not in a region mapped with a memory tagging flag\."
	gdb_test "memory-tag print-allocation-tag ${untagged_ptr_symbol}" $msg \
	"memory-tag print-allocation-tag with an untagged address"

	gdb_test "memory-tag set-allocation-tag ${untagged_ptr_symbol} 1 00" $msg \
	"memory-tag set-allocation-tag with an untagged address"

	# Test setting and showing the logical tags for a literal address.
	for {set i 0} {$i < 32} {incr i} {
	set addr_tagged 0

	with_test_prefix "tag ${i}" {
	set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
	gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
	"update value of symbol ${tagged_ptr_symbol}"
	}

	set tag_hexnz [get_hex_tag [expr $i % 16]]
	gdb_test "memory-tag print-logical-tag ${tagged_ptr_symbol}" \
	" = 0x${tag_hexnz}" \
	"print-logical-tag with tag ${i}"

	set tag_hexnn [get_tag_nn $i]
	gdb_test "memory-tag with-logical-tag ${tagged_ptr_symbol} ${tag_hexnn}" \
	" = \\(void \\*\\) ${addr_tagged}" \
	"with-logical-tag with tag ${i}"
	}

	# Reset the tagged ptr to its original value
	gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${tagged_ptr_addr}" \
	"reset ${tagged_ptr_symbol} to ${tagged_ptr_addr}"

	set atag_msg "Allocation tag\\(s\\) updated successfully\."
	# Test setting and showing the allocation tags.
	for {set i 0} {$i < 32} {incr i} {

	set tag_hexnn [get_tag_nn $i]
	gdb_test "memory-tag set-allocation-tag ${tagged_ptr_symbol} 1 ${tag_hexnn}" \
	$atag_msg \
	"set-allocation-tag with tag ${i}"

	set tag_hexnz [get_hex_tag [expr $i % 16]]
	gdb_test "memory-tag print-allocation-tag ${tagged_ptr_symbol}" \
	" = 0x${tag_hexnz}" \
	"print-allocation-tag with tag ${i}"
	}

	# Test tag mismatches.
	with_test_prefix "tag mismatches" {
	for {set i 0} {$i < 32} {incr i} {

	# Set the allocation tag to a known value (0).
	set tag_hexnn [get_tag_nn $i]
	gdb_test "memory-tag set-allocation-tag ${tagged_ptr_symbol} 1 ${tag_hexnn}" \
	$atag_msg \
	"set-allocation-tag with tag ${i}"

	set atag_hexnz [get_hex_tag [expr $i % 16]]

	# Validate that the logical tag matches the allocation tag.
	with_test_prefix "tag ${i}" {
	set addr_tagged [get_tagged_ptr $i ${tagged_ptr_addr}]
	}

	with_test_prefix "tag ${i}" {
	gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
	"set ${tagged_ptr_symbol} to a matching logical tag"
	}

	gdb_test "memory-tag check ${tagged_ptr_symbol}" \
	"Memory tags for address $hex match \\(0x${atag_hexnz}\\)\." \
	"check match with tag ${i}"

	# Get a pointer with the logical tag that does not match the
	# allocation tag.
	set ltag [expr $i + 1]
	with_test_prefix "fetch mismatch tag ${i}" {
	set addr_tagged [get_tagged_ptr $ltag ${tagged_ptr_addr}]
	}

	with_test_prefix "tag ${i}" {
	gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${addr_tagged}" \
	"set ${tagged_ptr_symbol} to a mismatching logical tag"
	}

	# Validate that the logical tag does not match the allocation
	# tag.
	set ltag_hexnz [get_hex_tag [expr [expr $i + 1]% 16]]
	gdb_test "memory-tag check ${tagged_ptr_symbol}" \
	"Logical tag \\(0x${ltag_hexnz}\\) does not match the allocation tag \\(0x${atag_hexnz}\\) for address $hex\." \
	"check mismatch with tag ${i}"
	}
	# Reset the tagged ptr to its original value
	gdb_test_no_output "set variable ${tagged_ptr_symbol} = ${tagged_ptr_addr}" \
	"reset ${tagged_ptr_symbol} to ${tagged_ptr_addr}"
	}
	}

	# Test the memory tagging extensions for the "print" command.
	with_test_prefix "print command" {
	set untagged_ptr [get_tagged_ptr 0 ${tagged_ptr_addr}]

	with_test_prefix "fetch ltag" {
	set ltag [get_ltag_from_ptr ${tagged_ptr_addr}]
	}

	if {$ltag == -1} {
	unresolved "unexpected tag value"
	return -1
	}

	set atag [expr [expr $ltag + 1] % 16]
	set atag_hexnn [get_tag_nn $atag]

	gdb_test "memory-tag set-allocation-tag ${tagged_ptr_symbol} 1 ${atag_hexnn}" \
	$atag_msg \
	"make atag and ltag different"

	set atag_hexnz [get_hex_tag $atag]
	gdb_test "p/x ${tagged_ptr_symbol}" \
	[multi_line \
	"Logical tag \\(${ltag}\\) does not match the allocation tag \\(0x${atag_hexnz}\\)\." \
	"\\\$\[0-9\]+ = ${untagged_ptr}"] \
	"show tag mismatch"
	}

	# Test the memory tagging extensions for the "x" command.
	with_test_prefix "x command" {

	# Check if the allocation tags match what we expect.
	gdb_test "x/gxm ${tagged_ptr_symbol}" \
	[multi_line \
	"<Allocation Tag $hex for range \\\[$hex,$hex\\)>" \
	"$hex:\[ \t\]+$hex"] \
	"outputs tag information"

	# Also make sure no tag information is output for memory areas without
	# PROT_MTE mappings.
	gdb_test "x/gxm ${untagged_ptr_symbol}" \
	"$hex:\[ \t\]+$hex" \
	"does not output tag information"
	}

	# Validate the presence of the MTE registers.
	foreach reg {"tag_ctl" } {
	gdb_test "info registers $reg" \
	"$reg\[ \t\]+$hex\[ \t\]+$decimal" \
	"register $reg available"
	}

	# Run until a crash and confirm GDB displays memory tag violation
	# information.
	gdb_test "continue" \
	[multi_line \
	"Program received signal SIGSEGV, Segmentation fault" \
	"Memory tag violation while accessing address $hex" \
	"Allocation tag $hex" \
	"Logical tag $hex\." \
	"$hex in access_memory \\(.\\) at ." \
	".*tagged_ptr\\\[0\\\] = 'a';"] \
	"display tag violation information"

	# Restart to execute the async tag fault test.
	with_test_prefix "async" {
	if ![runto_main] {
	return -1
	}

	gdb_breakpoint "access_memory"

	if [gdb_continue "access_memory"] {
	fail "could not run to tagged memory test function"
	return -1
	}

	# Force a tag fault.
	gdb_test "memory-tag set-allocation-tag tagged_ptr 1 05" \
	$atag_msg \
	"make atag and ltag different"

	# Force the tag fault to be async.
	gdb_test_no_output "set \$tag_ctl=0x7fff5" "set tag_ctl to async"

	# Run until a crash and confirm GDB displays memory tag violation
	# information for async mode
	gdb_test "continue" \
	[multi_line \
	"Program received signal SIGSEGV, Segmentation fault" \
	"Memory tag violation" \
	"Fault address unavailable\." \
	"$hex in .* \\(.\\) ."] \
	"display tag violation information"
	}