gdb/testsuite/gdb.arch/riscv-reg-aliases.exp

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