forked from Imagelibrary/binutils-gdb
c6727038aa
Reusing the SME tests, this patch introduces additional tests to exercise reading/writing ZT0, availability of the register set, signal context reading for ZT0 and also core file generation. Reviewed-by: Thiago Jung Bauermann <thiago.bauermann@linaro.org>
263 lines
8.7 KiB
Tcl
263 lines
8.7 KiB
Tcl
# Copyright (C) 2023 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/>.
|
|
|
|
# Exercise reading/writing ZA registers when there is ZA state.
|
|
# Exercise reading/writing to ZT0 when there is ZA state available.
|
|
|
|
load_lib aarch64-scalable.exp
|
|
|
|
#
|
|
# Cycle through all ZA registers and pseudo-registers and validate that their
|
|
# contents are available for vector length SVL.
|
|
#
|
|
# Make sure reading/writing to ZA registers work as expected.
|
|
#
|
|
proc check_regs { mode vl svl } {
|
|
# Check VG to make sure it is correct
|
|
set expected_vg [expr $vl / 8]
|
|
gdb_test "print \$vg" "= ${expected_vg}"
|
|
|
|
# Check SVG to make sure it is correct
|
|
set expected_svg [expr $svl / 8]
|
|
gdb_test "print \$svg" "= ${expected_svg}"
|
|
|
|
# If svl is adjusted by prctl, we will have ZA enabled. If gdb is
|
|
# adjusting svl, ZA will not be enabled by default. It will only be
|
|
# enabled when ZA is written to.
|
|
set za_state "= \\\[ ZA \\\]"
|
|
if {$mode == "gdb"} {
|
|
set za_state "= \\\[ \\\]"
|
|
}
|
|
|
|
# Check SVCR.
|
|
if [gdb_test "print \$svcr" $za_state "svcr before assignments" ] {
|
|
fail "incorrect za state"
|
|
return -1
|
|
}
|
|
|
|
# Check the size of ZA.
|
|
set expected_za_size [expr $svl * $svl]
|
|
gdb_test "print sizeof \$za" " = $expected_za_size"
|
|
|
|
# Check the size of Z0.
|
|
gdb_test "print sizeof \$z0" " = $vl"
|
|
|
|
# Exercise reading/writing from/to ZA.
|
|
initialize_2d_array "\$za" 255 $svl $svl
|
|
set pattern [string_to_regexp [2d_array_value_pattern 255 $svl $svl]]
|
|
gdb_test "print \$za" " = $pattern" "read back from za"
|
|
|
|
# Exercise reading/writing from/to the tile pseudo-registers.
|
|
set last_tile 1
|
|
set expected_size [expr $svl * $svl]
|
|
set tile_svl $svl
|
|
set za_state "= \\\[ ZA \\\]"
|
|
foreach_with_prefix granularity {"b" "h" "s" "d" "q"} {
|
|
for {set tile 0} {$tile < $last_tile} {incr tile} {
|
|
set register_name "\$za${tile}${granularity}"
|
|
|
|
# Test the size.
|
|
gdb_test "print sizeof ${register_name}" " = ${expected_size}"
|
|
|
|
# Test reading/writing
|
|
initialize_2d_array $register_name 255 $tile_svl $tile_svl
|
|
|
|
# Make sure we have ZA state.
|
|
if [gdb_test "print \$svcr" $za_state "svcr after assignment to ${register_name}" ] {
|
|
fail "incorrect za state"
|
|
return -1
|
|
}
|
|
|
|
set pattern [string_to_regexp [2d_array_value_pattern 255 $tile_svl $tile_svl]]
|
|
gdb_test "print $register_name" " = $pattern" "read back from $register_name"
|
|
}
|
|
set last_tile [expr $last_tile * 2]
|
|
set expected_size [expr $expected_size / 2]
|
|
set tile_svl [expr $tile_svl / 2]
|
|
}
|
|
|
|
# Exercise reading/writing from/to the tile slice pseudo-registers.
|
|
set last_tile 1
|
|
set last_slice $svl
|
|
set expected_size $svl
|
|
set num_elements $svl
|
|
foreach_with_prefix granularity {"b" "h" "s" "d" "q"} {
|
|
for {set tile 0} {$tile < $last_tile} {incr tile} {
|
|
for {set slice 0} {$slice < $last_slice} {incr slice} {
|
|
foreach_with_prefix direction {"h" "v"} {
|
|
set register_name "\$za${tile}${direction}${granularity}${slice}"
|
|
|
|
# Test the size.
|
|
gdb_test "print sizeof ${register_name}" " = ${expected_size}"
|
|
|
|
# Test reading/writing
|
|
initialize_1d_array $register_name 255 $num_elements
|
|
|
|
# Make sure we have ZA state.
|
|
if [gdb_test "print \$svcr" $za_state "svcr after assignment of ${register_name}" ] {
|
|
fail "incorrect za state"
|
|
return -1
|
|
}
|
|
|
|
set pattern [string_to_regexp [1d_array_value_pattern 255 $num_elements]]
|
|
gdb_test "print $register_name" " = $pattern" "read back from $register_name"
|
|
}
|
|
}
|
|
}
|
|
set last_tile [expr $last_tile * 2]
|
|
set last_slice [expr ($last_slice / 2)]
|
|
set num_elements [expr $num_elements / 2]
|
|
}
|
|
|
|
# Exercise reading/writing from/to SME2 registers.
|
|
if [is_sme2_available] {
|
|
# The target supports SME2.
|
|
set zt_size 64
|
|
gdb_test "print sizeof \$zt0" " = $zt_size"
|
|
|
|
# Initially, when ZA is activated, ZT0 will be all zeroes.
|
|
set zt_pattern [string_to_regexp [1d_array_value_pattern 0 $zt_size]]
|
|
gdb_test "print \$zt0" " = $zt_pattern" "validate zeroed zt0"
|
|
|
|
# Validate that writing to ZT0 does the right thing.
|
|
initialize_1d_array "\$zt0" 255 $zt_size
|
|
set zt_pattern [string_to_regexp [1d_array_value_pattern 255 $zt_size]]
|
|
gdb_test "print \$zt0" " = $zt_pattern" "read back from zt0"
|
|
}
|
|
}
|
|
|
|
#
|
|
# Cycle through all ZA registers and pseudo-registers and validate their
|
|
# contents.
|
|
#
|
|
proc test_sme_registers_available { id_start id_end } {
|
|
|
|
set compile_flags {"debug" "macros"}
|
|
lappend compile_flags "additional_flags=-DID_START=${id_start}"
|
|
lappend compile_flags "additional_flags=-DID_END=${id_end}"
|
|
|
|
standard_testfile ${::srcdir}/${::subdir}/aarch64-sme-regs-available.c
|
|
set executable "${::testfile}-${id_start}-${id_end}"
|
|
if {[prepare_for_testing "failed to prepare" ${executable} ${::srcfile} ${compile_flags}]} {
|
|
return -1
|
|
}
|
|
set binfile [standard_output_file ${executable}]
|
|
|
|
if ![runto_main] {
|
|
untested "could not run to main"
|
|
return -1
|
|
}
|
|
|
|
# Check if we are talking to a remote target. If so, bail out, as right now
|
|
# remote targets can't communicate vector length (vl or svl) changes to gdb
|
|
# via the RSP. When this restriction is lifted, we can remove this guard.
|
|
if {[gdb_is_target_remote]} {
|
|
unsupported "aarch64 sve/sme tests not supported for remote targets"
|
|
return -1
|
|
}
|
|
|
|
gdb_test_no_output "set print repeats 1"
|
|
|
|
set prctl_breakpoint "stop 1"
|
|
gdb_breakpoint [gdb_get_line_number $prctl_breakpoint]
|
|
|
|
for {set id $id_start} {$id <= $id_end} {incr id} {
|
|
set vl [test_id_to_vl $id]
|
|
set svl [test_id_to_svl $id]
|
|
|
|
set skip_unsupported 0
|
|
if {![aarch64_supports_sve_vl $vl]
|
|
|| ![aarch64_supports_sme_svl $svl]} {
|
|
# We have a vector length or streaming vector length that
|
|
# is not supported by this target. Skip to the next iteration
|
|
# since it is no use running tests for an unsupported vector
|
|
# length.
|
|
if {![aarch64_supports_sve_vl $vl]} {
|
|
verbose -log "SVE vector length $vl not supported."
|
|
} elseif {![aarch64_supports_sme_svl $svl]} {
|
|
verbose -log "SME streaming vector length $svl not supported."
|
|
}
|
|
verbose -log "Skipping test."
|
|
set skip_unsupported 1
|
|
}
|
|
|
|
set mode "prctl"
|
|
with_test_prefix "$mode, vl=${vl} svl=${svl}" {
|
|
# If the SVE or SME vector length is not supported, just skip
|
|
# these next tests.
|
|
if {$skip_unsupported} {
|
|
untested "unsupported configuration on target"
|
|
continue
|
|
}
|
|
|
|
# Run the program until it has adjusted svl.
|
|
gdb_continue_to_breakpoint $prctl_breakpoint
|
|
check_regs $mode $vl $svl
|
|
}
|
|
}
|
|
|
|
set non_prctl_breakpoint "stop 2"
|
|
gdb_breakpoint [gdb_get_line_number $non_prctl_breakpoint]
|
|
|
|
for {set id $id_start} {$id <= $id_end} {incr id} {
|
|
set vl [test_id_to_vl $id]
|
|
set svl [test_id_to_svl $id]
|
|
|
|
set skip_unsupported 0
|
|
if {![aarch64_supports_sve_vl $vl]
|
|
|| ![aarch64_supports_sme_svl $svl]} {
|
|
# We have a vector length or streaming vector length that
|
|
# is not supported by this target. Skip to the next iteration
|
|
# since it is no use running tests for an unsupported vector
|
|
# length.
|
|
if {![aarch64_supports_sve_vl $vl]} {
|
|
verbose -log "SVE vector length $vl not supported."
|
|
} elseif {![aarch64_supports_sme_svl $svl]} {
|
|
verbose -log "SME streaming vector length $svl not supported."
|
|
}
|
|
verbose -log "Skipping test."
|
|
set skip_unsupported 1
|
|
}
|
|
|
|
set mode "gdb"
|
|
with_test_prefix "$mode, vl=${vl} svl=${svl}" {
|
|
# If the SVE or SME vector length is not supported, just skip
|
|
# these next tests.
|
|
if {$skip_unsupported} {
|
|
untested "unsupported configuration on target"
|
|
continue
|
|
}
|
|
|
|
# Run the program until we stop at the point where gdb should
|
|
# adjust the SVE and SME vector lengths.
|
|
gdb_continue_to_breakpoint $non_prctl_breakpoint
|
|
|
|
# Adjust svl via gdb.
|
|
set vg_value [expr $vl / 8]
|
|
set svg_value [expr $svl / 8]
|
|
gdb_test_no_output "set \$vg = ${vg_value}"
|
|
gdb_test_no_output "set \$svg = ${svg_value}"
|
|
|
|
check_regs $mode $vl $svl
|
|
}
|
|
}
|
|
}
|
|
|
|
require is_aarch64_target
|
|
require allow_aarch64_sve_tests
|
|
require allow_aarch64_sme_tests
|
|
|
|
test_sme_registers_available $id_start $id_end
|