1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
# Copyright 2023-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/>. */
# Support routines for aarch64-specific tests
#
# Return a regular expression that matches what gdb would print for a
# 1-dimension vector containing ELEMENTS elements of value BYTE.
#
# The pattern is of the form "{BYTE <repeats ELEMENTS times>".
#
proc 1d_array_value_pattern { byte elements } {
set brace_open "{"
set brace_close "}"
append data $brace_open $byte
if {$elements > 1} {
append data " <repeats $elements times>"
}
append data $brace_close
verbose -log "1d_array_value_pattern Pattern string is..."
verbose -log $data
return $data
}
#
# Return a regular expression that matches what gdb would print for a
# 2-dimension vector containing ROWS rows and COLUMNS columns of elements
# of value BYTE.
#
# The pattern is of the form
# "{{BYTE <repeats COLUMNS times>} <repeats ROWS times>}".
#
proc 2d_array_value_pattern { byte rows columns } {
set brace_open "{"
set brace_close "}"
append data $brace_open [1d_array_value_pattern $byte $columns]
if {$rows > 1} {
append data " <repeats $rows times>"
}
append data $brace_close
verbose -log "2d_array_value_pattern Pattern string is..."
verbose -log $data
return $data
}
#
# Initialize register NAME, a 1-dimension vector, with ELEMENTS elements
# by setting all elements to BYTE. ELEMENTS is limited at 256 for memory
# usage purposes.
#
# The initialization is of the form "{BYTE, BYTE, BYTE ...}".
#
proc initialize_1d_array { name byte elements } {
set brace_open "{"
set brace_close "}"
append data $brace_open
# Build the assignment in a single shot.
for {set element 0} {$element < $elements} {incr element} {
# Construct the initializer by appending elements to it.
append data $byte
# If this isn't the last element, add a comma.
if {[expr $element + 1] < $elements} {
append data ", "
}
}
append data $brace_close
verbose -log "initialization string is..."
verbose -log $data
gdb_test_no_output "set $name = $data" "write to $name"
}
#
# Return an initializer string for a 2-dimension vector with ROWS rows and
# COLUMNS columns, initializing all elements to BYTE for register NAME.
#
# COLUMNS is limited to 256 elements for memory usage purposes.
#
# The initialization is of the form "{{BYTE, BYTE}, ..., {BYTE, BYTE}}}".
#
proc initialize_2d_array { name byte rows columns } {
set brace_open "{"
set brace_close "}"
if {[expr $rows * $columns] <= 256} {
# Build the assignment in a single shot, as we have a maximum of 256
# elements.
for {set row 0} {$row < $rows} {incr row} {
append data $brace_open
for {set column 0} {$column < $columns} {incr column} {
# Construct the initializer by appending elements to it.
append data $byte
# If this isn't the last column, add a comma.
if {[expr $column + 1] < $columns} {
append data ", "
}
}
append data $brace_close
# If this isn't the last row, add a comma.
if {[expr $row + 1] < $rows} {
append data ","
}
}
set data $brace_open$data
set data $data$brace_close
verbose -log "initialization string is..."
verbose -log $data
gdb_test_no_output "set $name = $data" "write to $name"
} else {
# There are too many elements to initialize (more than 256), so we
# will do the initialization row by row.
for {set row 0} {$row < $rows} {incr row} {
initialize_1d_array "$name\[$row\]" $byte $columns
}
}
}
#
# Validate the values of the FPSIMD registers.
#
proc check_fpsimd_regs { byte state vl svl} {
set fpsimd_pattern [string_to_regexp [1d_array_value_pattern $byte 16]]
for {set number 0} {$number < 32} {incr number} {
set register_name "\$v${number}\.b\.u"
gdb_test "print sizeof $register_name" " = 16"
gdb_test "print $register_name" $fpsimd_pattern
}
}
|
