1# Copyright 2018-2020 Free Software Foundation, Inc.
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
16if {![istarget "riscv*-*-*"]} {
17    verbose "Skipping ${gdb_test_file_name}."
18    return
19}
20
21standard_testfile
22
23if {[prepare_for_testing "failed to prepare" $testfile $srcfile debug]} {
24    return -1
25}
26
27if ![runto_main] then {
28   fail "can't run to main"
29   return 0
30}
31
32
33# A list for all the integer register names and their aliases.  The format is
34# a list with each entry being itself a list, the first item being the primary
35# name of a register (the name GDB uses by default), and the second entry
36# being a list of register aliases.
37set xreg_names \
38{ { ra {x1} } { sp {x2} } { gp {x3} } { tp {x4} } { t0 {x5} } \
39  { t1 {x6} } { t2 {x7} } { fp {x8 s0} } { s1 {x9} } { a0 {x10} } \
40  { a1 {x11} } { a2 {x12} } { a3 {x13} } { a4 {x14} } { a5 {x15} } \
41  { a6 {x16} } { a7 {x17} } { s2 {x18} } { s3 {x19} } { s4 {x20} } \
42  { s5 {x21} } { s6 {x22} } { s7 {x23} } { s8 {x24} } { s9 {x25} } \
43  { s10 {x26} } { s11 {x27} } { t3 {x28} } { t4 {x29} } { t5 {x30} } \
44  { t6 {x31} } }
45
46# This is just like XREG_NAMES, except it contains all the floating point
47# register names and their aliases.
48set freg_names \
49{ { ft0 {f0} } { ft1 {f1} } { ft2 {f2} } { ft3 {f3} } { ft4 {f4} } \
50  { ft5 {f5} } { ft6 {f6} } { ft7 {f7} } { fs0 {f8} } { fs1 {f9} } \
51  { fa0 {f10} } { fa1 {f11} } { fa2 {f12} } { fa3 {f13} } { fa4 {f14} } \
52  { fa5 {f15} } { fa6 {f16} } { fa7 {f17} } { fs2 {f18} } { fs3 {f19} } \
53  { fs4 {f20} } { fs5 {f21} } { fs6 {f22} } { fs7 {f23} } { fs8 {f24} } \
54  { fs9 {f25} } { fs10 {f26} } { fs11 {f27} } { ft8 {f28} } { ft9 {f29} } \
55  { ft10 {f30} } { ft11 {f31} } }
56
57# Check that the zero register (and its x0 alias) both contain the
58# value 0.
59proc check_zero_register_value {testname} {
60    gdb_test "p/d \$zero" " = 0" "check \$zero: ${testname}"
61    gdb_test "p/d \$x0" " = 0" "check \$x0: ${testname}"
62}
63
64# Set all of the registers in REG_SET to zero.  Confirm that the value of zero
65# can be read back using the primary name, and from all of the alias names.
66#
67# For some architectures (RV64, RV128) the float registers have union type,
68# and we need to read/write using a ".float" extension.  This is passed in
69# REG_EXTENSION.  If no extension is needed then REG_EXTENSION is the empty
70# string.
71proc check_setting_registers_to_zero { reg_set reg_extension } {
72    foreach reg_desc ${reg_set} {
73	set primary_name [lindex ${reg_desc} 0]
74	set alias_names [lindex ${reg_desc} 1]
75
76	gdb_test_no_output "set \$${primary_name}${reg_extension} = 0" \
77	    "set register ${primary_name} to an initial value of zero"
78	gdb_test "p/d \$${primary_name}${reg_extension}" " = 0" \
79	    "check the initial value of ${primary_name} is now zero"
80
81	foreach reg_alias ${alias_names} {
82	    gdb_test "p/d \$${reg_alias}${reg_extension}" " = 0" \
83		"check the initial value of ${reg_alias} is now zero"
84	}
85    }
86}
87
88# Set all of the registers in REG_SET to a new value (the value starts at
89# REG_VALUE and is incremented after each test).  Then confirm that the new
90# value can be read back using the primary name, and from all of the alias
91# names.
92#
93# Next, set each register in REG_SET using each of its alias names, then
94# confirm that the value can be read back using both the primary name, and all
95# of the aliases.
96#
97# The REG_EXTENSION field is used as in CHECK_SETTING_REGISTERS_TO_ZERO.
98proc check_setting_registers_to_value { reg_set reg_extension reg_value } {
99    foreach reg_desc ${reg_set} {
100	set primary_name [lindex ${reg_desc} 0]
101	set alias_names [lindex ${reg_desc} 1]
102
103	# Set value through the primary register name, and check that all
104	# the aliases see the same value.
105	set reg_value [incr reg_value]
106	gdb_test_no_output "set \$${primary_name}${reg_extension} = $reg_value" \
107	    "write non-zero value to ${primary_name}"
108	gdb_test "p/d \$${primary_name}${reg_extension}" " = $reg_value" \
109	    "read ${primary_name} after non-zero write to ${primary_name}"
110	foreach reg_alias ${alias_names} {
111	    gdb_test "p/d \$${reg_alias}${reg_extension}" " = $reg_value" \
112		"read ${reg_alias} after non-zero write to ${primary_name}"
113	}
114
115	# For each alias, set a new value, and check that the primary
116	# register name, and all the other aliases, see the new value.
117	foreach reg_alias ${alias_names} {
118	    set reg_value [incr reg_value]
119
120	    gdb_test_no_output "set \$${reg_alias}${reg_extension} = $reg_value" \
121		"write non-zero value to ${reg_alias}"
122
123	    gdb_test "p/d \$${primary_name}${reg_extension}" " = $reg_value" \
124		"read ${primary_name} after non-zero write to ${reg_alias}"
125
126	    foreach other_reg_alias ${alias_names} {
127		gdb_test "p/d \$${other_reg_alias}${reg_extension}" " = $reg_value" \
128		    "read ${other_reg_alias} after non-zero write to ${reg_alias}"
129	    }
130	}
131    }
132}
133
134# First, some testing of the zero register.  This register should
135# always read as zero, and should swallow any attempt to write a
136# non-zero value to the register.
137
138check_zero_register_value "before any writes"
139
140gdb_test_no_output "set \$zero = 123" \
141    "write to the \$zero register"
142
143check_zero_register_value "after write to \$zero"
144
145gdb_test_no_output "set \$x0 = 123" \
146    "write to the \$x0 register"
147
148check_zero_register_value "after write to \$x0"
149
150# Some RISC-V variants model the fregs as a union (RV64, RV128).  In this case
151# we should access the register using 'REG_NAME.float'.  In the following we
152# figure out if the field name is needed or not by looking at how GDB prints
153# on register.
154set skip_freg_tests 0
155set freg_extension "INVALID"
156set message "check format of float registers"
157gdb_test_multiple "info registers \$ft0" $message {
158    -re "Invalid register `ft0'\r\n$gdb_prompt $" {
159	set skip_freg_tests 1
160	set freg_extension "NONE"
161	pass $message
162    }
163    -re "ft0 \+\[0-9\]\+.*\r\n$gdb_prompt $" {
164	set freg_extension ""
165	pass $message
166    }
167    -re "ft0 \+\{float = .*\r\n$gdb_prompt $" {
168	set freg_extension ".float"
169	pass $message
170    }
171}
172gdb_assert ![string eq "${freg_extension}" "INVALID"] \
173    "check that floating point format has been understood"
174
175# Now check that we can write zero, and read zero back to all of the integer
176# and floating point registers.
177check_setting_registers_to_zero ${xreg_names} ""
178
179if { ! $skip_freg_tests } {
180    check_setting_registers_to_zero ${freg_names} ${freg_extension}
181}
182
183# Set each register in turn to a new value, and confirm that the new value can
184# be read back from the primary name, and from all of the alias names.  The
185# value passed in to each test invocation here is arbitrary, they are
186# significantly different so that the float tests don't reuse value from the
187# integer tests.
188check_setting_registers_to_value ${xreg_names} "" 100
189
190if { ! $skip_freg_tests } {
191    check_setting_registers_to_value ${freg_names} ${freg_extension} 500
192}
193