X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Ftestsuite%2Fgdb.base%2Fbreak.exp;h=05ddd70485b65cd3465a25bf8274b626805a1bac;hb=8ec659a07ea7e0c4bec363fa5f92ca59a7f5a25d;hp=b8f1d7f8fcb91fb216f320386ed1de60503bc0ef;hpb=1996fae84682e8ddd146215dd2959ad1ec924c09;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/testsuite/gdb.base/break.exp b/gdb/testsuite/gdb.base/break.exp
index b8f1d7f8fc..05ddd70485 100644
--- a/gdb/testsuite/gdb.base/break.exp
+++ b/gdb/testsuite/gdb.base/break.exp
@@ -1,4 +1,5 @@
-#   Copyright (C) 1988, 1990, 1991, 1992, 1994, 1997, 1998
+#   Copyright 1988, 1990, 1991, 1992, 1994, 1995, 1996, 1997, 1998, 1999,
+#   2000, 2002, 2003
 #   Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
@@ -33,10 +34,26 @@ set bug_id 0
 
 set testfile "break"
 set srcfile ${testfile}.c
+set srcfile1 ${testfile}1.c
 set binfile ${objdir}/${subdir}/${testfile}
 
-if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-w}] != "" } {
-    gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}0.o" object {debug nowarnings}] != "" } {
+     untested break.exp
+     return -1
+}
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}1.o" object {debug nowarnings}] != "" } {
+     untested break.exp
+     return -1
+}
+
+if  { [gdb_compile "${binfile}0.o ${binfile}1.o" "${binfile}" executable {debug nowarnings}] != "" } {
+     untested break.exp
+     return -1
+}
+
+if [get_compiler_info ${binfile}] {
+    return -1
 }
 
 gdb_exit
@@ -53,7 +70,7 @@ if [target_info exists gdb_stub] {
 
 # 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
+# Note that lib/gdb.exp provides a "delete_breakpoints" proc
 # for general use elsewhere.
 
 send_gdb "delete breakpoints\n"
@@ -78,6 +95,13 @@ gdb_test "break main" \
     "Breakpoint.*at.* file .*$srcfile, line.*" \
     "breakpoint function"
 
+#
+# test break at quoted function
+#
+gdb_test "break \"marker2\"" \
+    "Breakpoint.*at.* file .*$srcfile1, line.*" \
+    "breakpoint quoted function"
+
 #
 # test break at function in file
 #
@@ -85,47 +109,100 @@ gdb_test "break $srcfile:factorial" \
     "Breakpoint.*at.* file .*$srcfile, line.*" \
     "breakpoint function in file"
 
+set bp_location1 [gdb_get_line_number "set breakpoint 1 here"]
+
 #
 # test break at line number
 #
-gdb_test "break 64" \
-    "Breakpoint.*at.* file .*$srcfile, line 64\\." \
+# Note that the default source file is the last one whose source text
+# was printed.  For native debugging, before we've executed the
+# program, this is the file containing main, but for remote debugging,
+# it's wherever the processor was stopped when we connected to the
+# board.  So, to be sure, we do a list command.
+#
+gdb_test "list main" \
+    ".*main \\(argc, argv, envp\\).*" \
+    "use `list' to establish default source file"
+gdb_test "break $bp_location1" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location1\\." \
     "breakpoint line number"
 
 #
 # test duplicate breakpoint
 #
-gdb_test "break 64" \
-    "Note: breakpoint \[0-9\]+ also set at pc.*Breakpoint \[0-9\]+ at.* file .*$srcfile, line 64\\." \
+gdb_test "break $bp_location1" \
+    "Note: breakpoint \[0-9\]+ also set at pc.*Breakpoint \[0-9\]+ at.* file .*$srcfile, line $bp_location1\\." \
     "breakpoint duplicate"
 
+set bp_location2 [gdb_get_line_number "set breakpoint 2 here"]
+
 #
 # test break at line number in file
 #
-gdb_test "break $srcfile:70" \
-    "Breakpoint.*at.* file .*$srcfile, line 70\\." \
+gdb_test "break $srcfile:$bp_location2" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location2\\." \
     "breakpoint line number in file"
 
+set bp_location3 [gdb_get_line_number "set breakpoint 3 here"]
+set bp_location4 [gdb_get_line_number "set breakpoint 4 here"]
+
+#
+# Test putting a break at the start of a multi-line if conditional.
+# Verify the breakpoint was put at the start of the conditional.
+#
+gdb_test "break multi_line_if_conditional" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location3\\." \
+    "breakpoint at start of multi line if conditional"
+
+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 57
+    set main_line $bp_location5
 } else {
-    set main_line 60
+    set main_line $bp_location6
 }
 
