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