forked from Imagelibrary/binutils-gdb
a5d3f94c27
After this commit:
commit e2f620135d
Date: Thu Mar 30 13:26:25 2023 +0100
gdb/testsuite: change newline patterns used in gdb_test
It was pointed out in PR gdb/30403 that the same patterns can be found
in other lib/gdb.exp procs and that it would probably be a good idea
if these procs remained in sync with gdb_test. Actually, the bug
specifically calls out gdb_test_multiple when using with '-wrap', but
I found a couple of other locations in gdb_continue_to_breakpoint,
gdb_test_multiline, get_valueof, and get_local_valueof.
In all these locations one or both of the following issues are
addressed:
1. A leading pattern of '[\r\n]*' is pointless. If there is a
newline it will be matched, but if there is not then the testsuite
doesn't care. Also, as expect is happy to skip non-matched output
at the start of a pattern, if there is a newline expect is happy to
skip over it before matching the rest. As such, this leading
pattern is removed.
2. Using '\[\r\n\]*$gdb_prompt' means that we will swallow
unexpected blank lines at the end of a command's output, but also,
if the pattern from the test script ends with a '\r', '\n', or '.'
then these will partially match the trailing newline, with the
remainder of the newline matched by the pattern from gdb.exp. This
split matching doesn't add any value, it's just something that has
appeared as a consequence of how gdb.exp was originally written. In
this case the '\[\r\n\]*' is replaced with '\r\n'.
I've rerun the testsuite and fixed the regressions that I saw, these
were places where GDB emits a blank line at the end of the command
output, which we now need to explicitly match in the test script, this
was for:
gdb.dwarf2/dw2-out-of-range-end-of-seq.exp
gdb.guile/guile.exp
gdb.python/python.exp
Or a location where the test script was matching part of the newline
sequence, while gdb.exp was previously matching the remainder of the
newline sequence. Now we rely on gdb.exp to match the complete
newline sequence, this was for:
gdb.base/commands.exp
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=30403
1250 lines
34 KiB
Plaintext
1250 lines
34 KiB
Plaintext
# Copyright 1988-2023 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/>.
|
|
|
|
#
|
|
# test special commands (if, while, etc)
|
|
#
|
|
|
|
# The allow_hw_watchpoint_tests checks if watchpoints are supported by the
|
|
# processor. On PowerPC, the check runs a small test program under gdb
|
|
# to determine if the Power processor supports HW watchpoints. The check
|
|
# must be done before starting the test so as to not disrupt the execution
|
|
# of the actual test.
|
|
|
|
set allow_hw_watchpoint_tests_p [allow_hw_watchpoint_tests]
|
|
|
|
standard_testfile run.c
|
|
|
|
set flags {}
|
|
lappend flags debug
|
|
lappend flags additional_flags=-DFAKEARGV
|
|
lappend_include_file flags $srcdir/lib/unbuffer_output.c
|
|
|
|
if { [prepare_for_testing "failed to prepare" $testfile $srcfile $flags] } {
|
|
return -1
|
|
}
|
|
|
|
# Run to FUNCTION. If that fails, issue a FAIL and make the caller
|
|
# return.
|
|
|
|
proc runto_or_return {function} {
|
|
if { ![runto factorial] } {
|
|
return -code return
|
|
}
|
|
}
|
|
|
|
proc_with_prefix gdbvar_simple_if_test {} {
|
|
global valnum_re
|
|
|
|
gdb_test_no_output "set \$foo = 0" "set foo"
|
|
# All this test should do is print 0xdeadbeef once.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{if $foo == 1} \
|
|
{ p/x 0xfeedface} \
|
|
{else} \
|
|
{ p/x 0xdeadbeef} \
|
|
{end}] \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"#1"
|
|
|
|
# All this test should do is print 0xfeedface once.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{if $foo == 0} \
|
|
{ p/x 0xfeedface} \
|
|
{else} \
|
|
{ p/x 0xdeadbeef} \
|
|
{end}] \
|
|
"$valnum_re = 0xfeedface" \
|
|
"#2"
|
|
}
|
|
|
|
proc_with_prefix gdbvar_simple_while_test {} {
|
|
global valnum_re
|
|
|
|
gdb_test_no_output "set \$foo = 5" "set foo"
|
|
# This test should print 0xfeedface five times.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{while $foo > 0} \
|
|
{ p/x 0xfeedface} \
|
|
{ set $foo -= 1} \
|
|
{end}] \
|
|
[multi_line \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface"] \
|
|
"#1"
|
|
}
|
|
|
|
proc_with_prefix gdbvar_complex_if_while_test {} {
|
|
global valnum_re
|
|
|
|
gdb_test_no_output "set \$foo = 4" "set foo"
|
|
# This test should alternate between 0xdeadbeef and 0xfeedface two times.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{while $foo > 0} \
|
|
{ set $foo -= 1} \
|
|
{ if ($foo % 2) == 1} \
|
|
{ p/x 0xdeadbeef} \
|
|
{ else} \
|
|
{ p/x 0xfeedface} \
|
|
{ end} \
|
|
{end}] \
|
|
[multi_line \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface"] \
|
|
"#1"
|
|
}
|
|
|
|
proc_with_prefix progvar_simple_if_test {} {
|
|
global valnum_re
|
|
|
|
runto_or_return factorial
|
|
|
|
# Don't depend upon argument passing, since most simulators don't
|
|
# currently support it. Bash value variable to be what we want.
|
|
gdb_test "p value=5" " = 5" "set value to 5"
|
|
# All this test should do is print 0xdeadbeef once.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{if value == 1} \
|
|
{ p/x 0xfeedface} \
|
|
{else} \
|
|
{ p/x 0xdeadbeef} \
|
|
{end}] \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"#1"
|
|
|
|
# All this test should do is print 0xfeedface once.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{if value == 5} \
|
|
{ p/x 0xfeedface} \
|
|
{else} \
|
|
{ p/x 0xdeadbeef} \
|
|
{end}] \
|
|
"$valnum_re = 0xfeedface" \
|
|
"#2"
|
|
}
|
|
|
|
proc_with_prefix progvar_simple_while_test {} {
|
|
global valnum_re
|
|
|
|
runto_or_return factorial
|
|
|
|
# Don't depend upon argument passing, since most simulators don't
|
|
# currently support it. Bash value variable to be what we want.
|
|
gdb_test "p value=5" " = 5" "set value to 5"
|
|
# This test should print 0xfeedface five times.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{while value > 0} \
|
|
{ p/x 0xfeedface} \
|
|
{ set value -= 1} \
|
|
{end}] \
|
|
[multi_line \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xfeedface"] \
|
|
"#1"
|
|
}
|
|
|
|
proc_with_prefix progvar_complex_if_while_test {} {
|
|
global valnum_re
|
|
|
|
runto_or_return factorial
|
|
|
|
# Don't depend upon argument passing, since most simulators don't
|
|
# currently support it. Bash value variable to be what we want.
|
|
gdb_test "p value=4" " = 4" "set value to 4"
|
|
# This test should alternate between 0xdeadbeef and 0xfeedface two
|
|
# times.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{while value > 0} \
|
|
{ set value -= 1} \
|
|
{ if (value % 2) == 1} \
|
|
{ p/x 0xdeadbeef} \
|
|
{ else} \
|
|
{ p/x 0xfeedface} \
|
|
{ end} \
|
|
{end}] \
|
|
[multi_line \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface"] \
|
|
"#1"
|
|
}
|
|
|
|
proc_with_prefix if_while_breakpoint_command_test {} {
|
|
global valnum_re
|
|
|
|
runto_or_return factorial
|
|
|
|
# Don't depend upon argument passing, since most simulators don't
|
|
# currently support it. Bash value variable to be what we want.
|
|
gdb_test "p value=5" " = 5" "set value to 5"
|
|
delete_breakpoints
|
|
gdb_test "break factorial" "Breakpoint.*at.*"
|
|
|
|
gdb_test_multiple "commands" "commands" {
|
|
-re "End with" {
|
|
pass "commands"
|
|
}
|
|
}
|
|
|
|
# This test should alternate between 0xdeadbeef and 0xfeedface two times.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{while value > 0} \
|
|
{ set value -= 1} \
|
|
{ if (value % 2) == 1} \
|
|
{ p/x 0xdeadbeef} \
|
|
{ else} \
|
|
{ p/x 0xfeedface} \
|
|
{ end} \
|
|
{end} \
|
|
{end}] \
|
|
"" \
|
|
"commands part 2"
|
|
gdb_test \
|
|
"continue" \
|
|
[multi_line \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface"] \
|
|
"#1"
|
|
gdb_test "info break" "while.*set.*if.*p/x.*else.*p/x.*end.*"
|
|
}
|
|
|
|
# Test that we can run the inferior from breakpoint commands.
|
|
#
|
|
# The expected behavior is that all commands after the first "step"
|
|
# shall be ignored. See the gdb manual, "Break Commands",
|
|
# subsection "Breakpoint command lists".
|
|
|
|
proc_with_prefix infrun_breakpoint_command_test {} {
|
|
runto_or_return factorial
|
|
|
|
# Don't depend upon argument passing, since most simulators don't
|
|
# currently support it. Bash value variable to be what we want.
|
|
gdb_test "p value=6" " = 6" "set value to 6"
|
|
delete_breakpoints
|
|
gdb_test "break factorial if value == 5" "Breakpoint.*at.*"
|
|
|
|
# infrun_breakpoint_command_test - This test was broken into two parts
|
|
# to get around a synchronization problem in expect.
|
|
# part1: issue the gdb command "commands"
|
|
# part2: send the list of commands
|
|
|
|
set test "commands #1"
|
|
gdb_test_multiple "commands" $test {
|
|
-re "End with" {
|
|
pass $test
|
|
}
|
|
}
|
|
gdb_test "step\nstep\nstep\nstep\nend" "" \
|
|
"commands #2"
|
|
|
|
gdb_test "continue" \
|
|
"Continuing.*.*.*Breakpoint \[0-9\]*, factorial \\(value=5\\).*at.*\[0-9\]*\[ \]*if \\(value > 1\\) \{.*\[0-9\]*\[ \]*value \\*= factorial \\(value - 1\\);.*"
|
|
}
|
|
|
|
proc_with_prefix breakpoint_command_test {} {
|
|
runto_or_return factorial
|
|
|
|
# Don't depend upon argument passing, since most simulators don't
|
|
# currently support it. Bash value variable to be what we want.
|
|
gdb_test "p value=6" " = 6" "set value to 6"
|
|
delete_breakpoints
|
|
gdb_test "break factorial" "Breakpoint.*at.*"
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{commands} \
|
|
{ printf "Now the value is %d\n", value} \
|
|
{end}] \
|
|
"End with.*" \
|
|
"commands"
|
|
gdb_test "continue" \
|
|
"Breakpoint \[0-9\]*, factorial.*Now the value is 5"
|
|
gdb_test "print value" " = 5"
|
|
}
|
|
|
|
# Test clearing the commands of several breakpoints with one single "end".
|
|
proc_with_prefix breakpoint_clear_command_test {} {
|
|
runto_or_return factorial
|
|
|
|
set any "\[^\r\n\]*"
|
|
delete_breakpoints
|
|
gdb_test "break factorial" "Breakpoint.*at.*"
|
|
gdb_test_no_output "set \$bpnumfactorial = \$bpnum"
|
|
gdb_test "break -q main" "Breakpoint.*at.*"
|
|
gdb_test_no_output "set \$bpnummain = \$bpnum"
|
|
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{commands $bpnumfactorial $bpnummain} \
|
|
{ print 1234321} \
|
|
{end}] \
|
|
"End with.*" \
|
|
"set commands of two breakpoints to print 1234321"
|
|
gdb_test "info breakpoints" \
|
|
[multi_line \
|
|
"${any}What${any}" \
|
|
"${any}in factorial${any}" \
|
|
"${any}print 1234321${any}" \
|
|
"${any}in main${any}" \
|
|
"${any}print 1234321${any}" \
|
|
] \
|
|
"print 1234321 command present in the two breakpoints"
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{commands $bpnumfactorial $bpnummain} \
|
|
{end}] \
|
|
"End with.*" \
|
|
"clear the command list of the two breakpoints"
|
|
gdb_test "info breakpoints" \
|
|
[multi_line \
|
|
"${any}What${any}" \
|
|
"${any}in factorial${any}" \
|
|
"${any}in main${any}" \
|
|
] \
|
|
"print 1234321 command is not present anymore in the two breakpoints"
|
|
}
|
|
|
|
# Test a simple user defined command (with arguments)
|
|
proc_with_prefix user_defined_command_test {} {
|
|
global valnum_re
|
|
|
|
gdb_test_no_output "set \$foo = 4" "set foo"
|
|
|
|
gdb_test_multiple "define mycommand" "define mycommand" {
|
|
-re "End with" {
|
|
pass "define mycommand"
|
|
}
|
|
}
|
|
|
|
# This test should alternate between 0xdeadbeef and 0xfeedface two times.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{while $arg0 > 0} \
|
|
{ set $arg0 -= 1} \
|
|
{ if ($arg0 % 2) == 1} \
|
|
{ p/x 0xdeadbeef} \
|
|
{ else} \
|
|
{ p/x 0xfeedface} \
|
|
{ end} \
|
|
{end} \
|
|
{end}] \
|
|
"" \
|
|
"enter commands"
|
|
|
|
global decimal
|
|
set valnum_re "\\\$$decimal"
|
|
|
|
gdb_test \
|
|
{mycommand $foo} \
|
|
[multi_line \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface" \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"$valnum_re = 0xfeedface"] \
|
|
"execute user-defined command"
|
|
gdb_test "show user mycommand" \
|
|
" while \\\$arg0.*set.* if \\\(\\\$arg0.*p/x.* else\[^\n\].*p/x.* end\[^\n\].* end\[^\n\].*" \
|
|
"display user command"
|
|
|
|
# Create and test a user-defined command with an empty body.
|
|
gdb_test_multiple "define myemptycommand" "define myemptycommand" {
|
|
-re "End with" {
|
|
pass "define myemptycommand"
|
|
}
|
|
}
|
|
gdb_test "end" \
|
|
"" \
|
|
"end definition of user-defined command with empty body"
|
|
|
|
gdb_test_no_output "myemptycommand" \
|
|
"execute user-defined empty command"
|
|
|
|
gdb_test "show user" \
|
|
"User command \"myemptycommand.*" \
|
|
"display empty command in command list"
|
|
|
|
gdb_test "show user myemptycommand" \
|
|
"User command \"myemptycommand.*" \
|
|
"display user-defined empty command"
|
|
}
|
|
|
|
# Test that the case with which the command was defined is preserved.
|
|
|
|
proc_with_prefix user_defined_command_case_sensitivity {} {
|
|
# Define a first command with mixed case name.
|
|
set test "define Homer-Simpson"
|
|
gdb_test_multiple $test $test {
|
|
-re "End with" {
|
|
pass $test
|
|
}
|
|
}
|
|
|
|
gdb_test "print 123\nend" "" "enter commands 1"
|
|
|
|
# Define a second command, same name but different case.
|
|
set test "define HomeR-SimpsoN"
|
|
gdb_test_multiple $test $test {
|
|
-re "End with" {
|
|
pass $test
|
|
}
|
|
}
|
|
|
|
gdb_test "print 456\nend" "" "enter commands 2"
|
|
|
|
gdb_test "Homer-Simpson" " = 123" "execute command Homer-Simpson"
|
|
gdb_test "HomeR-SimpsoN" " = 456" "execute command HomeR-SimpsoN"
|
|
gdb_test "HOMER-SIMPSON" "Undefined command.*" "try to call in upper case"
|
|
gdb_test "homer-simpson" "Undefined command.*" "try to call in lower case"
|
|
}
|
|
|
|
# Test that "eval" in a user-defined command expands $argc/$argN.
|
|
|
|
proc_with_prefix user_defined_command_args_eval {} {
|
|
gdb_test_multiple "define command_args_eval" \
|
|
"define command_args_eval" {
|
|
-re "End with" {
|
|
pass "define"
|
|
}
|
|
}
|
|
|
|
# Make a command that constructs references to $argc and $argN via
|
|
# eval.
|
|
gdb_test \
|
|
[multi_line \
|
|
{eval "printf \"argc = %%d,\", $arg%c", 'c'} \
|
|
{set $i = 0} \
|
|
{while $i < $argc} \
|
|
{ eval "printf \" %%d\", $arg%d", $i} \
|
|
{ set $i = $i + 1} \
|
|
{end} \
|
|
{printf "\n"} \
|
|
{end}] \
|
|
"" \
|
|
"enter commands"
|
|
|
|
gdb_test "command_args_eval 1 2 3" "argc = 3, 1 2 3" "execute command"
|
|
}
|
|
|
|
# Test that the $argc/$argN variables are pushed on/popped from the
|
|
# args stack correctly when a user-defined command calls another
|
|
# user-defined command (or in this case, recurses).
|
|
|
|
proc_with_prefix user_defined_command_args_stack_test {} {
|
|
gdb_test_multiple "define args_stack_command" \
|
|
"define args_stack_command" {
|
|
-re "End with" {
|
|
pass "define"
|
|
}
|
|
}
|
|
|
|
# Make a command that refers to $argc/$argN before and after
|
|
# recursing. Also, vary the number of arguments passed to each
|
|
# recursion point.
|
|
gdb_test \
|
|
[multi_line \
|
|
{printf "before, argc = %d,", $argc} \
|
|
{set $i = 0} \
|
|
{while $i < $argc} \
|
|
{ eval "printf \" %%d\", $arg%d", $i} \
|
|
{ set $i = $i + 1} \
|
|
{end} \
|
|
{printf "\n"} \
|
|
{} \
|
|
{} \
|
|
{if $argc == 3} \
|
|
{ args_stack_command 21 22} \
|
|
{end} \
|
|
{if $argc == 2} \
|
|
{ args_stack_command 11} \
|
|
{end} \
|
|
{} \
|
|
{} \
|
|
{printf "after, argc = %d,", $argc} \
|
|
{set $i = 0} \
|
|
{while $i < $argc} \
|
|
{ eval "printf \" %%d\", $arg%d", $i} \
|
|
{ set $i = $i + 1} \
|
|
{end} \
|
|
{printf "\n"} \
|
|
{end}] \
|
|
"" \
|
|
"enter commands"
|
|
|
|
set expected \
|
|
[multi_line \
|
|
"before, argc = 3, 31 32 33" \
|
|
"before, argc = 2, 21 22" \
|
|
"before, argc = 1, 11" \
|
|
"after, argc = 1, 11" \
|
|
"after, argc = 2, 21 22" \
|
|
"after, argc = 3, 31 32 33"]
|
|
gdb_test "args_stack_command 31 32 33" $expected "execute command"
|
|
}
|
|
|
|
# Test a simple user defined command with many arguments. GDB <= 7.12
|
|
# used to have a hard coded limit of 10 arguments.
|
|
|
|
proc_with_prefix user_defined_command_manyargs_test {} {
|
|
set test "define command"
|
|
gdb_test_multiple "define manyargs" $test {
|
|
-re "End with" {
|
|
pass $test
|
|
}
|
|
}
|
|
|
|
# Define a function that doubles its arguments.
|
|
gdb_test \
|
|
[multi_line \
|
|
{printf "nargs=%d:", $argc} \
|
|
{set $i = 0} \
|
|
{while $i < $argc} \
|
|
{ eval "printf \" %%d\", 2 * $arg%d\n", $i} \
|
|
{ set $i = $i + 1} \
|
|
{end} \
|
|
{printf "\n"} \
|
|
{end}] \
|
|
"" \
|
|
"enter commands"
|
|
|
|
# Some random number of arguments, as long as higher than 10.
|
|
set nargs 100
|
|
|
|
set cmd "manyargs"
|
|
for {set i 1} {$i <= $nargs} {incr i} {
|
|
append cmd " $i"
|
|
}
|
|
|
|
set expected "nargs=$nargs:"
|
|
for {set i 1} {$i <= $nargs} {incr i} {
|
|
append expected " " [expr 2 * $i]
|
|
}
|
|
|
|
gdb_test $cmd $expected "execute command"
|
|
}
|
|
|
|
proc_with_prefix watchpoint_command_test {} {
|
|
global gdb_prompt
|
|
global allow_hw_watchpoint_tests_p
|
|
|
|
# Disable hardware watchpoints if necessary.
|
|
if {!$allow_hw_watchpoint_tests_p} {
|
|
gdb_test_no_output "set can-use-hw-watchpoints 0" ""
|
|
}
|
|
|
|
runto_or_return factorial
|
|
|
|
delete_breakpoints
|
|
|
|
# Verify that we can create a watchpoint, and give it a commands
|
|
# list that continues the inferior. We set the watchpoint on a
|
|
# local variable, too, so that it self-deletes when the watched
|
|
# data goes out of scope.
|
|
#
|
|
# What should happen is: Each time the watchpoint triggers, it
|
|
# continues the inferior. Eventually, the watchpoint will self-
|
|
# delete, when the watched variable is out of scope. But by that
|
|
# time, the inferior should have exited. GDB shouldn't crash or
|
|
# anything untoward as a result of this.
|
|
#
|
|
set wp_id -1
|
|
|
|
gdb_test_multiple "watch local_var" "watch local_var" {
|
|
-re "\[Ww\]atchpoint (\[0-9\]*): local_var.*$gdb_prompt $" {
|
|
set wp_id $expect_out(1,string)
|
|
pass "watch local_var"
|
|
}
|
|
}
|
|
|
|
if {$wp_id == -1} {return}
|
|
|
|
gdb_test_multiple "commands $wp_id" "begin commands on watch" {
|
|
-re "Type commands for breakpoint.*, one per line.*>$" {
|
|
pass "begin commands on watch"
|
|
}
|
|
}
|
|
# See the 'No symbol "value...' fail below. This command will
|
|
# fail if it's executed in the wrong frame. If adjusting the
|
|
# test, make sure this property holds.
|
|
gdb_test_multiple "print value" "add print command to watch" {
|
|
-re ">$" {
|
|
pass "add print command to watch"
|
|
}
|
|
}
|
|
gdb_test_multiple "continue" "add continue command to watch" {
|
|
-re ">$" {
|
|
pass "add continue command to watch"
|
|
}
|
|
}
|
|
gdb_test "end" \
|
|
"" \
|
|
"end commands on watch"
|
|
|
|
set test "continue with watch"
|
|
set lno_1 [gdb_get_line_number "commands.exp: hw local_var out of scope" "run.c"]
|
|
set lno_2 [gdb_get_line_number "commands.exp: local_var out of scope" "run.c"]
|
|
gdb_test_multiple "continue" "$test" {
|
|
-re "No symbol \"value\" in current context.\r\n$gdb_prompt $" {
|
|
# Happens if GDB actually runs the watchpoints commands,
|
|
# even though the watchpoint was deleted for not being in
|
|
# scope.
|
|
fail $test
|
|
}
|
|
-re "Continuing.*\[Ww\]atchpoint $wp_id deleted because the program has left the block in.*which its expression is valid.*run.c:($lno_1|$lno_2).*$gdb_prompt $" {
|
|
pass $test
|
|
}
|
|
}
|
|
}
|
|
|
|
proc_with_prefix test_command_prompt_position {} {
|
|
global gdb_prompt
|
|
global valnum_re
|
|
|
|
runto_or_return factorial
|
|
|
|
# Don't depend upon argument passing, since most simulators don't
|
|
# currently support it. Bash value variable to be what we want.
|
|
delete_breakpoints
|
|
gdb_test "break factorial" "Breakpoint.*at.*"
|
|
gdb_test "p value=5" ".*" "set value to 5"
|
|
# All this test should do is print 0xdeadbeef once.
|
|
gdb_test \
|
|
[multi_line_input \
|
|
{if value == 1} \
|
|
{ p/x 0xfeedface} \
|
|
{else} \
|
|
{ p/x 0xdeadbeef} \
|
|
{end}] \
|
|
"$valnum_re = 0xdeadbeef" \
|
|
"if test"
|
|
|
|
# Now let's test for the correct position of the '>' in gdb's
|
|
# prompt for commands. It should be at the beginning of the line,
|
|
# and not after one space.
|
|
|
|
set test "> OK"
|
|
gdb_test_multiple "commands" $test {
|
|
-re "Type commands.*End with.*\[\r\n\]>$" {
|
|
gdb_test_multiple "printf \"Now the value is %d\\n\", value" $test {
|
|
-re "^printf.*value\r\n>$" {
|
|
gdb_test_multiple "end" $test {
|
|
-re "^end\r\n$gdb_prompt $" {
|
|
pass $test
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
proc_with_prefix deprecated_command_test {} {
|
|
gdb_test "maintenance deprecate blah" "Can't find command.*" \
|
|
"tried to deprecate non-existing command"
|
|
|
|
gdb_test_no_output "maintenance deprecate p \"new_p\"" "maintenance deprecate p \"new_p\" /1/"
|
|
gdb_test "p 5" \
|
|
"Warning: 'p', an alias for the command 'print', is deprecated.*Use 'new_p'.*" \
|
|
"p deprecated warning, with replacement"
|
|
gdb_test "p 5" ".\[0-9\]* = 5.*" "deprecated warning goes away /1/"
|
|
|
|
gdb_test_no_output "maintenance deprecate p \"new_p\"" "maintenance deprecate p \"new_p\" /2/"
|
|
gdb_test_no_output "maintenance deprecate print \"new_print\""
|
|
gdb_test "p 5" \
|
|
"Warning: command 'print' \\(p\\) is deprecated.*Use 'new_print'.*" \
|
|
"both alias and command are deprecated"
|
|
gdb_test "p 5" ".\[0-9\]* = 5.*" "deprecated warning goes away /2/"
|
|
|
|
gdb_test_no_output "maintenance deprecate set remote memory-read-packet-size \"srm\" " \
|
|
"deprecate long command /1/"
|
|
gdb_test "set remote memory-read-packet-size" \
|
|
"Warning: command 'set remote memory-read-packet-size' is deprecated.*Use 'srm'.*" \
|
|
"long command deprecated /1/"
|
|
|
|
gdb_test_no_output "maintenance deprecate set remote memory-read-packet-size" \
|
|
"deprecate long command /2/"
|
|
gdb_test "set remote memory-read-packet-size" \
|
|
"Warning: command 'set remote memory-read-packet-size' is deprecated.*No alternative known.*" \
|
|
"long command deprecated with no alternative /2/"
|
|
|
|
gdb_test "maintenance deprecate" \
|
|
"\"maintenance deprecate\".*" \
|
|
"deprecate with no arguments"
|
|
|
|
# Test that an alias with a prefix still gives a warning.
|
|
set file1 [standard_output_file xxx_yyy_cmd]
|
|
set fd [open "$file1" w]
|
|
puts $fd \
|
|
"define set xxx_yyy
|
|
echo in command xxx_yyy\\n
|
|
end
|
|
|
|
alias set qqq_aaa=set xxx_yyy
|
|
maintenance deprecate set qqq_aaa"
|
|
close $fd
|
|
gdb_test_no_output "source $file1" \
|
|
"source file containing xxx_yyy command and its alias"
|
|
gdb_test "set qqq_aaa" \
|
|
"Warning: 'set qqq_aaa', an alias for the command 'set xxx_yyy', is deprecated\\.\r\n.*No alternative known\\..*" \
|
|
"deprecated alias with prefix give a warning"
|
|
}
|
|
|
|
# Test that the help for a command does not show deprecated aliases.
|
|
|
|
proc_with_prefix deprecated_command_alias_help_test {} {
|
|
gdb_test_multiline "define real_command" \
|
|
"define real_command" "End with a line saying just \"end\"\\." \
|
|
"print 1" "" \
|
|
"end" ""
|
|
|
|
gdb_test_no_output "alias alias_command = real_command"
|
|
gdb_test_no_output "alias alias_with_args_command = real_command 123"
|
|
|
|
gdb_test "help real_command" \
|
|
"real_command, alias_with_args_command, alias_command\r\n alias alias_with_args_command = real_command 123\r\nUser-defined." \
|
|
"help real_command, before"
|
|
gdb_test_no_output "maintenance deprecate alias_command"
|
|
gdb_test_no_output "maintenance deprecate alias_with_args_command"
|
|
gdb_test "help real_command" \
|
|
"User-defined." \
|
|
"help real_command, after"
|
|
}
|
|
|
|
proc_with_prefix bp_deleted_in_command_test {} {
|
|
global gdb_prompt
|
|
|
|
delete_breakpoints
|
|
|
|
# Create a breakpoint, and associate a command-list to it, with
|
|
# one command that deletes this breakpoint.
|
|
gdb_test "break factorial" \
|
|
"Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\."
|
|
|
|
gdb_test_multiple "commands" "begin commands" {
|
|
-re "Type commands for breakpoint.*>$" {
|
|
pass "begin commands"
|
|
}
|
|
}
|
|
gdb_test_multiple "silent" "add silent command" {
|
|
-re ">$" {
|
|
pass "add silent command"
|
|
}
|
|
}
|
|
gdb_test_multiple "clear factorial" "add clear command" {
|
|
-re ">$" {
|
|
pass "add clear command"
|
|
}
|
|
}
|
|
gdb_test_multiple "printf \"factorial command-list executed\\n\"" \
|
|
"add printf command" {
|
|
-re ">$" {
|
|
pass "add printf command"
|
|
}
|
|
}
|
|
gdb_test_multiple "cont" "add cont command" {
|
|
-re ">$" {
|
|
pass "add cont command"
|
|
}
|
|
}
|
|
gdb_test "end" \
|
|
"" \
|
|
"end commands"
|
|
|
|
gdb_run_cmd
|
|
gdb_test "" "factorial command-list executed.*" "run factorial until breakpoint"
|
|
}
|
|
|
|
proc_with_prefix temporary_breakpoint_commands {} {
|
|
delete_breakpoints
|
|
|
|
# Create a temporary breakpoint, and associate a commands list to it.
|
|
# This test will verify that this commands list is executed when the
|
|
# breakpoint is hit.
|
|
gdb_test "tbreak factorial" \
|
|
"Temporary breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\." \
|
|
"breakpoint"
|
|
|
|
gdb_test_multiple "commands" \
|
|
"begin commands in bp_deleted_in_command_test" {
|
|
-re "Type commands for breakpoint.*>$" {
|
|
pass "begin commands"
|
|
}
|
|
}
|
|
gdb_test_multiple "silent" "add silent tbreak command" {
|
|
-re ">$" {
|
|
pass "add silent tbreak command"
|
|
}
|
|
}
|
|
gdb_test_multiple "printf \"factorial tbreak commands executed\\n\"" \
|
|
"add printf tbreak command" {
|
|
-re ">$" {
|
|
pass "add printf tbreak command"
|
|
}
|
|
}
|
|
gdb_test_multiple "cont" "add cont tbreak command" {
|
|
-re ">$" {
|
|
pass "add cont tbreak command"
|
|
}
|
|
}
|
|
gdb_test "end" \
|
|
"" \
|
|
"end tbreak commands"
|
|
|
|
gdb_run_cmd
|
|
gdb_test "" "factorial tbreak commands executed.*" \
|
|
"run factorial until temporary breakpoint"
|
|
}
|
|
|
|
# Test that GDB can handle $arg0 outside of user functions without
|
|
# crashing.
|
|
proc_with_prefix stray_arg0_test { } {
|
|
global valnum_re
|
|
|
|
gdb_test "print \$arg0" \
|
|
"$valnum_re = void" \
|
|
"#1"
|
|
|
|
gdb_test "if 1 == 1\nprint \$arg0\nend" \
|
|
"$valnum_re = void" \
|
|
"#2"
|
|
|
|
gdb_test "print \$arg0 = 1" \
|
|
"$valnum_re = 1" \
|
|
"#3"
|
|
|
|
gdb_test "print \$arg0" \
|
|
"$valnum_re = 1" \
|
|
"#4"
|
|
}
|
|
|
|
# Test that GDB is able to source a file with an indented comment.
|
|
proc_with_prefix source_file_with_indented_comment {} {
|
|
set file1 [standard_output_file source_file_with_indented_comment]
|
|
|
|
set fd [open "$file1" w]
|
|
puts $fd \
|
|
{define my_fun
|
|
#indented comment
|
|
end
|
|
echo Done!\n}
|
|
close $fd
|
|
|
|
gdb_test "source $file1" "Done!" "source file"
|
|
}
|
|
|
|
# Test that GDB can handle arguments when sourcing files recursively.
|
|
# If the arguments are overwritten with ####### then the test has failed.
|
|
proc_with_prefix recursive_source_test {} {
|
|
set file1 [standard_output_file recursive_source_1]
|
|
set file2 [standard_output_file recursive_source_2]
|
|
set file3 [standard_output_file recursive_source_3]
|
|
|
|
set fd [open "$file1" w]
|
|
puts $fd \
|
|
"source $file2
|
|
abcdef qwerty"
|
|
close $fd
|
|
|
|
set fd [open "$file2" w]
|
|
puts $fd \
|
|
"define abcdef
|
|
echo 1: <<<\$arg0>>>\\n
|
|
source $file3
|
|
echo 2: <<<\$arg0>>>\\n
|
|
end"
|
|
close $fd
|
|
|
|
set fd [open "$file3" w]
|
|
puts $fd \
|
|
"echo in file3\\n
|
|
#################################################################"
|
|
close $fd
|
|
|
|
gdb_test "source $file1" \
|
|
"1: <<<qwerty>>>\[\r\n]+in file3\[\r\n]+2: <<<qwerty>>>" \
|
|
"source file"
|
|
}
|
|
|
|
proc gdb_test_no_prompt { command result msg } {
|
|
set msg "$command - $msg"
|
|
set result "^[string_to_regexp $command]\r\n$result$"
|
|
gdb_test_multiple $command $msg {
|
|
-re "$result" {
|
|
pass $msg
|
|
return 1
|
|
}
|
|
-re "\r\n *>$" {
|
|
fail $msg
|
|
return 0
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
proc_with_prefix if_commands_test {} {
|
|
global gdb_prompt
|
|
|
|
gdb_test_no_output "set \$tem = 1" "set \$tem"
|
|
|
|
set test "if_commands_test 1"
|
|
gdb_test_no_prompt "if \$tem == 2" { >} $test
|
|
gdb_test_no_prompt "break -q main" { >} $test
|
|
gdb_test_no_prompt "else" { >} $test
|
|
gdb_test_no_prompt "break factorial" { >} $test
|
|
gdb_test_no_prompt "commands" { >} $test
|
|
gdb_test_no_prompt "silent" { >} $test
|
|
gdb_test_no_prompt "set \$tem = 3" { >} $test
|
|
gdb_test_no_prompt "continue" { >} $test
|
|
gdb_test_multiple "end" "first end - $test" {
|
|
-re " >\$" {
|
|
pass "first end - $test"
|
|
}
|
|
-re "\r\n>\$" {
|
|
fail "first end - $test"
|
|
}
|
|
}
|
|
gdb_test_multiple "end" "second end - $test" {
|
|
-re "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
|
|
pass "second end - $test"
|
|
}
|
|
-re "Undefined command: \"silent\".*$gdb_prompt $" {
|
|
fail "second end - $test"
|
|
}
|
|
}
|
|
|
|
set test "if_commands_test 2"
|
|
gdb_test_no_prompt "if \$tem == 1" { >} $test
|
|
gdb_test_no_prompt "break -q main" { >} $test
|
|
gdb_test_no_prompt "else" { >} $test
|
|
gdb_test_no_prompt "break factorial" { >} $test
|
|
gdb_test_no_prompt "commands" { >} $test
|
|
gdb_test_no_prompt "silent" { >} $test
|
|
gdb_test_no_prompt "set \$tem = 3" { >} $test
|
|
gdb_test_no_prompt "continue" { >} $test
|
|
gdb_test_multiple "end" "first end - $test" {
|
|
-re " >\$" {
|
|
pass "first end - $test"
|
|
}
|
|
-re "\r\n>\$" {
|
|
fail "first end - $test"
|
|
}
|
|
}
|
|
gdb_test_multiple "end" "second end - $test" {
|
|
-re "Breakpoint \[0-9\]+ at .*: file .*run.c, line \[0-9\]+\.\r\n$gdb_prompt $" {
|
|
pass "second end - $test"
|
|
}
|
|
}
|
|
}
|
|
|
|
# Verify an error during "commands" commands execution will prevent any other
|
|
# "commands" from other breakpoints at the same location to be executed.
|
|
|
|
proc_with_prefix error_clears_commands_left {} {
|
|
set test "hook-stop 1"
|
|
gdb_test_multiple {define hook-stop} $test {
|
|
-re "End with a line saying just \"end\"\\.\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
set test "hook-stop 1a"
|
|
gdb_test_multiple {echo hook-stop1\n} $test {
|
|
-re "\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
gdb_test_no_output "end" "hook-stop 1b"
|
|
|
|
delete_breakpoints
|
|
gdb_breakpoint "main"
|
|
|
|
set test "main commands 1"
|
|
gdb_test_multiple {commands $bpnum} $test {
|
|
-re "End with a line saying just \"end\"\\.\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
set test "main commands 1a"
|
|
gdb_test_multiple {echo cmd1\n} $test {
|
|
-re "\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
set test "main commands 1b"
|
|
gdb_test_multiple {errorcommandxy\n} $test {
|
|
-re "\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
gdb_test_no_output "end" "main commands 1c"
|
|
|
|
gdb_breakpoint "main"
|
|
set test "main commands 2"
|
|
gdb_test_multiple {commands $bpnum} $test {
|
|
-re "End with a line saying just \"end\"\\.\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
set test "main commands 2a"
|
|
gdb_test_multiple {echo cmd2\n} $test {
|
|
-re "\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
set test "main commands 2b"
|
|
gdb_test_multiple {errorcommandyz\n} $test {
|
|
-re "\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
gdb_test_no_output "end" "main commands 2c"
|
|
|
|
gdb_run_cmd
|
|
gdb_test \
|
|
"" \
|
|
[multi_line \
|
|
"hook-stop1" \
|
|
".*" \
|
|
"cmd1" \
|
|
"Undefined command: \"errorcommandxy\"\\. Try \"help\"\\."] \
|
|
"cmd1 error"
|
|
|
|
gdb_test {echo idle\n} "\r\nidle" "no cmd2"
|
|
}
|
|
|
|
proc_with_prefix redefine_hook_test {} {
|
|
gdb_test \
|
|
[multi_line_input \
|
|
"define one"\
|
|
"end"] \
|
|
"" \
|
|
"define one"
|
|
|
|
gdb_test \
|
|
[multi_line_input \
|
|
"define hook-one" \
|
|
"echo hibob\\n" \
|
|
"end"] \
|
|
"" \
|
|
"define hook-one"
|
|
|
|
set test "redefine one"
|
|
gdb_test_multiple "define one" $test {
|
|
-re "Redefine command .one.. .y or n. $" {
|
|
send_gdb "y\n"
|
|
exp_continue
|
|
}
|
|
|
|
-re "End with" {
|
|
pass $test
|
|
}
|
|
}
|
|
|
|
gdb_test "end" "" "enter commands for one redefinition"
|
|
|
|
gdb_test "one" "hibob" "execute one command"
|
|
}
|
|
|
|
proc_with_prefix redefine_backtrace_test {} {
|
|
gdb_test_multiple "define backtrace" "define backtrace" {
|
|
-re "Really redefine built-in command \"backtrace\"\\? \\(y or n\\) $" {
|
|
pass "define backtrace"
|
|
}
|
|
}
|
|
|
|
gdb_test_multiple "y" "expect response to define backtrace" {
|
|
-re "End with a line saying just \"end\"\\.\r\n>$" {
|
|
pass "expect response to define backtrace"
|
|
}
|
|
}
|
|
|
|
gdb_test \
|
|
[multi_line_input \
|
|
"echo hibob\\n" \
|
|
"end"] \
|
|
"" \
|
|
"enter commands"
|
|
|
|
gdb_test "backtrace" "hibob" "execute backtrace command"
|
|
gdb_test "bt" "hibob" "execute bt command"
|
|
}
|
|
|
|
# Test using "if" and "while" without args when building a command list.
|
|
|
|
proc define_if_without_arg_test {} {
|
|
foreach cmd {if while define} {
|
|
set test "define some_command_$cmd"
|
|
gdb_test_multiple $test $test {
|
|
-re "End with" {
|
|
pass $test
|
|
}
|
|
}
|
|
|
|
gdb_test "$cmd" "$cmd command requires an argument." "type $cmd without args"
|
|
}
|
|
}
|
|
|
|
# Test the loop_break command.
|
|
|
|
proc_with_prefix loop_break_test {} {
|
|
gdb_test_no_output "set \$a = 0" "initialize \$a"
|
|
gdb_test_no_output "set \$total = 0" "initialize \$total"
|
|
|
|
gdb_test \
|
|
[multi_line_input \
|
|
"while \$a < 5" \
|
|
" if \$a == 4" \
|
|
" loop_break" \
|
|
" end" \
|
|
" set \$b = 0" \
|
|
" while \$b < 5" \
|
|
" if \$b == 2" \
|
|
" loop_break" \
|
|
" end" \
|
|
" set \$total = \$total + 1" \
|
|
" set \$b = \$b + 1" \
|
|
" end" \
|
|
" set \$a = \$a + 1" \
|
|
"end"] \
|
|
"" \
|
|
"run while loop"
|
|
|
|
gdb_test "print \$a" " = 4" "validate \$a"
|
|
gdb_test "print \$b" " = 2" "validate \$b"
|
|
gdb_test "print \$total" " = 8" "validate \$total"
|
|
}
|
|
|
|
# Test the loop_continue command.
|
|
|
|
proc_with_prefix loop_continue_test {} {
|
|
gdb_test_no_output "set \$a = 0" "initialize \$a"
|
|
gdb_test_no_output "set \$total = 0" "initialize \$total"
|
|
|
|
gdb_test \
|
|
[multi_line_input \
|
|
"while \$a < 5" \
|
|
" set \$a = \$a + 1" \
|
|
" set \$b = 0" \
|
|
" if \$a == 4" \
|
|
" loop_continue" \
|
|
" end" \
|
|
" while \$b < 5" \
|
|
" set \$b = \$b + 1" \
|
|
" if \$b == 2" \
|
|
" loop_continue" \
|
|
" end" \
|
|
" set \$total = \$total + 1" \
|
|
" end" \
|
|
"end"] \
|
|
"" \
|
|
"run while loop"
|
|
|
|
gdb_test "print \$a" " = 5" "validate \$a"
|
|
gdb_test "print \$b" " = 5" "validate \$b"
|
|
gdb_test "print \$total" " = 16" "validate \$total"
|
|
}
|
|
|
|
# Test an input line split with a continuation character (backslash)
|
|
# while entering a multi-line command (in a secondary prompt).
|
|
|
|
proc_with_prefix backslash_in_multi_line_command_test {} {
|
|
set dg_ver [dejagnu_version]
|
|
set dg_major [lindex $dg_ver 0]
|
|
set dg_minor [lindex $dg_ver 1]
|
|
|
|
# With older versions of DejaGnu, the "\\\n" we send gets replaced with a
|
|
# space, thus breaking the test. Just skip it in that case.
|
|
if { $dg_major == 1 && $dg_minor < 5 } {
|
|
untested "dejagnu version is too old"
|
|
return
|
|
}
|
|
|
|
gdb_breakpoint "main"
|
|
|
|
gdb_test_multiple "commands" "commands" {
|
|
-re "End with a line saying just \"end\"\\.\r\n>$" {
|
|
pass "commands"
|
|
}
|
|
}
|
|
|
|
set test "input line split with backslash"
|
|
send_gdb "print \\\nargc\n"
|
|
gdb_test_multiple "" $test {
|
|
-re "^print \\\\\r\nargc\r\n>$" {
|
|
pass $test
|
|
}
|
|
}
|
|
|
|
gdb_test_no_output "end"
|
|
|
|
# Input any command, just to be sure the readline state is sane.
|
|
# In PR 21218, this would trigger the infamous:
|
|
# readline: readline_callback_read_char() called with no handler!
|
|
gdb_test "print 1" "" "run command"
|
|
}
|
|
|
|
gdbvar_simple_if_test
|
|
gdbvar_simple_while_test
|
|
gdbvar_complex_if_while_test
|
|
progvar_simple_if_test
|
|
progvar_simple_while_test
|
|
progvar_complex_if_while_test
|
|
if_while_breakpoint_command_test
|
|
infrun_breakpoint_command_test
|
|
breakpoint_command_test
|
|
breakpoint_clear_command_test
|
|
user_defined_command_test
|
|
user_defined_command_case_sensitivity
|
|
user_defined_command_args_eval
|
|
user_defined_command_args_stack_test
|
|
user_defined_command_manyargs_test
|
|
watchpoint_command_test
|
|
test_command_prompt_position
|
|
deprecated_command_test
|
|
deprecated_command_alias_help_test
|
|
bp_deleted_in_command_test
|
|
temporary_breakpoint_commands
|
|
stray_arg0_test
|
|
source_file_with_indented_comment
|
|
recursive_source_test
|
|
if_commands_test
|
|
error_clears_commands_left
|
|
redefine_hook_test
|
|
backslash_in_multi_line_command_test
|
|
define_if_without_arg_test
|
|
loop_break_test
|
|
loop_continue_test
|
|
# This one should come last, as it redefines "backtrace".
|
|
redefine_backtrace_test
|