-# Copyright 1988, 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999,
-# 2000, 2002, 2003, 2004
-# Free Software Foundation, Inc.
+# Copyright 1988-2020 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 2 of the License, or
+# 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, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-# Please email any bugs, comments, and/or additions to this file to:
-# bug-gdb@prep.ai.mit.edu
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Based on break.exp, written by Rob Savoye. (rob@cygnus.com)
# Modified to test gdb's handling of separate debug info files.
+# Modified to test gdb's handling of a debug-id retrieval.
# This file has two parts. The first is testing that gdb behaves
# normally after reading in an executable and its corresponding
# separate debug file. The second moves the .debug file to a different
# location and tests the "set debug-file-directory" command.
+# The third is for testing build-id retrievel by finding the separate
+# ".debug-id/ab/cdef.debug" file.
-if $tracelevel then {
- strace $tracelevel
-}
-
#
# test running programs
#
-set prms_id 0
-set bug_id 0
-set testfile "sepdebug"
-set srcfile ${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}
+standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {
- gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
-}
-
-# FIXME: this is nasty. We need to check for the stabs debug format.
-# To do this we must run gdb on the unstripped executable, list 'main'
-# (as to have a default source file), use get_debug_format (which does
-# 'info source') and then see if the debug info is stabs. If so, we
-# bail out. We cannot do this any other way because get_debug_format
-# finds out the debug format using gdb itself, and in case of stabs we
-# get an error loading the program if it is already stripped. An
-# alternative would be to find out the debug info from the flags
-# passed to dejagnu when the test is run.
-
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
-gdb_test "list main" "" ""
-get_debug_format
-if { [test_debug_format "stabs"] } then {
- # the separate debug info feature doesn't work well in binutils with stabs.
- # It produces a corrupted debug info only file, and gdb chokes on it.
- # It is almost impossible to capture the failing message out of gdb,
- # because it happens inside gdb_load. At that point any error message
- # is intercepted by dejagnu itself, and, because of the error threshold,
- # any faulty test result is changed into an UNRESOLVED.
- # (see dejagnu/lib/framework.exp)
- unsupported "no separate debug info handling with stabs"
- return -1
-} elseif { [test_debug_format "unknown"] } then {
- # gdb doesn't know what the debug format is. We are out of luck here.
- unsupported "unknown debugging format"
+ untested "failed to compile"
return -1
}
-gdb_exit
# Note: the procedure gdb_gnu_strip_debug will produce an executable called
# ${binfile}, which is just like the executable ($binfile) but without
-# the debuginfo. Instead $binfile has a .gnudebuglink section which contains
+# the debuginfo. Instead $binfile has a .gnu_debuglink section which contains
# the name of a debuginfo only file. This file will be stored in the
-# gdb.base/.debug subdirectory.
+# gdb.base/ subdirectory.
-if [gdb_gnu_strip_debug $binfile] {
+if [gdb_gnu_strip_debug $binfile$EXEEXT] {
# check that you have a recent version of strip and objcopy installed
unsupported "cannot produce separate debug info files"
return -1
}
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load ${binfile}
+#
+# PR gdb/9538. Verify that symlinked executable still finds the separate
+# debuginfo.
+#
+set old_subdir $subdir
+set subdir [file join ${old_subdir} pr9538]
+
+# Cleanup any stale state.
+set new_name [standard_output_file ${testfile}${EXEEXT}]
+remote_exec build "rm -rf [file dirname $new_name]"
+
+remote_exec build "mkdir [file dirname $new_name]"
+remote_exec build "ln -s ${binfile}${EXEEXT} $new_name"
+clean_restart ${testfile}${EXEEXT}
+if { $gdb_file_cmd_debug_info != "debug" } then {
+ fail "no debug information found."
+}
+
+# Restore subdir
+set subdir ${old_subdir}
-if [target_info exists gdb_stub] {
- gdb_step_for_stub;
+clean_restart ${testfile}${EXEEXT}
+if { $gdb_file_cmd_debug_info != "debug" } then {
+ fail "no debug information found."
}
+
#
# test simple breakpoint setting commands
#
-# Test deleting all breakpoints when there are none installed,
-# GDB should not prompt for confirmation.
-# Note that gdb-init.exp provides a "delete_breakpoints" proc
-# for general use elsewhere.
-
-send_gdb "delete breakpoints\n"
-gdb_expect {
- -re "Delete all breakpoints.*$" {
- send_gdb "y\n"
- gdb_expect {
- -re "$gdb_prompt $" {
- fail "Delete all breakpoints when none (unexpected prompt)"
- }
- timeout { fail "Delete all breakpoints when none (timeout after unexpected prompt)" }
- }
- }
- -re ".*$gdb_prompt $" { pass "Delete all breakpoints when none" }
- timeout { fail "Delete all breakpoints when none (timeout)" }
-}
-
#
# test break at function
#
# board. So, to be sure, we do a list command.
#
gdb_test "list main" \
- ".*main \\(argc, argv, envp\\).*" \
+ ".*main \\(int argc, char \\*\\*argv, char \\*\\*envp\\).*" \
"use `list' to establish default source file"
gdb_test "break $bp_location1" \
"Breakpoint.*at.* file .*$srcfile, line $bp_location1\\." \
"Breakpoint.*at.* file .*$srcfile, line $bp_location4\\." \
"breakpoint at start of multi line while conditional"
-set bp_location5 [gdb_get_line_number "set breakpoint 5 here"]
set bp_location6 [gdb_get_line_number "set breakpoint 6 here"]
-#
-# check to see what breakpoints are set
-#
-if [target_info exists gdb_stub] {
- set main_line $bp_location5
-} else {
- set main_line $bp_location6
-}
+set main_line $bp_location6
set bp_location7 [gdb_get_line_number "set breakpoint 7 here"]
set bp_location8 [gdb_get_line_number "set breakpoint 8 here"]
-set bp_location9 [gdb_get_line_number "set breakpoint 9 here"]
gdb_test "info break" \
- "Num Type\[ \]+Disp Enb Address\[ \]+What.*
+ "Num Type\[ \]+Disp Enb Address\[ \]+What.*
\[0-9\]+\[\t \]+breakpoint keep y.* in main at .*$srcfile:$main_line.*
-\[0-9\]+\[\t \]+breakpoint keep y.* in marker2 at .*$srcfile:($bp_location8|$bp_location9).*
+\[0-9\]+\[\t \]+breakpoint keep y.* in marker2 at .*$srcfile:$bp_location8.*
\[0-9\]+\[\t \]+breakpoint keep y.* in factorial at .*$srcfile:$bp_location7.*
\[0-9\]+\[\t \]+breakpoint keep y.* in main at .*$srcfile:$bp_location1.*
\[0-9\]+\[\t \]+breakpoint keep y.* in main at .*$srcfile:$bp_location1.*
# handle arguments.
# Huh? There doesn't *appear* to be anything that passes arguments
# below.
-if [istarget "mips-idt-*"] then {
- return
-}
#
# run until the breakpoint at main is hit. For non-stubs-using targets.
#
-if ![target_info exists use_gdb_stub] {
- if [istarget "*-*-vxworks*"] then {
- send_gdb "run vxmain \"2\"\n"
- set timeout 120
- verbose "Timeout is now $timeout seconds" 2
- } else {
- send_gdb "run\n"
- }
- gdb_expect {
- -re "The program .* has been started already.*y or n. $" {
- send_gdb "y\n"
- exp_continue
- }
- -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $"\
- { pass "run until function breakpoint" }
- -re ".*$gdb_prompt $" { fail "run until function breakpoint" }
- timeout { fail "run until function breakpoint (timeout)" }
- }
-} else {
- if ![target_info exists gdb_stub] {
- gdb_test continue ".*Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.*\{.*" "stub continue"
- }
-}
+gdb_run_cmd
+gdb_test "" \
+ "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*" \
+ "run until function breakpoint"
#
# run until the breakpoint at a line number
#
# Run until the breakpoint set at a quoted function
#
-gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, (0x\[0-9a-f\]+ in )?marker2 \\(a=43\\) at .*$srcfile:($bp_location8|$bp_location9).*" \
+gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, (0x\[0-9a-f\]+ in )?marker2 \\(a=43\\) at .*$srcfile:$bp_location8.*" \
"run until quoted breakpoint"
#
# run until the file:function breakpoint at a line number in a file
# test temporary breakpoint at function
#
-gdb_test "tbreak main" "Breakpoint.*at.* file .*$srcfile, line.*" "Temporary breakpoint function"
+gdb_test "tbreak main" "Temporary breakpoint.*at.* file .*$srcfile, line.*" "temporary breakpoint function"
#
# test break at function in file
#
-gdb_test "tbreak $srcfile:factorial" "Breakpoint.*at.* file .*$srcfile, line.*" \
+gdb_test "tbreak $srcfile:factorial" "Temporary breakpoint.*at.* file .*$srcfile, line.*" \
"Temporary breakpoint function in file"
#
# test break at line number
#
-send_gdb "tbreak $bp_location1\n"
-gdb_expect {
- -re "Breakpoint.*at.* file .*$srcfile, line $bp_location1.*$gdb_prompt $" { pass "Temporary breakpoint line number #1" }
- -re ".*$gdb_prompt $" { pass "Temporary breakpoint line number #1" }
- timeout { fail "breakpoint line number #1 (timeout)" }
-}
-gdb_test "tbreak $bp_location6" "Breakpoint.*at.* file .*$srcfile, line $bp_location6.*" "Temporary breakpoint line number #2"
+gdb_test "tbreak $bp_location1" \
+ "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location1.*" \
+ "temporary breakpoint line number #1"
+
+gdb_test "tbreak $bp_location6" \
+ "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location6.*" \
+ "temporary breakpoint line number #2"
#
# test break at line number in file
#
-send_gdb "tbreak $srcfile:$bp_location2\n"
-gdb_expect {
- -re "Breakpoint.*at.* file .*$srcfile, line $bp_location2.*$gdb_prompt $" { pass "Temporary breakpoint line number in file #1" }
- -re ".*$gdb_prompt $" { pass "Temporary breakpoint line number in file #1" }
- timeout { fail "Temporary breakpoint line number in file #1 (timeout)" }
-}
+
+gdb_test "tbreak $srcfile:$bp_location2" \
+ "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location2.*" \
+ "temporary breakpoint line number in file #1"
set bp_location11 [gdb_get_line_number "set breakpoint 11 here"]
-gdb_test "tbreak $srcfile:$bp_location11" "Breakpoint.*at.* file .*$srcfile, line $bp_location11.*" "Temporary breakpoint line number in file #2"
+gdb_test "tbreak $srcfile:$bp_location11" "Temporary breakpoint.*at.* file .*$srcfile, line $bp_location11.*" "Temporary breakpoint line number in file #2"
#
# check to see what breakpoints are set (temporary this time)
#
-gdb_test "info break" "Num Type.*Disp Enb Address.*What.*\[\r\n\]
+gdb_test "info break" "Num Type.*Disp Enb Address.*What.*\[\r\n\]
\[0-9\]+\[\t \]+breakpoint del.*y.*in main at .*$srcfile:$main_line.*\[\r\n\]
\[0-9\]+\[\t \]+breakpoint del.*y.*in factorial at .*$srcfile:$bp_location7.*\[\r\n\]
\[0-9\]+\[\t \]+breakpoint del.*y.*in main at .*$srcfile:$bp_location1.*\[\r\n\]
# inappropriately. (There are no calls to those system functions
# in this test program.)
#
-if ![runto_main] then { fail "break tests suppressed" }
-
-send_gdb "catch\n"
-gdb_expect {
- -re "Catch requires an event name.*$gdb_prompt $"\
- {pass "catch requires an event name"}
- -re "$gdb_prompt $"\
- {fail "catch requires an event name"}
- timeout {fail "(timeout) catch requires an event name"}
-}
-
+if ![runto_main] then { fail "sepdebug tests suppressed" }
-set name "set catch fork, never expected to trigger"
-send_gdb "catch fork\n"
-gdb_expect {
- -re "Catchpoint \[0-9\]* .fork..*$gdb_prompt $"
- {pass $name}
- -re "Catch of fork not yet implemented.*$gdb_prompt $"
- {pass $name}
- -re "$gdb_prompt $"
- {fail $name}
- timeout {fail "(timeout) $name"}
-}
-
-
-set name "set catch vfork, never expected to trigger"
-send_gdb "catch vfork\n"
+gdb_test "catch fork" "Catchpoint \[0-9\]+ \\(fork\\)" \
+ "set catch fork, never expected to trigger"
-# If we are on HP-UX 10.20, we expect an error message to be
-# printed if we type "catch vfork" at the gdb gdb_prompt. This is
-# because on HP-UX 10.20, we cannot catch vfork events.
-
-if [istarget "hppa*-hp-hpux10.20"] then {
- gdb_expect {
- -re "Catch of vfork events not supported on HP-UX 10.20..*$gdb_prompt $"
- {pass $name}
- -re "$gdb_prompt $"
- {fail $name}
- timeout {fail "(timeout) $name"}
- }
-} else {
- gdb_expect {
- -re "Catchpoint \[0-9\]* .vfork..*$gdb_prompt $"
- {pass $name}
- -re "Catch of vfork not yet implemented.*$gdb_prompt $"
- {pass $name}
- -re "$gdb_prompt $"
- {fail $name}
- timeout {fail "(timeout) $name"}
- }
-}
+gdb_test "catch vfork" "Catchpoint \[0-9\]+ \\(vfork\\)" \
+ "set catch vfork, never expected to trigger"
-set name "set catch exec, never expected to trigger"
-send_gdb "catch exec\n"
-gdb_expect {
- -re "Catchpoint \[0-9\]* .exec..*$gdb_prompt $"
- {pass $name}
- -re "Catch of exec not yet implemented.*$gdb_prompt $"
- {pass $name}
- -re "$gdb_prompt $" {fail $name}
- timeout {fail "(timeout) $name"}
-}
+gdb_test "catch exec" "Catchpoint \[0-9\]+ \\(exec\\)" \
+ "set catch exec, never expected to trigger"
# Verify that GDB responds gracefully when asked to set a breakpoint
# on a nonexistent source line.
#
-send_gdb "break 999\n"
-gdb_expect {
- -re "No line 999 in file .*$gdb_prompt $"\
- {pass "break on non-existent source line"}
- -re "$gdb_prompt $"\
- {fail "break on non-existent source line"}
- timeout {fail "(timeout) break on non-existent source line"}
-}
+
+gdb_test_no_output "set breakpoint pending off"
+gdb_test "break 999" "No line 999 in the current file." \
+ "break on non-existent source line"
# Run to the desired default location. If not positioned here, the
# tests below don't work.
# the informational message about other breakpoints at the same
# location. We'll hit that bird with this stone too.
#
-send_gdb "break\n"
-gdb_expect {
- -re "Breakpoint \[0-9\]*.*$gdb_prompt $"\
- {pass "break on default location, 1st time"}
- -re "$gdb_prompt $"\
- {fail "break on default location, 1st time"}
- timeout {fail "(timeout) break on default location, 1st time"}
-}
-send_gdb "break\n"
-gdb_expect {
- -re "Note: breakpoint \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
- {pass "break on default location, 2nd time"}
- -re "$gdb_prompt $"\
- {fail "break on default location, 2nd time"}
- timeout {fail "(timeout) break on default location, 2nd time"}
-}
+gdb_test "break" "Breakpoint \[0-9\]*.*" \
+ "break on default location, 1st time"
-send_gdb "break\n"
-gdb_expect {
- -re "Note: breakpoints \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
- {pass "break on default location, 3rd time"}
- -re "$gdb_prompt $"\
- {fail "break on default location, 3rd time"}
- timeout {fail "(timeout) break on default location, 3rd time"}
-}
+gdb_test "break" \
+ "Note: breakpoint \[0-9\]* also set at .*Breakpoint \[0-9\]*.*" \
+ "break on default location, 2nd time"
-send_gdb "break\n"
-gdb_expect {
- -re "Note: breakpoints \[0-9\]*, \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*$gdb_prompt $"\
- {pass "break on default location, 4th time"}
- -re "$gdb_prompt $"\
- {fail "break on default location, 4th time"}
- timeout {fail "(timeout) break on default location, 4th time"}
-}
+gdb_test "break" \
+ "Note: breakpoints \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*" \
+ "break on default location, 3rd time"
+
+gdb_test "break" \
+ "Note: breakpoints \[0-9\]*, \[0-9\]* and \[0-9\]* also set at .*Breakpoint \[0-9\]*.*" \
+ "break on default location, 4th time"
# Verify that a "silent" breakpoint can be set, and that GDB is indeed
# "silent" about its triggering.
#
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then { fail "sepdebug tests suppressed" }
-send_gdb "break $bp_location1\n"
-gdb_expect {
- -re "Breakpoint (\[0-9\]*) at .*, line $bp_location1.*$gdb_prompt $"\
- {pass "set to-be-silent break bp_location1"}
- -re "$gdb_prompt $"\
- {fail "set to-be-silent break bp_location1"}
- timeout {fail "(timeout) set to-be-silent break bp_location1"}
+gdb_test_multiple "break $bp_location1" \
+ "set to-be-silent break bp_location1" {
+ -re "Breakpoint (\[0-9\]*) at .*, line $bp_location1.*$gdb_prompt $" {
+ pass "set to-be-silent break bp_location1"
+ }
}
-send_gdb "commands $expect_out(1,string)\n"
-send_gdb "silent\n"
-send_gdb "end\n"
-gdb_expect {
- -re ".*$gdb_prompt $"\
- {pass "set silent break bp_location1"}
- timeout {fail "(timeout) set silent break bp_location1"}
-}
+gdb_test "commands $expect_out(1,string)\nsilent\nend" ">end" "set silent break bp_location1"
-send_gdb "info break $expect_out(1,string)\n"
-gdb_expect {
- -re "\[0-9\]*\[ \t\]*breakpoint.*:$bp_location1\r\n\[ \t\]*silent.*$gdb_prompt $"\
- {pass "info silent break bp_location1"}
- -re "$gdb_prompt $"\
- {fail "info silent break bp_location1"}
- timeout {fail "(timeout) info silent break bp_location1"}
-}
-send_gdb "continue\n"
-gdb_expect {
- -re "Continuing.\r\n$gdb_prompt $"\
- {pass "hit silent break bp_location1"}
- -re "$gdb_prompt $"\
- {fail "hit silent break bp_location1"}
- timeout {fail "(timeout) hit silent break bp_location1"}
-}
-send_gdb "bt\n"
-gdb_expect {
- -re "#0 main .* at .*:$bp_location1.*$gdb_prompt $"\
- {pass "stopped for silent break bp_location1"}
- -re "$gdb_prompt $"\
- {fail "stopped for silent break bp_location1"}
- timeout {fail "(timeout) stopped for silent break bp_location1"}
-}
+gdb_test "info break $expect_out(1,string)" \
+ "\[0-9\]*\[ \t\]*breakpoint.*:$bp_location1\r\n\[ \t\]*silent.*" \
+ "info silent break bp_location1"
+
+gdb_test "continue" "Continuing.*" "hit silent break bp_location1"
+
+gdb_test "bt" "#0 main .* at .*:$bp_location1.*" \
+ "stopped for silent break bp_location1"
# Verify that GDB can at least parse a breakpoint with the
# "thread" keyword. (We won't attempt to test here that a
# The gdb.threads subdirectory contains tests for that.)
#
set bp_location12 [gdb_get_line_number "set breakpoint 12 here"]
-send_gdb "break $bp_location12 thread 999\n"
-gdb_expect {
- -re "Unknown thread 999.*$gdb_prompt $"\
- {pass "thread-specific breakpoint on non-existent thread disallowed"}
- -re "$gdb_prompt $"\
- {fail "thread-specific breakpoint on non-existent thread disallowed"}
- timeout {fail "(timeout) thread-specific breakpoint on non-existent thread disallowed"}
-}
-send_gdb "break $bp_location12 thread foo\n"
-gdb_expect {
- -re "Junk after thread keyword..*$gdb_prompt $"\
- {pass "thread-specific breakpoint on bogus thread ID disallowed"}
- -re "$gdb_prompt $"\
- {fail "thread-specific breakpoint on bogus thread ID disallowed"}
- timeout {fail "(timeout) thread-specific breakpoint on bogus thread ID disallowed"}
-}
+
+gdb_test "break $bp_location12 thread 999" "Unknown thread 999.*" \
+ "thread-specific breakpoint on non-existent thread disallowed"
+
+gdb_test "break $bp_location12 thread foo" \
+ "Invalid thread ID: foo" \
+ "thread-specific breakpoint on bogus thread ID disallowed"
# Verify that GDB responds gracefully to a breakpoint command with
# trailing garbage.
#
-send_gdb "break $bp_location12 foo\n"
-gdb_expect {
- -re "Junk at end of arguments..*$gdb_prompt $"\
- {pass "breakpoint with trailing garbage disallowed"}
- -re "$gdb_prompt $"\
- {fail "breakpoint with trailing garbage disallowed"}
- timeout {fail "(timeout) breakpoint with trailing garbage disallowed"}
-}
+
+gdb_test "break $bp_location12 foo" \
+ "malformed linespec error: unexpected string, \"foo\".*" \
+ "breakpoint with trailing garbage disallowed"
# Verify that GDB responds gracefully to a "clear" command that has
# no matching breakpoint. (First, get us off the current source line,
# which we know has a breakpoint.)
#
-send_gdb "next\n"
-gdb_expect {
- -re ".*$gdb_prompt $"\
- {pass "step over breakpoint"}
- timeout {fail "(timeout) step over breakpoint"}
-}
-send_gdb "clear 81\n"
-gdb_expect {
- -re "No breakpoint at 81..*$gdb_prompt $"\
- {pass "clear line has no breakpoint disallowed"}
- -re "$gdb_prompt $"\
- {fail "clear line has no breakpoint disallowed"}
- timeout {fail "(timeout) clear line has no breakpoint disallowed"}
-}
-send_gdb "clear\n"
-gdb_expect {
- -re "No breakpoint at this line..*$gdb_prompt $"\
- {pass "clear current line has no breakpoint disallowed"}
- -re "$gdb_prompt $"\
- {fail "clear current line has no breakpoint disallowed"}
- timeout {fail "(timeout) clear current line has no breakpoint disallowed"}
-}
+
+gdb_test "next" "marker1.*" "step over breakpoint"
+
+gdb_test "clear 81" "No breakpoint at 81.*" \
+ "clear line has no breakpoint disallowed"
+
+gdb_test "clear" "No breakpoint at this line.*" \
+ "clear current line has no breakpoint disallowed"
# Verify that we can set and clear multiple breakpoints.
#
# Verify that a breakpoint can be set via a convenience variable.
#
-send_gdb "set \$foo=$bp_location11\n"
-gdb_expect {
- -re "$gdb_prompt $"\
- {pass "set convenience variable \$foo to bp_location11"}
- timeout {fail "(timeout) set convenience variable \$foo to bp_location11"}
-}
-send_gdb "break \$foo\n"
-gdb_expect {
- -re "Breakpoint (\[0-9\]*) at .*, line $bp_location11.*$gdb_prompt $"\
- {pass "set breakpoint via convenience variable"}
- -re "$gdb_prompt $"\
- {fail "set breakpoint via convenience variable"}
- timeout {fail "(timeout) set breakpoint via convenience variable"}
-}
+
+gdb_test_no_output "set \$foo=$bp_location11" \
+ "set convenience variable \$foo to bp_location11"
+
+gdb_test "break \$foo" \
+ "Breakpoint (\[0-9\]*) at .*, line $bp_location11.*" \
+ "set breakpoint via convenience variable"
# Verify that GDB responds gracefully to an attempt to set a
# breakpoint via a convenience variable whose type is not integer.
#
-send_gdb "set \$foo=81.5\n"
-gdb_expect {
- -re "$gdb_prompt $"\
- {pass "set convenience variable \$foo to 81.5"}
- timeout {fail "(timeout) set convenience variable \$foo to 81.5"}
-}
-send_gdb "break \$foo\n"
-gdb_expect {
- -re "Convenience variables used in line specs must have integer values..*$gdb_prompt $"\
- {pass "set breakpoint via non-integer convenience variable disallowed"}
- -re "$gdb_prompt $"\
- {fail "set breakpoint via non-integer convenience variable disallowed"}
- timeout {fail "(timeout) set breakpoint via non-integer convenience variable disallowed"}
-}
+
+gdb_test_no_output "set \$foo=81.5" \
+ "set convenience variable \$foo to 81.5"
+
+gdb_test "break \$foo" \
+ "Convenience variables used in line specs must have integer values.*" \
+ "set breakpoint via non-integer convenience variable disallowed"
# Verify that we can set and trigger a breakpoint in a user-called function.
#
-send_gdb "break marker2\n"
-gdb_expect {
- -re "Breakpoint (\[0-9\]*) at .*, line ($bp_location8|$bp_location9).*$gdb_prompt $"\
- {pass "set breakpoint on to-be-called function"}
- -re "$gdb_prompt $"\
- {fail "set breakpoint on to-be-called function"}
- timeout {fail "(timeout) set breakpoint on to-be-called function"}
-}
-send_gdb "print marker2(99)\n"
-gdb_expect {
- -re "The program being debugged stopped while in a function called from GDB.\r\nWhen the function .marker2. is done executing, GDB will silently\r\nstop .instead of continuing to evaluate the expression containing\r\nthe function call...*$gdb_prompt $"\
- {pass "hit breakpoint on called function"}
- -re "$gdb_prompt $"\
- {fail "hit breakpoint on called function"}
- timeout {fail "(timeout) hit breakpoint on called function"}
-}
+
+gdb_test "break marker2" \
+ "Breakpoint (\[0-9\]*) at .*, line $bp_location8.*" \
+ "set breakpoint on to-be-called function"
+
+gdb_test "print marker2(99)" \
+ "The program being debugged stopped while in a function called from GDB.\r\nEvaluation of the expression containing the function\r\n.marker2. will be abandoned.\r\nWhen the function is done executing, GDB will silently stop.*" \
+ "hit breakpoint on called function"
# As long as we're stopped (breakpointed) in a called function,
# verify that we can successfully backtrace & such from here.
-#
-# In this and the following test, the _sr4export check apparently is needed
-# for hppa*-*-hpux.
-#
-send_gdb "bt\n"
-gdb_expect {
- -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*_sr4export.*$gdb_prompt $"\
- {pass "backtrace while in called function"}
- -re "#0\[ \t\]*($hex in )?marker2.*:($bp_location8|$bp_location9)\r\n#1.*function called from gdb.*$gdb_prompt $"\
- {pass "backtrace while in called function"}
- -re "$gdb_prompt $"\
- {fail "backtrace while in called function"}
- timeout {fail "(timeout) backtrace while in called function"}
-}
+
+gdb_test "bt" \
+ "#0\[ \t\]*($hex in )?marker2.*:$bp_location8\r\n#1\[ \t\]*<function called from gdb>.*" \
+ "backtrace while in called function"
# Return from the called function. For remote targets, it's important to do
# this before runto_main, which otherwise may silently stop on the dummy
# breakpoint inserted by GDB at the program's entry point.
#
-send_gdb "finish\n"
-gdb_expect {
- -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.* in _sr4export.*$gdb_prompt $"\
- {pass "finish from called function"}
- -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*function called from gdb.*$gdb_prompt $"\
- {pass "finish from called function"}
- -re "Run till exit from .*marker2.* at .*($bp_location8|$bp_location9)\r\n.*Value returned.*$gdb_prompt $"\
- {pass "finish from called function"}
- -re "$gdb_prompt $"\
- {fail "finish from called function"}
- timeout {fail "(timeout) finish from called function"}
+
+gdb_test_multiple "finish" "finish from called function" {
+ -re "Run till exit from .*marker2.* at .*$bp_location8\r\n.*function called from gdb.*$gdb_prompt $" {
+ pass "finish from called function"
+ }
+ -re "Run till exit from .*marker2.* at .*$bp_location8\r\n.*Value returned.*$gdb_prompt $" {
+ pass "finish from called function"
+ }
}
# Verify that GDB responds gracefully to a "finish" command with
# arguments.
#
-if ![runto_main] then { fail "break tests suppressed" }
+if ![runto_main] then { fail "sepdebug tests suppressed" }
-send_gdb "finish 123\n"
-gdb_expect {
- -re "The \"finish\" command does not take any arguments.\r\n$gdb_prompt $"\
- {pass "finish with arguments disallowed"}
- -re "$gdb_prompt $"\
- {fail "finish with arguments disallowed"}
- timeout {fail "(timeout) finish with arguments disallowed"}
-}
+gdb_test "finish 123" \
+ "The \"finish\" command does not take any arguments.*" \
+ "finish with arguments disallowed"
# Verify that GDB responds gracefully to a request to "finish" from
# the outermost frame. On a stub that never exits, this will just
# second condition.
#
-send_gdb "finish\n"
-gdb_expect {
- -re "\"finish\" not meaningful in the outermost frame.\r\n$gdb_prompt $"\
- {pass "finish from outermost frame disallowed"}
- -re "Run till exit from.*\r\n$gdb_prompt $" {
- pass "finish from outermost frame disallowed"
- }
- -re "$gdb_prompt $"\
- {fail "finish from outermost frame disallowed"}
- timeout {fail "(timeout) finish from outermost frame disallowed"}
-}
-
-# Verify that we can explicitly ask GDB to stop on all shared library
-# events, and that it does so.
-#
-if [istarget "hppa*-*-hpux*"] then {
- if ![runto_main] then { fail "break tests suppressed" }
-
- send_gdb "set stop-on-solib-events 1\n"
- gdb_expect {
- -re "$gdb_prompt $"\
- {pass "set stop-on-solib-events"}
- timeout {fail "(timeout) set stop-on-solib-events"}
- }
-
- send_gdb "run\n"
- gdb_expect {
- -re ".*Start it from the beginning.*y or n. $"\
- {send_gdb "y\n"
- gdb_expect {
- -re ".*Stopped due to shared library event.*$gdb_prompt $"\
- {pass "triggered stop-on-solib-events"}
- -re "$gdb_prompt $"\
- {fail "triggered stop-on-solib-events"}
- timeout {fail "(timeout) triggered stop-on-solib-events"}
- }
- }
- -re "$gdb_prompt $"\
- {fail "rerun for stop-on-solib-events"}
- timeout {fail "(timeout) rerun for stop-on-solib-events"}
- }
-
- send_gdb "set stop-on-solib-events 0\n"
- gdb_expect {
- -re "$gdb_prompt $"\
- {pass "reset stop-on-solib-events"}
- timeout {fail "(timeout) reset stop-on-solib-events"}
- }
-}
-
-# Hardware breakpoints are unsupported on HP-UX. Verify that GDB
-# gracefully responds to requests to create them.
-#
-if [istarget "hppa*-*-hpux*"] then {
- if ![runto_main] then { fail "break tests suppressed" }
-
- send_gdb "hbreak\n"
- gdb_expect {
- -re "No hardware breakpoint support in the target.*$gdb_prompt $"\
- {pass "hw breaks disallowed"}
- -re "$gdb_prompt $"\
- {fail "hw breaks disallowed"}
- timeout {fail "(timeout) hw breaks disallowed"}
- }
-
- send_gdb "thbreak\n"
- gdb_expect {
- -re "No hardware breakpoint support in the target.*$gdb_prompt $"\
- {pass "temporary hw breaks disallowed"}
- -re "$gdb_prompt $"\
- {fail "temporary hw breaks disallowed"}
- timeout {fail "(timeout) temporary hw breaks disallowed"}
- }
+gdb_test_multiple "finish" "finish from outermost frame disallowed" {
+ -re "\"finish\" not meaningful in the outermost frame.*$gdb_prompt $" {
+ pass "finish from outermost frame disallowed"
+ }
+ -re "Run till exit from.*$gdb_prompt $" {
+ pass "finish from outermost frame disallowed"
+ }
}
-#********
-
-
#
# Test "next" over recursive function call.
#
global decimal
global binfile
- if [target_info exists use_gdb_stub] {
- # Reload the program.
- delete_breakpoints
- gdb_load ${binfile};
- } else {
- # FIXME: should be using runto
- gdb_test "kill" "" "kill program" "Kill the program being debugged.*y or n. $" "y"
-
- delete_breakpoints
- }
+ gdb_test "kill" "" "kill program" "Kill the program being debugged.*y or n. $" "y"
+ delete_breakpoints
gdb_test "break factorial" "Breakpoint $decimal at .*" "break at factorial"
# Run until we call factorial with 6
- if [istarget "*-*-vxworks*"] then {
- send_gdb "run vxmain \"6\"\n"
- } else {
- gdb_run_cmd
- }
- gdb_expect {
- -re "Break.* factorial .value=6. .*$gdb_prompt $" {}
- -re ".*$gdb_prompt $" {
- fail "run to factorial(6)";
- gdb_suppress_tests;
- }
- timeout { fail "run to factorial(6) (timeout)" ; gdb_suppress_tests }
- }
+ gdb_run_cmd
+ gdb_test "" "Break.* factorial .value=6. .*" "run to factorial(6)"
# Continue until we call factorial recursively with 5.
if [target_info exists gdb,noresults] { gdb_suppress_tests }
gdb_continue_to_end "recursive next test"
- gdb_stop_suppressing_tests;
+ gdb_stop_suppressing_tests
}
test_next_with_recursion
#********
+proc test_different_dir {type test_different_dir xfail} {
+ with_test_prefix "$type" {
+ global srcdir subdir binfile srcfile timeout gdb_prompt
+ global bp_location6 decimal hex
+
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+ gdb_test_no_output "set debug-file-directory ${test_different_dir}" \
+ "set separate debug location"
+ gdb_load ${binfile}
+
+ #
+ # test break at function
+ #
+ if {$xfail} {
+ setup_xfail "*-*-*"
+ }
+ gdb_test "break main" \
+ "Breakpoint.*at.* file .*$srcfile, line.*" \
+ "breakpoint function, optimized file"
+
+ #
+ # test break at function
+ #
+ if {$xfail} {
+ setup_xfail "*-*-*"
+ }
+ gdb_test "break marker4" \
+ "Breakpoint.*at.* file .*$srcfile, line.*" \
+ "breakpoint small function, optimized file"
+
+ #
+ # run until the breakpoint at main is hit. For non-stubs-using targets.
+ #
+ gdb_run_cmd
+ if {$xfail} {
+ setup_xfail "*-*-*"
+ }
+ set test "run until function breakpoint, optimized file"
+ gdb_test_multiple "" $test {
+ -re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $" {
+ pass $test
+ }
+ -re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$gdb_prompt $" {
+ pass "$test (code motion)"
+ }
+ }
+
+ #
+ # run until the breakpoint at a small function
+ #
+
+ #
+ # Add a second pass pattern. The behavior differs here between stabs
+ # and dwarf for one-line functions. Stabs preserves two line symbols
+ # (one before the prologue and one after) with the same line number,
+ # but dwarf regards these as duplicates and discards one of them.
+ # Therefore the address after the prologue (where the breakpoint is)
+ # has no exactly matching line symbol, and GDB reports the breakpoint
+ # as if it were in the middle of a line rather than at the beginning.
+
+ set bp_location14 [gdb_get_line_number "set breakpoint 14 here"]
+ if {$xfail} {
+ setup_xfail "*-*-*"
+ }
+
+ gdb_test_multiple "continue" "run until breakpoint set at small function, optimized file" {
+ -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*$gdb_prompt $" {
+ pass "run until breakpoint set at small function, optimized file (line bp_location14)"
+ }
+ -re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*$gdb_prompt $" {
+ pass "run until breakpoint set at small function, optimized file (line bp_location14)"
+ }
+ }
+
+ # proc test_different_dir
+ }
+}
+
+
# now move the .debug file to a different location so that we can test
# the "set debug-file-directory" command.
-
-remote_exec build "mv ${objdir}/${subdir}/.debug/${testfile}.debug ${objdir}/${subdir}"
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_test "set debug-file-directory ${objdir}/${subdir}" ".*" "set separate debug location"
-gdb_load ${binfile}
-
-if [target_info exists gdb_stub] {
- gdb_step_for_stub;
+
+set different_dir [standard_output_file ${testfile}.dir]
+set debugfile "${different_dir}/[standard_output_file ${testfile}${EXEEXT}.debug]"
+remote_exec build "rm -rf $different_dir"
+remote_exec build "mkdir -p [file dirname $debugfile]"
+remote_exec build "mv -f [standard_output_file ${testfile}${EXEEXT}.debug] $debugfile"
+
+test_different_dir debuglink $different_dir 0
+
+
+# Test CRC mismatch is reported.
+
+if {[build_executable sepdebug.exp sepdebug2 sepdebug2.c debug] != -1
+ && ![gdb_gnu_strip_debug [standard_output_file sepdebug2]$EXEEXT]} {
+
+ remote_exec build "cp ${debugfile} [standard_output_file sepdebug2.debug]"
+
+ gdb_exit
+ gdb_start
+ gdb_reinitialize_dir $srcdir/$subdir
+
+ set escapedobjdirsubdir [string_to_regexp [standard_output_file {}]]
+
+ gdb_test "file [standard_output_file sepdebug2]" "warning: the debug information found in \"${escapedobjdirsubdir}/sepdebug2\\.debug\" does not match \"${escapedobjdirsubdir}/sepdebug2\" \\(CRC mismatch\\)\\..*\\(No debugging symbols found in .*\\).*" "CRC mismatch is reported"
}
-#
-# test break at function
-#
-gdb_test "break main" \
- "Breakpoint.*at.* file .*$srcfile, line.*" \
- "breakpoint function, optimized file"
-#
-# test break at function
-#
-gdb_test "break marker4" \
- "Breakpoint.*at.* file .*$srcfile, line.*" \
- "breakpoint small function, optimized file"
+# NT_GNU_BUILD_ID / .note.gnu.build-id test:
-#
-# run until the breakpoint at main is hit. For non-stubs-using targets.
-#
-if ![target_info exists use_gdb_stub] {
- if [istarget "*-*-vxworks*"] then {
- send_gdb "run vxmain \"2\"\n"
- set timeout 120
- verbose "Timeout is now $timeout seconds" 2
- } else {
- send_gdb "run\n"
- }
- gdb_expect {
- -re "The program .* has been started already.*y or n. $" {
- send_gdb "y\n"
- exp_continue
- }
- -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $"\
- { pass "run until function breakpoint, optimized file" }
- -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$gdb_prompt $"\
- { pass "run until function breakpoint, optimized file (code motion)" }
- -re ".*$gdb_prompt $" { fail "run until function breakpoint, optimized file" }
- timeout { fail "run until function breakpoint, optimized file (timeout)" }
- }
+set build_id_debug_filename [build_id_debug_filename_get $binfile$EXEEXT]
+if ![string compare $build_id_debug_filename ""] then {
+ unsupported "build-id is not supported by the compiler"
+
+ # Spare debug files may confuse testsuite runs in the future.
+ remote_exec build "rm -f $debugfile"
} else {
- if ![target_info exists gdb_stub] {
- gdb_test continue ".*Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.*\{.*" "stub continue, optimized file"
+ set build_id_debugself_filename [build_id_debug_filename_get $debugfile]
+ set test "build-id support by binutils"
+ set xfail 0
+ if ![string compare $build_id_debugself_filename ""] then {
+ unsupported $test
+ set xfail 1
+ } elseif {[string compare $build_id_debugself_filename $build_id_debug_filename] != 0} then {
+ fail $test
+ } else {
+ pass $test
}
-}
-#
-# run until the breakpoint at a small function
-#
+ file mkdir [file dirname [standard_output_file ${build_id_debug_filename}]]
+ remote_exec build "mv $debugfile [standard_output_file ${build_id_debug_filename}]"
-#
-# Add a second pass pattern. The behavior differs here between stabs
-# and dwarf for one-line functions. Stabs preserves two line symbols
-# (one before the prologue and one after) with the same line number,
-# but dwarf regards these as duplicates and discards one of them.
-# Therefore the address after the prologue (where the breakpoint is)
-# has no exactly matching line symbol, and GDB reports the breakpoint
-# as if it were in the middle of a line rather than at the beginning.
+ test_different_dir build-id [standard_output_file {}] $xfail
-set bp_location13 [gdb_get_line_number "set breakpoint 13 here"]
-set bp_location14 [gdb_get_line_number "set breakpoint 14 here"]
-send_gdb "continue\n"
-gdb_expect {
- -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
- pass "run until breakpoint set at small function, optimized file"
- }
- -re "Breakpoint $decimal, $hex in marker4 \\(d=177601976\\) at .*$srcfile:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*" {
- pass "run until breakpoint set at small function, optimized file"
- }
- -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location14\[\r\n\]+$bp_location14\[\t \]+void marker4.*" {
- # marker4() is defined at line 46 when compiled with -DPROTOTYPES
- pass "run until breakpoint set at small function, optimized file (line bp_location14)"
- }
- -re ".*$gdb_prompt " {
- fail "run until breakpoint set at small function, optimized file"
- }
- timeout {
- fail "run until breakpoint set at small function, optimized file (timeout)"
- }
-}
+ # Test also multiple directories can be specified. Without the build-id
+ # reference GDB would find the separate debug info just at the same
+ # location as the executable file.
+ test_different_dir multiple-dirs "/doesnotexist:[standard_output_file {}]" $xfail
-# Reset the default arguments for VxWorks
-if [istarget "*-*-vxworks*"] {
- set timeout 10
- verbose "Timeout is now $timeout seconds" 2
- send_gdb "set args main\n"
- gdb_expect -re ".*$gdb_prompt $" {}
+ # Spare debug files may confuse testsuite runs in the future.
+ remote_exec build "rm -f [standard_output_file ${build_id_debug_filename}]"
}