mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2025-02-05 12:53:16 +08:00
1d506c26d9
This commit is the result of the following actions:
- Running gdb/copyright.py to update all of the copyright headers to
include 2024,
- Manually updating a few files the copyright.py script told me to
update, these files had copyright headers embedded within the
file,
- Regenerating gdbsupport/Makefile.in to refresh it's copyright
date,
- Using grep to find other files that still mentioned 2023. If
these files were updated last year from 2022 to 2023 then I've
updated them this year to 2024.
I'm sure I've probably missed some dates. Feel free to fix them up as
you spot them.
366 lines
12 KiB
Plaintext
366 lines
12 KiB
Plaintext
# Copyright (C) 2021-2024 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}"]
|
|
}
|
|
|
|
require is_aarch64_target
|
|
|
|
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"
|
|
}
|