X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftestsuite%2Fgdb.base%2Fsepdebug.exp;h=c5e019be3f6c48251cbb7ab74203ca1c42b61571;hb=fa43b1d7ca8d9699a253b1f227e91c406a043a0b;hp=e5498eb26efd483e87a6d1b30efa52f4718b6c60;hpb=4935890f4d4df7c5c88e4be2945e5c7a9b282ab6;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/testsuite/gdb.base/sepdebug.exp b/gdb/testsuite/gdb.base/sepdebug.exp
index e5498eb26e..c5e019be3f 100644
--- a/gdb/testsuite/gdb.base/sepdebug.exp
+++ b/gdb/testsuite/gdb.base/sepdebug.exp
@@ -1,5 +1,4 @@
-#   Copyright 1988, 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999,
-#   2000, 2002, 2003, 2004, 2007 Free Software Foundation, Inc.
+#   Copyright 1988-2014 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
@@ -14,9 +13,6 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-# Please email any bugs, comments, and/or additions to this file to:
-# bug-gdb@prep.ai.mit.edu
-
 # 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.
@@ -29,19 +25,11 @@
 # ".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}] != "" } {
     untested sepdebug.exp
@@ -50,9 +38,9 @@ if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {deb
 
 # 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] {
     # check that you have a recent version of strip and objcopy installed
@@ -60,38 +48,36 @@ if [gdb_gnu_strip_debug $binfile] {
     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} $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
 #
@@ -162,24 +148,16 @@ gdb_test "break multi_line_while_conditional" \
     "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 factorial at .*$srcfile:$bp_location7.*
@@ -194,25 +172,14 @@ gdb_test "info break" \
 # 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.
 #
 gdb_run_cmd
-gdb_expect {
-    -re "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)"
-    }
-}
+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
@@ -261,44 +228,42 @@ delete_breakpoints
 # 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\]
@@ -314,80 +279,55 @@ gdb_test "info break" "Num Type.*Disp Enb Address.*What.*\[\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" }
 
+gdb_test "catch" "Catch requires an event name.*" \
+    "catch requires an event name"
 
 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"}
+gdb_test_multiple "catch fork" $name {
+    -re "Catchpoint \[0-9\]* .fork.*$gdb_prompt $" {
+	pass $name
+    }
+    -re "Catch of fork not yet implemented.*$gdb_prompt $" {
+	pass $name
+    }
 }
 
-
-set name "set catch vfork, never expected to trigger"
-send_gdb "catch vfork\n"
-
 # 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"}
+set name "set catch vfork, never expected to trigger"
+gdb_test_multiple "catch vfork" $name {
+    -re "Catch of vfork events not supported on HP-UX 10.20.*" {
+	pass $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"}
+    -re "Catchpoint \[0-9\]* .vfork.*$gdb_prompt $" {
+	pass $name
+    }
+    -re "Catch of vfork not yet implemented.*$gdb_prompt $" {
+	pass $name
     }
 }
 
 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_multiple "catch exec" $name {
+    -re "Catchpoint \[0-9\]* .exec.*$gdb_prompt $" {
+	pass $name
+    }
+    -re "Catch of exec not yet implemented.*$gdb_prompt $" {
+	pass $name
+    }
 }
 
 # 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.
@@ -400,89 +340,44 @@ gdb_test "until $bp_location1" "main .* at .*:$bp_location1.*" "until bp_locatio
 # 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
@@ -490,61 +385,34 @@ gdb_expect {
 # 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" \
+    "Junk after thread keyword.*" \
+    "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.
 #
@@ -557,57 +425,35 @@ gdb_test "clear marker3" {Deleted breakpoints [0-9]+ [0-9]+.*}
 
 # 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|$bp_location9).*" \
+    "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.
@@ -615,47 +461,41 @@ gdb_expect {
 # 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_multiple "bt" "backtrace while in called function" {
+    -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"
+    }
 }
 
 # 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|$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"
+    }
 }
 
 # 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
@@ -663,79 +503,47 @@ gdb_expect {
 # 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"}
+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"
+    }
 }
 
 # 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"}
-  }
+    if ![runto_main] then { fail "sepdebug tests suppressed" }
+
+    gdb_test_no_output "set stop-on-solib-events 1" \
+	"set stop-on-solib-events"
+
+    gdb_test "run" \
+	"Stopped due to shared library event.*" \
+	"triggered stop-on-solib-events" \
+	"Start it from the beginning.*y or n. $" \
+	"y"
+
+    gdb_test_no_output "set stop-on-solib-events 0" \
+      "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"}
-  }
+    if ![runto_main] then { fail "sepdebug tests suppressed" }
+
+    gdb_test "hbreak" \
+	"No hardware breakpoint support in the target.*" \
+	"hw breaks disallowed"
+
+    gdb_test "thbreak" \
+      "No hardware breakpoint support in the target.*" \
+      "temporary hw breaks disallowed"
 }
 
 #********
