]>
Commit | Line | Data |
---|---|---|
1d506c26 | 1 | # Copyright (C) 2023-2024 Free Software Foundation, Inc. |
16582a51 LM |
2 | |
3 | # This program is free software; you can redistribute it and/or modify | |
4 | # it under the terms of the GNU General Public License as published by | |
5 | # the Free Software Foundation; either version 3 of the License, or | |
6 | # (at your option) any later version. | |
7 | # | |
8 | # This program is distributed in the hope that it will be useful, | |
9 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | # GNU General Public License for more details. | |
12 | # | |
13 | # You should have received a copy of the GNU General Public License | |
14 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
15 | ||
16 | # Exercise the following: | |
17 | # - Printing ZA registers when there is no ZA state. | |
18 | # - Setting values of ZA registers when there is no ZA state. | |
19 | # - Validating ZA state is activated when we write to ZA registers. | |
c6727038 | 20 | # - Validate that reading ZT0 without an active ZA state works as expected. |
16582a51 LM |
21 | |
22 | load_lib aarch64-scalable.exp | |
23 | ||
24 | # | |
25 | # Validate that the ZA registers have the expected state. | |
26 | # | |
27 | proc_with_prefix check_regs { vl svl } { | |
28 | # Check VG to make sure it is correct | |
29 | set expected_vg [expr $vl / 8] | |
30 | gdb_test "print \$vg" "= ${expected_vg}" | |
31 | ||
32 | # Check SVG to make sure it is correct | |
33 | set expected_svg [expr $svl / 8] | |
34 | gdb_test "print \$svg" "= ${expected_svg}" | |
35 | ||
36 | # Make sure there is no SM or ZA state. | |
37 | if [gdb_test "print \$svcr" "= \\\[ \\\]"] { | |
38 | fail "incorrect ZA state" | |
39 | return -1 | |
40 | } | |
41 | ||
42 | # Check the size of ZA. | |
43 | set expected_za_size [expr $svl * $svl] | |
44 | gdb_test "print sizeof \$za" " = $expected_za_size" | |
45 | ||
46 | # Check the size of Z0. | |
47 | gdb_test "print sizeof \$z0" " = $vl" | |
48 | ||
49 | # Set the expected ZA pattern. | |
50 | set za_pattern [string_to_regexp [2d_array_value_pattern 0 $svl $svl]] | |
51 | ||
52 | # Check ZA. | |
53 | gdb_test "print \$za" $za_pattern | |
54 | ||
55 | # Exercise reading/writing the tile slice pseudo-registers. | |
56 | set last_tile 1 | |
57 | set last_slice $svl | |
58 | set elements $svl | |
59 | set expected_size $svl | |
60 | foreach_with_prefix granularity {"b" "h" "s" "d" "q"} { | |
61 | set pattern [string_to_regexp [1d_array_value_pattern 0 $elements]] | |
62 | for {set tile 0} {$tile < $last_tile} {incr tile} { | |
63 | for {set slice 0} {$slice < $last_slice} {incr slice} { | |
64 | foreach_with_prefix direction {"h" "v"} { | |
65 | set register_name "\$za${tile}${direction}${granularity}${slice}" | |
66 | # Test the size. | |
67 | gdb_test "print sizeof ${register_name}" " = ${expected_size}" | |
68 | gdb_test "print ${register_name}" $pattern | |
69 | } | |
70 | } | |
71 | } | |
72 | set last_tile [expr $last_tile * 2] | |
73 | set last_slice [expr ($last_slice / 2)] | |
74 | set elements [expr ($elements / 2)] | |
75 | } | |
76 | ||
77 | # Exercise reading/writing the tile pseudo-registers. | |
78 | set last_tile 1 | |
79 | set elements $svl | |
80 | set expected_size [expr $svl * $svl] | |
81 | foreach_with_prefix granularity {"b" "h" "s" "d" "q"} { | |
82 | set pattern [string_to_regexp [2d_array_value_pattern 0 $elements $elements]] | |
83 | for {set tile 0} {$tile < $last_tile} {incr tile} { | |
84 | set register_name "\$za${tile}${granularity}" | |
85 | # Test the size. | |
86 | gdb_test "print sizeof ${register_name}" " = ${expected_size}" | |
87 | gdb_test "print ${register_name}" $pattern | |
88 | } | |
89 | set last_tile [expr $last_tile * 2] | |
90 | set expected_size [expr $expected_size / 2] | |
91 | set elements [expr ($elements / 2)] | |
92 | } | |
c6727038 LM |
93 | |
94 | # Exercise reading from SME2 registers. | |
95 | if [is_sme2_available] { | |
96 | # The target supports SME2. | |
97 | set zt_size 64 | |
98 | gdb_test "print sizeof \$zt0" " = $zt_size" | |
99 | ||
100 | # If ZA is not active, ZT0 will always be zero. | |
101 | set zt_pattern [string_to_regexp [1d_array_value_pattern 0 $zt_size]] | |
102 | gdb_test "print \$zt0" " = $zt_pattern" | |
103 | } | |
16582a51 LM |
104 | } |
105 | ||
106 | # | |
107 | # Cycle through all ZA registers and pseudo-registers and validate that their | |
108 | # contents are unavailable (zeroed out) for vector length SVL. | |
109 | # | |
110 | proc test_sme_registers_unavailable { id_start id_end } { | |
111 | ||
112 | set compile_flags {"debug" "macros"} | |
113 | lappend compile_flags "additional_flags=-DID_START=${id_start}" | |
114 | lappend compile_flags "additional_flags=-DID_END=${id_end}" | |
115 | ||
116 | standard_testfile ${::srcdir}/${::subdir}/aarch64-sme-regs-unavailable.c | |
117 | set executable "${::testfile}-${id_start}-${id_end}" | |
118 | if {[prepare_for_testing "failed to prepare" ${executable} ${::srcfile} ${compile_flags}]} { | |
119 | return -1 | |
120 | } | |
121 | set binfile [standard_output_file ${executable}] | |
122 | ||
16582a51 LM |
123 | # Check if we are talking to a remote target. If so, bail out, as right now |
124 | # remote targets can't communicate vector length (vl or svl) changes to gdb | |
125 | # via the RSP. When this restriction is lifted, we can remove this guard. | |
5fec7411 | 126 | if {[gdb_protocol_is_remote]} { |
16582a51 LM |
127 | unsupported "aarch64 sve/sme tests not supported for remote targets" |
128 | return -1 | |
129 | } | |
130 | ||
5fec7411 PA |
131 | if ![runto_main] { |
132 | untested "could not run to main" | |
133 | return -1 | |
134 | } | |
135 | ||
16582a51 LM |
136 | gdb_test_no_output "set print repeats 1" |
137 | ||
138 | set prctl_breakpoint "stop 1" | |
139 | gdb_breakpoint [gdb_get_line_number $prctl_breakpoint] | |
140 | ||
141 | for {set id $id_start} {$id <= $id_end} {incr id} { | |
142 | set vl [test_id_to_vl $id] | |
143 | set svl [test_id_to_svl $id] | |
144 | ||
145 | set skip_unsupported 0 | |
146 | if {![aarch64_supports_sve_vl $vl] | |
147 | || ![aarch64_supports_sme_svl $svl]} { | |
148 | # We have a vector length or streaming vector length that | |
149 | # is not supported by this target. Skip to the next iteration | |
150 | # since it is no use running tests for an unsupported vector | |
151 | # length. | |
152 | if {![aarch64_supports_sve_vl $vl]} { | |
153 | verbose -log "SVE vector length $vl not supported." | |
154 | } elseif {![aarch64_supports_sme_svl $svl]} { | |
155 | verbose -log "SME streaming vector length $svl not supported." | |
156 | } | |
157 | verbose -log "Skipping test." | |
158 | set skip_unsupported 1 | |
159 | } | |
160 | ||
161 | with_test_prefix "prctl, vl=${vl} svl=${svl}" { | |
162 | # If the SVE or SME vector length is not supported, just skip | |
163 | # these next tests. | |
164 | if {$skip_unsupported} { | |
165 | untested "unsupported configuration on target" | |
166 | continue | |
167 | } | |
168 | ||
169 | # Run the program until it has adjusted svl. | |
170 | gdb_continue_to_breakpoint $prctl_breakpoint | |
171 | ||
172 | check_regs $vl $svl | |
173 | } | |
174 | } | |
175 | ||
176 | set non_prctl_breakpoint "stop 2" | |
177 | gdb_breakpoint [gdb_get_line_number $non_prctl_breakpoint] | |
178 | gdb_continue_to_breakpoint $non_prctl_breakpoint | |
179 | ||
180 | for {set id $id_start} {$id <= $id_end} {incr id} { | |
181 | set vl [test_id_to_vl $id] | |
182 | set svl [test_id_to_svl $id] | |
183 | ||
184 | set skip_unsupported 0 | |
185 | if {![aarch64_supports_sve_vl $vl] | |
186 | || ![aarch64_supports_sme_svl $svl]} { | |
187 | # We have a vector length or streaming vector length that | |
188 | # is not supported by this target. Skip to the next iteration | |
189 | # since it is no use running tests for an unsupported vector | |
190 | # length. | |
191 | if {![aarch64_supports_sve_vl $vl]} { | |
192 | verbose -log "SVE vector length $vl not supported." | |
193 | } elseif {![aarch64_supports_sme_svl $svl]} { | |
194 | verbose -log "SME streaming vector length $svl not supported." | |
195 | } | |
196 | verbose -log "Skipping test." | |
197 | set skip_unsupported 1 | |
198 | } | |
199 | ||
200 | with_test_prefix "gdb, vl=${vl} svl=${svl}" { | |
201 | ||
202 | # If the SVE or SME vector length is not supported, just skip | |
203 | # these next tests. | |
204 | if {$skip_unsupported} { | |
205 | untested "unsupported configuration on target" | |
206 | continue | |
207 | } | |
208 | ||
209 | # Adjust vg and svg. | |
210 | set vg_value [expr $vl / 8] | |
211 | set svg_value [expr $svl / 8] | |
212 | gdb_test_no_output "set \$vg = ${vg_value}" | |
213 | gdb_test_no_output "set \$svg = ${svg_value}" | |
214 | ||
215 | check_regs $vl $svl | |
216 | } | |
217 | } | |
218 | } | |
219 | ||
220 | require is_aarch64_target | |
221 | require allow_aarch64_sve_tests | |
222 | require allow_aarch64_sme_tests | |
223 | ||
224 | test_sme_registers_unavailable $id_start $id_end |