mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-27 04:52:05 +08:00
3666a04883
This commits the result of running gdb/copyright.py as per our Start
of New Year procedure...
gdb/ChangeLog
Update copyright year range in copyright header of all GDB files.
642 lines
19 KiB
Plaintext
642 lines
19 KiB
Plaintext
# Copyright 2012-2021 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/>.
|
|
|
|
# Tests for explicit locations
|
|
|
|
load_lib completion-support.exp
|
|
|
|
standard_testfile explicit.c explicit2.c 3explicit.c
|
|
set exefile $testfile
|
|
|
|
if {[prepare_for_testing "failed to prepare" $exefile \
|
|
[list $srcfile $srcfile2 $srcfile3] {debug nowarnings}]} {
|
|
return -1
|
|
}
|
|
|
|
# Wrap the entire test in a namespace to avoid contaminating other tests.
|
|
namespace eval $testfile {
|
|
|
|
# Test the given (explicit) LINESPEC which should cause gdb to break
|
|
# at LOCATION.
|
|
proc test_breakpoint {linespec location} {
|
|
|
|
set testname "set breakpoint at \"$linespec\""
|
|
# Delete all breakpoints, set a new breakpoint at LINESPEC,
|
|
# and attempt to run to it.
|
|
delete_breakpoints
|
|
if {[gdb_breakpoint $linespec]} {
|
|
pass $testname
|
|
send_log "\nexpecting locpattern \"$location\"\n"
|
|
gdb_continue_to_breakpoint $linespec $location
|
|
} else {
|
|
fail $testname
|
|
}
|
|
}
|
|
|
|
# Add the given LINESPEC to the array named in THEARRAY. GDB is expected
|
|
# to stop at LOCATION.
|
|
proc add {thearray linespec location} {
|
|
upvar $thearray ar
|
|
|
|
lappend ar(linespecs) $linespec
|
|
lappend ar(locations) $location
|
|
}
|
|
|
|
# A list of all explicit linespec arguments.
|
|
variable all_arguments
|
|
set all_arguments {"source" "function" "label" "line"}
|
|
|
|
# Some locations used in this test
|
|
variable lineno
|
|
variable location
|
|
set lineno(normal) [gdb_get_line_number "myfunction location" $srcfile]
|
|
set lineno(top) [gdb_get_line_number "top location" $srcfile]
|
|
foreach v [array names lineno] {
|
|
set location($v) ".*[string_to_regexp "$srcfile:$lineno($v)"].*"
|
|
}
|
|
|
|
# A list of explicit locations and the corresponding location.
|
|
variable linespecs
|
|
set linespecs(linespecs) {}
|
|
set linespecs(location) {}
|
|
|
|
add linespecs "-source $srcfile -function myfunction" $location(normal)
|
|
add linespecs "-source $srcfile -function myfunction -label top" \
|
|
$location(top)
|
|
|
|
# This isn't implemented yet; -line is silently ignored.
|
|
add linespecs "-source $srcfile -function myfunction -label top -line 3" \
|
|
$location(top)
|
|
add linespecs "-source $srcfile -line $lineno(top)" $location(top)
|
|
add linespecs "-function myfunction" $location(normal)
|
|
add linespecs "-function myfunction -label top" $location(top)
|
|
|
|
# These are also not yet supported; -line is silently ignored.
|
|
add linespecs "-function myfunction -line 3" $location(normal)
|
|
add linespecs "-function myfunction -label top -line 3" $location(top)
|
|
add linespecs "-line 3" $location(normal)
|
|
|
|
# Fire up gdb.
|
|
if {![runto_main]} {
|
|
return -1
|
|
}
|
|
|
|
# Turn off queries
|
|
gdb_test_no_output "set confirm off"
|
|
|
|
# Simple error tests (many more are tested in ls-err.exp)
|
|
foreach arg $all_arguments {
|
|
# Test missing argument
|
|
gdb_test "break -$arg" \
|
|
[string_to_regexp "missing argument for \"-$arg\""]
|
|
|
|
# Test abbreviations
|
|
set short [string range $arg 0 3]
|
|
if { $arg != $short } {
|
|
gdb_test "break -$short" \
|
|
[string_to_regexp "missing argument for \"-$short\""]
|
|
}
|
|
}
|
|
|
|
# Test invalid arguments
|
|
foreach arg {"-foo" "-foo bar" "-function myfunction -foo" \
|
|
"-function -myfunction -foo bar"} {
|
|
gdb_test "break $arg" \
|
|
[string_to_regexp "invalid explicit location argument, \"-foo\""]
|
|
}
|
|
|
|
# Test explicit locations, with and without conditions.
|
|
# For these tests, it is easiest to turn of pending breakpoint.
|
|
gdb_test_no_output "set breakpoint pending off" \
|
|
"turn off pending breakpoints"
|
|
|
|
foreach linespec $linespecs(linespecs) loc_pattern $linespecs(locations) {
|
|
|
|
# Test the linespec
|
|
test_breakpoint $linespec $loc_pattern
|
|
|
|
# Test with a valid condition
|
|
delete_breakpoints
|
|
set tst "set breakpoint at \"$linespec\" with valid condition"
|
|
if {[gdb_breakpoint "$linespec if arg == 0"]} {
|
|
pass $tst
|
|
|
|
gdb_test "info break" ".*stop only if arg == 0.*" \
|
|
"info break of conditional breakpoint at \"$linespec\""
|
|
} else {
|
|
fail $tst
|
|
}
|
|
|
|
# Test with invalid condition
|
|
gdb_test "break $linespec if foofoofoo == 1" \
|
|
".*No symbol \"foofoofoo\" in current context.*" \
|
|
"set breakpoint at \"$linespec\" with invalid condition"
|
|
|
|
# Test with thread
|
|
delete_breakpoints
|
|
gdb_test "break $linespec thread 123" "Unknown thread 123."
|
|
}
|
|
|
|
# Tests below are about tab-completion, which doesn't work if readline
|
|
# library isn't used. Check it first.
|
|
if { [readline_is_used] } {
|
|
|
|
# Test the explicit location completer
|
|
foreach abbrev {"fun" "so" "lab" "li"} full {"function" "source" "label" "line"} {
|
|
set tst "complete 'break -$abbrev'"
|
|
send_gdb "break -${abbrev}\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -$full " {
|
|
send_gdb "\n"
|
|
gdb_test_multiple "" $tst {
|
|
-re "missing argument for \"-$full\".*$gdb_prompt " {
|
|
pass $tst
|
|
}
|
|
}
|
|
}
|
|
}
|
|
set tst "complete -$full with no value"
|
|
send_gdb "break -$full \t"
|
|
gdb_test_multiple "" $tst {
|
|
-re ".*break -$full " {
|
|
send_gdb "\n"
|
|
gdb_test_multiple "" $tst {
|
|
-re ".*Source filename requires function, label, or line offset\..*$gdb_prompt " {
|
|
if {[string equal $full "source"]} {
|
|
pass $tst
|
|
} else {
|
|
fail $tst
|
|
}
|
|
}
|
|
-re "missing argument for \"-$full\".*$gdb_prompt " {
|
|
pass $tst
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
set tst "complete unique function name"
|
|
send_gdb "break -function my_unique_func\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -function my_unique_function_name" {
|
|
send_gdb "\n"
|
|
gdb_test "" ".*Breakpoint \[0-9\]+.*" $tst
|
|
gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
|
|
}
|
|
}
|
|
|
|
set tst "complete non-unique function name"
|
|
send_gdb "break -function myfunc\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -function myfunc\\\x07tion" {
|
|
send_gdb "\t\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "\\\x07\r\nmyfunction\[ \t\]+myfunction2\[ \t\]+myfunction3\[ \t\]+myfunction4\[ \t\]+\r\n$gdb_prompt " {
|
|
gdb_test "2" ".*Breakpoint \[0-9\]+.*" $tst
|
|
gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
set tst "complete non-existant function name"
|
|
send_gdb "break -function foo\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -function foo\\\x07" {
|
|
send_gdb "\t\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "\\\x07\\\x07" {
|
|
send_gdb "\n"
|
|
gdb_test "" {Function "foo" not defined.} $tst
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
with_test_prefix "complete unique file name" {
|
|
foreach qc $completion::maybe_quoted_list {
|
|
set cmd "break -source ${qc}3explicit.c${qc}"
|
|
test_gdb_complete_unique \
|
|
"break -source ${qc}3ex" \
|
|
$cmd
|
|
gdb_test $cmd \
|
|
{Source filename requires function, label, or line offset.}
|
|
}
|
|
}
|
|
|
|
set tst "complete non-unique file name"
|
|
send_gdb "break -source exp\t"
|
|
# We're matching two cases here:
|
|
# - without GLIBC debuginfo
|
|
# (gdb) break -source exp^Glicit^G^M
|
|
# explicit.c explicit2.c ^M
|
|
# (gdb) break -source explicit^M
|
|
# Source filename requires function, label, or line offset.^M
|
|
# (gdb) PASS: gdb.linespec/explicit.exp: complete non-unique file name
|
|
# - with GLIBC debuginfo:
|
|
# (gdb) break -source exp^Gl^G^M
|
|
# explicit.c explicit2.c explicit_bzero.c explicit_bzero_chk.c \
|
|
# explodename.c ^M
|
|
# (gdb) break -source expl^M
|
|
# Source filename requires function, label, or line offset.^M
|
|
# (gdb) PASS: gdb.linespec/explicit.exp: complete non-unique file name
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -source exp\\\x07l" {
|
|
# At this point, either output is done (first case), or a
|
|
# further "icit" is emitted (second case). We have no reliable
|
|
# way to decide one way or another, so just send the tabs, even
|
|
# though that may be a little early in the second case.
|
|
send_gdb "\t\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "\\\x07\r\nexplicit.c\[ \t\]+explicit2.c\[ \t\]+\(expl.*\)?\r\n$gdb_prompt" {
|
|
send_gdb "\n"
|
|
gdb_test "" \
|
|
{Source filename requires function, label, or line offset.} \
|
|
$tst
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
set tst "complete non-existant file name"
|
|
send_gdb "break -source foo\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -source foo" {
|
|
send_gdb "\t\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "\\\x07\\\x07" {
|
|
send_gdb "\n"
|
|
gdb_test "" \
|
|
{Source filename requires function, label, or line offset.} \
|
|
$tst
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
set tst "complete filename and unique function name"
|
|
send_gdb "break -source explicit.c -function ma\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -source explicit.c -function main " {
|
|
send_gdb "\n"
|
|
gdb_test "" ".*Breakpoint .*" $tst
|
|
gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
|
|
}
|
|
}
|
|
|
|
set tst "complete filename and non-unique function name"
|
|
send_gdb "break -so 3explicit.c -func myfunc\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -so 3explicit.c -func myfunc\\\x07tion" {
|
|
send_gdb "\t\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "\\\x07\r\nmyfunction3\[ \t\]+myfunction4\[ \t\]+\r\n$gdb_prompt " {
|
|
gdb_test "3" ".*Breakpoint \[0-9\]+.*" $tst
|
|
gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
set tst "complete filename and non-existant function name"
|
|
send_gdb "break -sou 3explicit.c -fun foo\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -sou 3explicit.c -fun foo\\\x07" {
|
|
send_gdb "\t\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "\\\x07\\\x07" {
|
|
send_gdb "\n"
|
|
gdb_test "" \
|
|
{Function "foo" not defined in "3explicit.c".} $tst
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
set tst "complete filename and function reversed"
|
|
send_gdb "break -func myfunction4 -source 3ex\t"
|
|
gdb_test_multiple "" $tst {
|
|
-re "break -func myfunction4 -source 3explicit.c " {
|
|
send_gdb "\n"
|
|
gdb_test "" "Breakpoint \[0-9\]+.*" $tst
|
|
gdb_test_no_output "delete \$bpnum" "delete $tst breakpoint"
|
|
}
|
|
}
|
|
|
|
with_test_prefix "complete unique label name" {
|
|
foreach qc $completion::maybe_quoted_list {
|
|
test_gdb_complete_unique \
|
|
"break -function myfunction -label ${qc}to" \
|
|
"break -function myfunction -label ${qc}top${qc}"
|
|
}
|
|
}
|
|
|
|
with_test_prefix "complete unique label name with source file" {
|
|
test_gdb_complete_unique \
|
|
"break -source explicit.c -function myfunction -label to" \
|
|
"break -source explicit.c -function myfunction -label top"
|
|
}
|
|
|
|
with_test_prefix "complete unique label name reversed" {
|
|
test_gdb_complete_multiple "b -label top -function " "myfunction" "" {
|
|
"myfunction"
|
|
"myfunction2"
|
|
"myfunction3"
|
|
"myfunction4"
|
|
}
|
|
}
|
|
|
|
with_test_prefix "complete non-unique label name" {
|
|
test_gdb_complete_multiple "b -function myfunction -label " "" "" {
|
|
"done"
|
|
"top"
|
|
}
|
|
}
|
|
|
|
# The program is stopped at myfunction, so gdb is able to
|
|
# infer the label's function.
|
|
with_test_prefix "complete label name with no function" {
|
|
test_gdb_complete_unique \
|
|
"break -label to" \
|
|
"break -label top"
|
|
check_bp_locations_match_list \
|
|
"break -label top" {
|
|
"-function myfunction -label top"
|
|
}
|
|
}
|
|
|
|
# See above.
|
|
with_test_prefix "complete label name with source file but no function" {
|
|
test_gdb_complete_unique \
|
|
"break -source explicit.c -label to" \
|
|
"break -source explicit.c -label top"
|
|
check_bp_locations_match_list \
|
|
"break -source explicit.c -label top" {
|
|
"-source explicit.c -function myfunction -label top"
|
|
}
|
|
}
|
|
|
|
with_test_prefix "complete label name with wrong source file" {
|
|
test_gdb_complete_none \
|
|
"break -source explicit2.c -function myfunction -label to"
|
|
check_setting_bp_fails \
|
|
"break -source explicit2.c -function myfunction -label top"
|
|
}
|
|
|
|
# Get rid of symbols from shared libraries, otherwise
|
|
# "b -source thr<tab>" could find some system library's
|
|
# source.
|
|
gdb_test_no_output "nosharedlibrary"
|
|
|
|
# Test that after a seemingly finished option argument,
|
|
# completion matches both the explicit location options and
|
|
# the linespec keywords.
|
|
set completions_list {
|
|
"-force-condition"
|
|
"-function"
|
|
"-label"
|
|
"-line"
|
|
"-qualified"
|
|
"-source"
|
|
"if"
|
|
"task"
|
|
"thread"
|
|
}
|
|
foreach what { "-function" "-label" "-line" "-source" } {
|
|
# Also test with "-qualified" appearing before the
|
|
# explicit location.
|
|
foreach prefix {"" "-qualified "} {
|
|
|
|
# ... and with "-qualified" appearing after the
|
|
# explicit location.
|
|
foreach suffix {"" " -qualified"} {
|
|
with_test_prefix "complete after $prefix$what$suffix" {
|
|
if {$what != "-line"} {
|
|
set w "$prefix$what argument$suffix "
|
|
test_gdb_complete_multiple \
|
|
"b $w" "" "" $completions_list
|
|
test_gdb_complete_unique \
|
|
"b $w thr" \
|
|
"b $w thread"
|
|
test_gdb_complete_unique \
|
|
"b $w -fun" \
|
|
"b $w -function"
|
|
} else {
|
|
# After -line, we expect a number / offset.
|
|
foreach line {"10" "+10" "-10"} {
|
|
set w "$prefix-line $line$suffix"
|
|
test_gdb_complete_multiple \
|
|
"b $w " "" "" $completions_list
|
|
test_gdb_complete_unique \
|
|
"b $w thr" \
|
|
"b $w thread"
|
|
test_gdb_complete_unique \
|
|
"b $w -fun" \
|
|
"b $w -function"
|
|
}
|
|
|
|
# With an invalid -line argument, we don't get any
|
|
# completions.
|
|
test_gdb_complete_none "b $prefix-line argument$suffix "
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
# These tests don't make sense with "-qualified" after
|
|
# the location.
|
|
with_test_prefix "complete after $prefix$what" {
|
|
# Don't complete a linespec keyword ("thread") or
|
|
# another option name when expecting an option
|
|
# argument.
|
|
test_gdb_complete_none "b $prefix$what thr"
|
|
test_gdb_complete_none "b $prefix$what -fun"
|
|
}
|
|
}
|
|
}
|
|
|
|
# Test that after a seemingly finished option argument,
|
|
# completion for "-" matches both the explicit location
|
|
# options and the linespec keywords that start with "-".
|
|
with_test_prefix "complete '-' after options" {
|
|
test_gdb_complete_multiple "b -function myfunction " "-" "" {
|
|
"-force-condition"
|
|
"-function"
|
|
"-label"
|
|
"-line"
|
|
"-qualified"
|
|
"-source"
|
|
}
|
|
}
|
|
|
|
# Tests that ensure that after "if" we complete on expressions
|
|
# are in cpcompletion.exp.
|
|
|
|
# Disable the completion limit for the rest of the testcase.
|
|
gdb_test_no_output "set max-completions unlimited"
|
|
|
|
# Get rid of symbols from shared libraries, otherwise the
|
|
# completions match list for "break <tab>" is huge and makes
|
|
# the test below quite long while the gdb_test_multiple loop
|
|
# below consumes the matches. Not doing this added ~20
|
|
# seconds at the time of writing. (Actually, already done above.)
|
|
# gdb_test_no_output "nosharedlibrary"
|
|
|
|
# Test completion with no input argument. We should see all
|
|
# the options, plus all the functions. To keep it simple, as
|
|
# proxy, we check for presence of one explicit location
|
|
# option, one probe location, and one function.
|
|
set saw_opt_function 0
|
|
set saw_opt_probe_stap 0
|
|
set saw_function 0
|
|
|
|
set tst "complete with no arguments"
|
|
send_gdb "break \t"
|
|
gdb_test_multiple "" $tst {
|
|
"break \\\x07" {
|
|
send_gdb "\t"
|
|
gdb_test_multiple "" $tst {
|
|
"Display all" {
|
|
send_gdb "y"
|
|
exp_continue
|
|
}
|
|
-re "-function" {
|
|
set saw_opt_function 1
|
|
exp_continue
|
|
}
|
|
-re "-probe-stap" {
|
|
set saw_opt_probe_stap 1
|
|
exp_continue
|
|
}
|
|
-re "myfunction4" {
|
|
set saw_function 1
|
|
exp_continue
|
|
}
|
|
-re "\r\n$gdb_prompt " {
|
|
gdb_assert {$saw_opt_function && $saw_opt_probe_stap && $saw_function} $tst
|
|
}
|
|
-re " " {
|
|
exp_continue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
clear_input_line $tst
|
|
|
|
# NOTE: We don't bother testing more elaborate combinations of options,
|
|
# such as "-func main -sour 3ex\t" (main is defined in explicit.c).
|
|
# The completer cannot handle these yet.
|
|
|
|
# The following completion tests require having no symbols
|
|
# loaded.
|
|
gdb_exit
|
|
gdb_start
|
|
|
|
# The match list you get when you complete with no options
|
|
# specified at all.
|
|
set completion_list {
|
|
"-function"
|
|
"-label"
|
|
"-line"
|
|
"-probe"
|
|
"-probe-dtrace"
|
|
"-probe-stap"
|
|
"-qualified"
|
|
"-source"
|
|
}
|
|
with_test_prefix "complete with no arguments and no symbols" {
|
|
test_gdb_complete_multiple "b " "" "-" $completion_list
|
|
test_gdb_complete_multiple "b " "-" "" $completion_list
|
|
}
|
|
}
|
|
# End of completion tests.
|
|
|
|
# Test pending explicit breakpoints
|
|
gdb_exit
|
|
gdb_start
|
|
|
|
set tst "pending invalid conditional explicit breakpoint"
|
|
if {![gdb_breakpoint "-func myfunction if foofoofoo == 1" \
|
|
allow-pending]} {
|
|
fail "set $tst"
|
|
} else {
|
|
gdb_test "info break" ".*PENDING.*myfunction if foofoofoo == 1.*" $tst
|
|
}
|
|
|
|
gdb_exit
|
|
gdb_start
|
|
|
|
set tst "pending valid conditional explicit breakpoint"
|
|
if {![gdb_breakpoint "-func myfunction if arg == 0" \
|
|
allow-pending]} {
|
|
fail "set $tst"
|
|
} else {
|
|
gdb_test "info break" ".*PENDING.*myfunction if arg == 0" $tst
|
|
|
|
gdb_load [standard_output_file $exefile]
|
|
gdb_test "info break" \
|
|
".*in myfunction at .*$srcfile:.*stop only if arg == 0.*" \
|
|
"$tst resolved"
|
|
}
|
|
|
|
# Test interaction of condition command and explicit linespec conditons.
|
|
gdb_exit
|
|
gdb_start
|
|
gdb_load [standard_output_file $exefile]
|
|
|
|
set tst "condition_command overrides explicit linespec condition"
|
|
if {![runto_main]} {
|
|
fail $tst
|
|
} else {
|
|
if {![gdb_breakpoint "-func myfunction if arg == 1"]} {
|
|
fail "set breakpoint with condition 'arg == 1'"
|
|
} else {
|
|
gdb_test_no_output "cond 2 arg == 0" \
|
|
"set new breakpoint condition for explicit linespec"
|
|
|
|
gdb_continue_to_breakpoint $tst $location(normal)
|
|
}
|
|
}
|
|
|
|
gdb_test "cond 2" [string_to_regexp "Breakpoint 2 now unconditional."] \
|
|
"clear condition for explicit breakpoint"
|
|
set tst "info break of cleared condition of explicit breakpoint"
|
|
gdb_test_multiple "info break" $tst {
|
|
-re ".*in myfunction at .*$srcfile:.*stop only if arg == 0.*" {
|
|
fail $tst
|
|
}
|
|
-re ".*in myfunction at .*$srcfile:.*$gdb_prompt $" {
|
|
pass $tst
|
|
}
|
|
}
|
|
|
|
# Test explicit "ranges." Make sure that using explicit
|
|
# locations doesn't alter the expected outcome.
|
|
gdb_test "list -q main" ".*" "list main 1"
|
|
set list_result [capture_command_output "list -,+" ""]
|
|
gdb_test "list -q main" ".*" "list main 2"
|
|
gdb_test "list -line -,-line +" [string_to_regexp $list_result]
|
|
|
|
# Ditto for the reverse (except that no output is expected).
|
|
gdb_test "list -q myfunction" ".*" "list myfunction 1"
|
|
gdb_test_no_output "list +,-"
|
|
gdb_test "list -q myfunction" ".*" "list myfunction 2"
|
|
gdb_test_no_output "list -line +, -line -"
|
|
}
|
|
|
|
namespace delete $testfile
|