@@ -758,14 +566,7 @@ proc test_next_with_recursion {} {
     # Run until we call factorial with 6
 
     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_test "" "Break.* factorial .value=6. .*" "run to factorial(6)"
 
     # Continue until we call factorial recursively with 5.
 
@@ -823,7 +624,7 @@ proc test_next_with_recursion {} {
 
     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
@@ -832,129 +633,132 @@ test_next_with_recursion
 #********
 
 proc test_different_dir {type test_different_dir xfail} {
-    global srcdir subdir objdir binfile srcfile timeout gdb_prompt
-    global pf_prefix
-    global bp_location6 decimal hex
-
-    set pf_prefix "$type:"
-
-    gdb_exit
-    gdb_start
-    gdb_reinitialize_dir $srcdir/$subdir
-    gdb_test "set debug-file-directory ${test_different_dir}" ".*" "set separate debug location"
-    gdb_load ${binfile}
-
-    if [target_info exists gdb_stub] {
-	gdb_step_for_stub;
-    }
-
-    #
-    # 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 "*-*-*"
-    }
-    gdb_expect {
-	-re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.* \{.*$gdb_prompt $" {
-	    pass "run until function breakpoint, optimized file"
+    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 "*-*-*"
 	}
-	-re "Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$gdb_prompt $" {
-	    pass "run until function breakpoint, optimized file (code motion)"
+	gdb_test "break main" \
+	    "Breakpoint.*at.* file .*$srcfile, line.*" \
+	    "breakpoint function, optimized file"
+
+	#
+	# test break at function
+	#
+	if {$xfail} {
+	    setup_xfail "*-*-*"
 	}
-	-re "$gdb_prompt $" {
-	    fail "run until function breakpoint, optimized file"
+	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 "*-*-*"
 	}
-	timeout {
-	    fail "run until function breakpoint, optimized file (timeout)"
+	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_location13 [gdb_get_line_number "set breakpoint 13 here"]
-    set bp_location14 [gdb_get_line_number "set breakpoint 14 here"]
-    send_gdb "continue\n"
-    if {$xfail} {
-	setup_xfail "*-*-*"
-    }
-    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"
+	#
+	# 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_location13 [gdb_get_line_number "set breakpoint 13 here"]
+	set bp_location14 [gdb_get_line_number "set breakpoint 14 here"]
+	if {$xfail} {
+	    setup_xfail "*-*-*"
 	}
-	timeout {
-	    fail "run until breakpoint set at small function, optimized file (timeout)"
+
+	gdb_test_multiple "continue" "run until breakpoint set at small function, optimized file" {
+	    -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile:$bp_location13\[\r\n\]+$bp_location13\[\t \]+void marker4.*$gdb_prompt $" {
+		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.*$gdb_prompt $" {
+		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.*$gdb_prompt $" {
+		# marker4() is defined at line 46 when compiled with -DPROTOTYPES
+		pass "run until breakpoint set at small function, optimized file (line bp_location14)"
+	    }
 	}
-    }
 
 
-    # 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 $" {}
-    }
+	# Reset the default arguments for VxWorks
+	if [istarget "*-*-vxworks*"] {
+	    set timeout 10
+	    verbose "Timeout is now $timeout seconds" 2
+	    gdb_test_no_output "set args main"
+	}
 
-    unset pf_prefix
-# proc test_different_dir
+	# 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}"
-set debugfile "${objdir}/${subdir}/${testfile}.debug"
 
-test_different_dir debuglink "${objdir}/${subdir}" 0
+set different_dir [standard_output_file ${testfile}.dir]
+set debugfile "${different_dir}/[standard_output_file ${testfile}.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}.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]]} {
+
+    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\\).*" "CRC mismatch is reported"
+}
 
 
 # NT_GNU_BUILD_ID / .note.gnu.build-id test:
 
 set build_id_debug_filename [build_id_debug_filename_get $binfile]
-if {$build_id_debug_filename eq ""} {
+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.
@@ -963,20 +767,26 @@ if {$build_id_debug_filename eq ""} {
     set build_id_debugself_filename [build_id_debug_filename_get $debugfile]
     set test "build-id support by binutils"
     set xfail 0
-    if {$build_id_debugself_filename eq ""} {
+    if ![string compare $build_id_debugself_filename ""] then {
 	unsupported $test
 	set xfail 1
-    } elseif {$build_id_debugself_filename ne $build_id_debug_filename} {
+    } elseif {[string compare $build_id_debugself_filename $build_id_debug_filename] != 0} then {
 	fail $test
     } else {
 	pass $test
     }
 
-    file mkdir [file dirname ${objdir}/${subdir}/${build_id_debug_filename}]
-    remote_exec build "mv $debugfile ${objdir}/${subdir}/${build_id_debug_filename}"
+    file mkdir [file dirname [standard_output_file ${build_id_debug_filename}]]
+    remote_exec build "mv $debugfile [standard_output_file ${build_id_debug_filename}]"
+
+    test_different_dir build-id [standard_output_file {}] $xfail
+
+    # 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 build-id "${objdir}/${subdir}" $xfail
+    test_different_dir multiple-dirs "/doesnotexist:[standard_output_file {}]" $xfail
 
     # Spare debug files may confuse testsuite runs in the future.
-    remote_exec build "rm -f ${objdir}/${subdir}/${build_id_debug_filename}"
+    remote_exec build "rm -f [standard_output_file ${build_id_debug_filename}]"
 }