+if {$hp_aCC_compiler} {
+    set proto "\\(int\\)"
+} else {
+    set proto ""
+}
+
+set bp_location7 [gdb_get_line_number "set breakpoint 7 here"]
+set bp_location8 [gdb_get_line_number "set breakpoint 8 here" $srcfile1]
+set bp_location9 [gdb_get_line_number "set breakpoint 9 here" $srcfile1]
+
+verbose -log    "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 .*$srcfile1:($bp_location8|$bp_location9).*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in factorial$proto 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.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:$bp_location2.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in multi_line_if_conditional at .*$srcfile:$bp_location3.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in multi_line_while_conditional at .*$srcfile:$bp_location4" \
+2
+
 gdb_test "info break" \
     "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 factorial at .*$srcfile:76.*
-\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:64.*
-\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:64.*
-\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:70" \
+\[0-9\]+\[\t \]+breakpoint     keep y.* in marker2 at .*$srcfile1:($bp_location8|$bp_location9).*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in factorial$proto 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.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in main at .*$srcfile:$bp_location2.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in multi_line_if_conditional at .*$srcfile:$bp_location3.*
+\[0-9\]+\[\t \]+breakpoint     keep y.* in multi_line_while_conditional at .*$srcfile:$bp_location4" \
     "breakpoint info"
 
-
 # FIXME: The rest of this test doesn't work with anything that can't
 # handle arguments.
 # Huh? There doesn't *appear* to be anything that passes arguments
@@ -150,37 +227,66 @@ if ![target_info exists use_gdb_stub] {
 	send_gdb "y\n"
 	exp_continue
     }
-    -re "Starting program.*Breakpoint \[0-9\]+,.*main .*argc.*argv.* at .*$srcfile:60.*60\[\t \]+if .argc.* \{.*$gdb_prompt $"\
+    -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:60.*60\[\t \]+if .argc.*\{" "stub continue"
+	gdb_test continue ".*Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location6.*$bp_location6\[\t \]+if .argc.*\{.*" "stub continue"
     }
 }
 
 #
 # run until the breakpoint at a line number
 #
-gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:64.*64\[\t \]+printf.*factorial.*" \
+gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location1.*$bp_location1\[\t \]+printf.*factorial.*" \
 			"run until breakpoint set at a line number"
 
 #
 # Run until the breakpoint set in a function in a file
 #
 for {set i 6} {$i >= 1} {incr i -1} {
-	gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, factorial \\(value=$i\\) at .*$srcfile:76.*76\[\t \]+if .value > 1. \{" \
+	gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, factorial \\(value=$i\\) at .*$srcfile:$bp_location7.*$bp_location7\[\t \]+.*if .value > 1. \{.*" \
 			"run until file:function($i) breakpoint"
 }
 
+#
+# 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 .*$srcfile1:($bp_location8|$bp_location9).*" \
+		"run until quoted breakpoint"
 #
 # run until the file:function breakpoint at a line number in a file
 #
-gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:70.*70\[\t \]+return 0;" \
+gdb_test continue "Continuing\\..*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location2.*$bp_location2\[\t \]+argc = \\(argc == 12345\\);.*" \
 		"run until file:linenum breakpoint"
 
+# Test break at offset +1
+set bp_location10 [gdb_get_line_number "set breakpoint 10 here"]
+
+gdb_test "break +1" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location10\\." \
+    "breakpoint offset +1"
+
+# Check to see if breakpoint is hit when stepped onto
+
+gdb_test "step" \
+    ".*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location10.*$bp_location10\[\t \]+return argc;.*breakpoint 10 here.*" \
+    "step onto breakpoint"
+
+# Check to see if breakpoint can be set on ending brace of function
+set bp_location10a [gdb_get_line_number "set breakpoint 10a here"]
+
+gdb_test "break $bp_location10a" \
+    "Breakpoint.*at.* file .*$srcfile, line $bp_location10a\\." \
+    "setting breakpoint at }"
+
+gdb_test "continue" \
+    ".*Breakpoint \[0-9\]+, main \\(argc=.*, argv=.*, envp=.*\\) at .*$srcfile:$bp_location10a.*$bp_location10a\[\t \]+}.*breakpoint 10a here.*" \
+    "continue to breakpoint at }"
+
 #
 # delete all breakpoints so we can start over, course this can be a test too
 #
@@ -202,31 +308,39 @@ gdb_test "tbreak $srcfile:factorial" "Breakpoint.*at.* file .*$srcfile, line.*"
 #
 # test break at line number
 #
-send_gdb "tbreak 64\n"
+send_gdb "tbreak $bp_location1\n"
 gdb_expect {
-    -re "Breakpoint.*at.* file .*$srcfile, line 64.*$gdb_prompt $" { pass "Temporary breakpoint line number #1" }
+    -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 60" "Breakpoint.*at.* file .*$srcfile, line 60.*" "Temporary breakpoint line number #2"
+gdb_test "tbreak $bp_location6" "Breakpoint.*at.* file .*$srcfile, line $bp_location6.*" "Temporary breakpoint line number #2"
 
 #
 # test break at line number in file
 #
-send_gdb "tbreak $srcfile:70\n"
+send_gdb "tbreak $srcfile:$bp_location2\n"
 gdb_expect {
-    -re "Breakpoint.*at.* file .*$srcfile, line 70.*$gdb_prompt $" { pass "Temporary breakpoint line number in file #1" }
+    -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:66" "Breakpoint.*at.* file .*$srcfile, line 66.*" "Temporary breakpoint line number in file #2"
+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"
 
 #
 # check to see what breakpoints are set (temporary this time)
 #
-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:76.*\[\r\n\]\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:64.*\[\r\n\]\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:70.*" "Temporary breakpoint info"
+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$proto at .*$srcfile:$bp_location7.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location1.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location6.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location2.*\[\r\n\]
+\[0-9\]+\[\t \]+breakpoint     del.*y.*in main at .*$srcfile:$bp_location11.*" \
+    "Temporary breakpoint info"
 
 
 #***********
@@ -298,29 +412,6 @@ gdb_expect {
   timeout {fail "(timeout) $name"}
 }
 
-# Verify that "until <location>" works.  (This is really just syntactic
-# sugar for "tbreak <location>; continue".)
-#
-send_gdb "until 64\n"
-gdb_expect {
-  -re "main .* at .*:64.*$gdb_prompt $"\
-          {pass "until 64"}
-  -re "$gdb_prompt $"\
-          {fail "until 64"}
-  timeout {fail "(timeout) until 64"}
-}
-
-# Verify that a malformed "until" is gracefully caught.
-#
-send_gdb "until 65 then stop\n"
-gdb_expect {
-  -re "Junk at end of arguments..*$gdb_prompt $"\
-          {pass "malformed until"}
-  -re "$gdb_prompt $"\
-          {fail "malformed until"}
-  timeout {fail "(timeout) malformed until"}
-}
-
 # Verify that GDB responds gracefully when asked to set a breakpoint
 # on a nonexistent source line.
 #
@@ -333,6 +424,12 @@ gdb_expect {
   timeout {fail "(timeout) break on non-existent source line"}
 }
 
+# Run to the desired default location. If not positioned here, the
+# tests below don't work.
+#
+gdb_test "until $bp_location1" "main .* at .*:$bp_location1.*" "until bp_location1"
+
+
 # Verify that GDB allows one to just say "break", which is treated
 # as the "default" breakpoint.  Note that GDB gets cute when printing
 # the informational message about other breakpoints at the same
@@ -379,13 +476,13 @@ gdb_expect {
 #
 if ![runto_main] then { fail "break tests suppressed" }
 
-send_gdb "break 64\n"
+send_gdb "break $bp_location1\n"
 gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 64.*$gdb_prompt $"\
-          {pass "set to-be-silent break 64"}
+  -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 64"}
-  timeout {fail "(timeout) set to-be-silent break 64"}
+          {fail "set to-be-silent break bp_location1"}
+  timeout {fail "(timeout) set to-be-silent break bp_location1"}
 }
 
 send_gdb "commands $expect_out(1,string)\n"
@@ -393,33 +490,33 @@ send_gdb "silent\n"
 send_gdb "end\n"
 gdb_expect {
   -re ".*$gdb_prompt $"\
-          {pass "set silent break 64"}
-  timeout {fail "(timeout) set silent break 64"}
+          {pass "set silent break bp_location1"}
+  timeout {fail "(timeout) set silent break bp_location1"}
 }
 
 send_gdb "info break $expect_out(1,string)\n"
 gdb_expect {
-  -re "\[0-9\]*\[ \t\]*breakpoint.*:64\r\n\[ \t\]*silent.*$gdb_prompt $"\
-          {pass "info silent break 64"}
+  -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 64"}
-  timeout {fail "(timeout) info silent break 64"}
+          {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 64"}
+          {pass "hit silent break bp_location1"}
   -re "$gdb_prompt $"\
-          {fail "hit silent break 64"}
-  timeout {fail "(timeout) hit silent break 64"}
+          {fail "hit silent break bp_location1"}
+  timeout {fail "(timeout) hit silent break bp_location1"}
 }
 send_gdb "bt\n"
 gdb_expect {
-  -re "#0  main .* at .*:64.*$gdb_prompt $"\
-          {pass "stopped for silent break 64"}
+  -re "#0  main .* at .*:$bp_location1.*$gdb_prompt $"\
+          {pass "stopped for silent break bp_location1"}
   -re "$gdb_prompt $"\
-          {fail "stopped for silent break 64"}
-  timeout {fail "(timeout) stopped for silent break 64"}
+          {fail "stopped for silent break bp_location1"}
+  timeout {fail "(timeout) stopped for silent break bp_location1"}
 }
 
 # Verify that GDB can at least parse a breakpoint with the
@@ -427,7 +524,8 @@ gdb_expect {
 # thread-specific breakpoint really triggers appropriately.
 # The gdb.threads subdirectory contains tests for that.)
 #
-send_gdb "break 65 thread 999\n"
+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"}
@@ -435,7 +533,7 @@ gdb_expect {
           {fail "thread-specific breakpoint on non-existent thread disallowed"}
   timeout {fail "(timeout) thread-specific breakpoint on non-existent thread disallowed"}
 }
-send_gdb "break 65 thread foo\n"
+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"}
@@ -447,7 +545,7 @@ gdb_expect {
 # Verify that GDB responds gracefully to a breakpoint command with
 # trailing garbage.
 #
-send_gdb "break 65 foo\n"
+send_gdb "break $bp_location12 foo\n"
 gdb_expect {
   -re "Junk at end of arguments..*$gdb_prompt $"\
           {pass "breakpoint with trailing garbage disallowed"}
@@ -466,9 +564,9 @@ gdb_expect {
           {pass "step over breakpoint"}
   timeout {fail "(timeout) step over breakpoint"}
 }
-send_gdb "clear 66\n"
+send_gdb "clear 81\n"
 gdb_expect {
-  -re "No breakpoint at 66..*$gdb_prompt $"\
+  -re "No breakpoint at 81..*$gdb_prompt $"\
           {pass "clear line has no breakpoint disallowed"}
   -re "$gdb_prompt $"\
           {fail "clear line has no breakpoint disallowed"}
@@ -483,17 +581,26 @@ gdb_expect {
   timeout {fail "(timeout) clear current line has no breakpoint disallowed"}
 }
 
+# Verify that we can set and clear multiple breakpoints.
+#
+# We don't test that it deletes the correct breakpoints.  We do at
+# least test that it deletes more than one breakpoint.
+#
+gdb_test "break marker3" "Breakpoint.*at.*" "break marker3 #1"
+gdb_test "break marker3" "Breakpoint.*at.*" "break marker3 #2"
+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=66\n"
+send_gdb "set \$foo=$bp_location11\n"
 gdb_expect {
   -re "$gdb_prompt $"\
-          {pass "set convenience variable \$foo to 66"}
-  timeout {fail "(timeout) set convenience variable \$foo to 66"}
+          {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 66.*$gdb_prompt $"\
+  -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"}
@@ -503,11 +610,11 @@ gdb_expect {
 # 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=66.5\n"
+send_gdb "set \$foo=81.5\n"
 gdb_expect {
   -re "$gdb_prompt $"\
-          {pass "set convenience variable \$foo to 66.5"}
-  timeout {fail "(timeout) set convenience variable \$foo to 66.5"}
+          {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 {
@@ -522,7 +629,7 @@ gdb_expect {
 #
 send_gdb "break marker2\n"
 gdb_expect {
-  -re "Breakpoint (\[0-9\]*) at .*, line 42.*$gdb_prompt $"\
+    -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"}
@@ -530,7 +637,7 @@ gdb_expect {
 }
 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 $"\
+  -re "The program being debugged stopped while in a function called from GDB.\r\nWhen the function .marker2$proto. 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"}
@@ -540,23 +647,35 @@ gdb_expect {
 # As long as we're stopped (breakpointed) in a called function,
 # verify that we can successfully backtrace & such from here.
 #
-if [istarget "hppa*-*-hpux*"] then {
-  send_gdb "bt\n"
-  gdb_expect {
-    -re "#0\[ \t\]*marker2.*:42\r\n#1.*_sr4export.*$gdb_prompt $"\
+# 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"}
-  }
-  send_gdb "finish\n"
-  gdb_expect {
-    -re "Run till exit from .*marker2.* at .*42\r\n.* in _sr4export.*$gdb_prompt $"\
+}
+
+# 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"}
-  }
 }
 
 # Verify that GDB responds gracefully to a "finish" command with
@@ -574,12 +693,18 @@ gdb_expect {
 }
 
 # Verify that GDB responds gracefully to a request to "finish" from
-# the outermost frame.
+# the outermost frame.  On a stub that never exits, this will just
+# run to the stubs routine, so we don't get this error...  Thus the 
+# 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"}
@@ -651,15 +776,6 @@ if [istarget "hppa*-*-hpux*"] then {
 #********
 
 
-proc test_clear_command {} {
-    gdb_test "break main" "Breakpoint.*at.*" "break main #1"
-    gdb_test "break main" "Breakpoint.*at.*" "break main #2"
-
-    # We don't test that it deletes the correct breakpoints.  We do at
-    # least test that it deletes more than one breakpoint.
-    gdb_test "clear main" {Deleted breakpoints [0-9]+ [0-9]+.*}
-}
-
 #
 # Test "next" over recursive function call.
 #
@@ -727,9 +843,19 @@ proc test_next_with_recursion {} {
 
     if [istarget "mips*tx39-*"] {
 	set timeout 60
-    } else {
-	set timeout 20
     }
+    # We used to set timeout here for all other targets as well.  This
+    # is almost certainly wrong.  The proper timeout depends on the
+    # target system in use, and how we communicate with it, so there
+    # is no single value appropriate for all targets.  The timeout
+    # should be established by the Dejagnu config file(s) for the
+    # board, and respected by the test suite.
+    #
+    # For example, if I'm running GDB over an SSH tunnel talking to a
+    # portmaster in California talking to an ancient 68k board running
+    # a crummy ROM monitor (a situation I can only wish were
+    # hypothetical), then I need a large timeout.  But that's not the
+    # kind of knowledge that belongs in this file.
 
     gdb_test next "\[0-9\]*\[\t \]+return \\(value\\);.*" \
 	    "next over recursive call"
@@ -743,23 +869,127 @@ proc test_next_with_recursion {} {
     if { $result != 0 } { gdb_suppress_tests }
 
     if [target_info exists gdb,noresults] { gdb_suppress_tests }
-    if [target_info exists use_gdb_stub] {
-	gdb_breakpoint "exit"
-	gdb_test "continue" "Continuing..*Breakpoint .*exit \[(\].*=0\[)\].*" "continue until exit in recursive next test"
-    } else {
-    # Continue until we exit.  Should not stop again.
-    # Don't bother to check the output of the program, that may be
-    # extremely tough for some remote systems.
-	gdb_test "continue"\
-		"Continuing.\[\r\n0-9\]+Program exited normally\\..*"\
-		"continue until exit in recursive next test"
-    }
-    gdb_stop_suppressing_tests;
+  gdb_continue_to_end "recursive next test"
+   gdb_stop_suppressing_tests;
 }
 
-test_clear_command
 test_next_with_recursion
 
+
+#********
+
+# build a new file with optimization enabled so that we can try breakpoints
+# on targets with optimized prologues
+
+set binfileo2 ${objdir}/${subdir}/${testfile}o2
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}O0.o" object {debug nowarnings optimize=-O2}] != "" } {
+     untested break.exp
+     return -1
+}
+
+if  { [gdb_compile "${srcdir}/${subdir}/${srcfile1}" "${binfile}O1.o" object {debug nowarnings optimize=-O2}] != "" } {
+     untested break.exp
+     return -1
+}
+
+if  { [gdb_compile "${binfile}O0.o ${binfile}O1.o" "${binfileo2}" executable {debug nowarnings}] != "" } {
+     untested break.exp
+     return -1
+}
+
+if [get_compiler_info ${binfileo2}] {
+    return -1
+}
+
+gdb_exit
+gdb_start
+gdb_reinitialize_dir $srcdir/$subdir
+gdb_load ${binfileo2}
+
+if [target_info exists gdb_stub] {
+    gdb_step_for_stub;
+}
+
+#
+# test break at function
+#
+gdb_test "break main" \
+    "Breakpoint.*at.* file .*, line.*" \
+    "breakpoint function, optimized file"
+
+#
+# test break at function
+#
+gdb_test "break marker4" \
+    "Breakpoint.*at.* file .*$srcfile1, line.*" \
+    "breakpoint small function, optimized file"
+
+#
+# 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)" }
+  }
+} 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"
+    }
+}
+
+#
+# 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" $srcfile1]
+set bp_location14 [gdb_get_line_number "set breakpoint 14 here" $srcfile1]
+send_gdb "continue\n"
+gdb_expect {
+    -re "Breakpoint $decimal, marker4 \\(d=177601976\\) at .*$srcfile1:$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 .*$srcfile1:$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 .*$srcfile1:$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)"
+    }
+}
+
+
 # Reset the default arguments for VxWorks
 if [istarget "*-*-vxworks*"] {
     set timeout 10