Merge GDB 7.5.1

gdb/testsuite/gdb.base/watchpoint.exp

 # Copyright 1992, 1994-2000, 2007-2012 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # This file was written by Fred Fish. (fnf@cygnus.com)
 
-if $tracelevel then {
-    strace $tracelevel
-}
-
 
 set testfile "watchpoint"
 set srcfile ${testfile}.c
 set binfile ${objdir}/${subdir}/${testfile}
 
-set wp_set 1
-
-if [get_compiler_info ${binfile}] {
+if [get_compiler_info] {
     return -1
 }
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
      untested watchpoint.exp
      return -1
 }
 
+# True if we're forcing no hardware watchpoints.
+set no_hw 0
+
 # Prepare for watchpoint tests by setting up two breakpoints and one
 # watchpoint.
 #
 # We use breakpoints at marker functions to get past all the startup code,
 # so we can get to the watchpoints in a reasonable amount of time from a
 # known starting point.
 #
 # For simplicity, so we always know how to reference specific breakpoints or
 # watchpoints by number, we expect a particular ordering and numbering of
 # each in the combined breakpoint/watchpoint table, as follows:
 #
 #       Number          What            Where
 #       1               Breakpoint      marker1()
 #       2               Breakpoint      marker2()
 #       3               Watchpoint      ival3
 
 proc initialize {} {
     global gdb_prompt
     global hex
     global decimal
     global srcfile
-    global wp_set
-
-    # Disable hardware watchpoints if necessary.
-    if [target_info exists gdb,no_hardware_watchpoints] {
-        gdb_test_no_output "set can-use-hw-watchpoints 0" ""
-    }
 
     if [gdb_test "break marker1" "Breakpoint 1 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker1" ] { 
       return 0; 
     }
 
 
     if [gdb_test "break marker2" "Breakpoint 2 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker2" ] { 
       return 0; 
     }
 
 
     if [gdb_test "info break" "1\[ \]*breakpoint.*marker1.*\r\n2\[ \]*breakpoint.*marker2.*" "info break in watchpoint.exp" ] { 
       return 0; 
     }
 
-
-    # ??rehrauer: To fix DTS #CHFts23014, in which setting a watchpoint
-    # before running can cause the inferior to croak on HP-UX 11.0 for
-    # reasons yet unknown, we've disabled the ability to set watches
-    # without a running inferior.  Verify the restriction. 
-    #
-    send_gdb "watch ival3\n"
-    gdb_expect {
-        -re ".*\[Ww\]atchpoint 3: ival3.*$gdb_prompt $" {
-            pass "set watchpoint on ival3"
-        }
-        -re "warning: can't do that without a running program; try \"break main\", \"run\" first.*$gdb_prompt $" {
-            pass "set watchpoint on ival3"
-            set wp_set 0
-            return 1
-        }
-        timeout {
-            fail "(timeout) set watchpoint on ival3"
-            return 0
-        }
-    }
+    gdb_test "watch ival3" ".*\[Ww\]atchpoint 3: ival3.*" "set watchpoint on ival3"
 
     if [gdb_test "info watch" "3\[ \]*.*watchpoint.*ival3" "watchpoint found in watchpoint/breakpoint table" ] { 
       return 0; 
     }
 
 
     # After installing the watchpoint, we disable it until we are ready
     # to use it.  This allows the test program to run at full speed until
     # we get to the first marker function.
 
     if [gdb_test "disable 3" "disable 3\[\r\n\]+" "disable watchpoint" ] { 
       return 0; 
     }
 
 
     return 1
 }
 
 #
 # Test simple watchpoint.
 #
 
 proc test_simple_watchpoint {} {
     global gdb_prompt
     global hex
     global decimal
-    global wp_set
 
     # Ensure that the watchpoint is disabled when we startup.
 
-    if { $wp_set } {
-        if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_simple_watchpoint" ] { 
-            return 0; 
-        }
+    if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_simple_watchpoint" ] { 
+      return 0; 
     }
 
-
     # Run until we get to the first marker function.
 
     gdb_run_cmd
     set timeout 600
-    gdb_expect {
+    set test "run to marker1 in test_simple_watchpoint"
+    set retcode [gdb_test_multiple "" $test {
         -re "Breakpoint 1, marker1 .*$gdb_prompt $" {
-            pass "run to marker1 in test_simple_watchpoint"
+            pass $test
         }
-        -re ".*$gdb_prompt $" {
-            fail "run to marker1 in test_simple_watchpoint"
-            return
-        }
-        timeout {
-            fail "run to marker1 in test_simple_watchpoint (timeout)"
-            return
-        }
-    }
+    }]
 
-    if { !$wp_set } {
-        # ??rehrauer: To fix DTS #CHFts23014, in which setting a watchpoint
-        # before running can cause the inferior to croak on HP-UX 11.0
-        # for reasons yet unknown, we've disabled the ability to set 
-        # watches without a running inferior.  The following testpoints used
-        # to be in [initialize].
-        #
-        gdb_test "watch ival3" \
-            "\[Ww\]atchpoint 3: ival3" \
-            "set watchpoint on ival3"
-
-        set wp_set 1
-
-        gdb_test "info watch" \
-            "3\[ \]*.*watchpoint.*ival3" \
-            "watchpoint found in watchpoint/breakpoint table"
-
-        # After installing the watchpoint, we disable it until we are ready
-        # to use it.  This allows the test program to run at full speed until
-        # we get to the first marker function.
-
-        gdb_test "disable 3" "disable 3" "disable watchpoint"
+    if { $retcode != 0 } {
+        return
     }
 
     # After reaching the marker function, enable the watchpoint.
 
     if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "enable watchpoint" ] { 
       return ; 
     }
 
 
     gdb_test "break func1" "Breakpoint.*at.*"
     gdb_test_no_output "set \$func1_breakpoint_number = \$bpnum"
 
     gdb_test "continue" "Continuing.*Breakpoint \[0-9\]*, func1.*" \
         "continue to breakpoint at func1"
 
     # Continue until the first change, from -1 to 0
 
-    send_gdb "cont\n"
-    gdb_expect {
+    set test "watchpoint hit, first time"
+    gdb_test_multiple "cont" $test {
         -re "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 = count; ival4 = count;.*$gdb_prompt $" {
-            pass "watchpoint hit, first time"
+            pass $test
         }
         -re "Continuing.*Breakpoint.*func1.*$gdb_prompt $" {
             setup_xfail "m68*-*-*" 2597
             fail "thought it hit breakpoint at func1 twice"
             gdb_test_no_output "delete \$func1_breakpoint_number"
             gdb_test "continue" "\
 Continuing.*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 = count;" \
-                "watchpoint hit, first time"
+                $test
         }
-        -re ".*$gdb_prompt $" { fail "watchpoint hit, first time" ; return }
-        timeout { fail "watchpoint hit, first time (timeout)" ; return }
-        eof { fail "watchpoint hit, first time (eof)" ; return }
     }
 
     # Check that the hit count is reported correctly
     gdb_test "info break" ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+ival3\r\n\[ \t]+breakpoint already hit 1 time.*" "Watchpoint hit count is 1"
 
     gdb_test_no_output "delete \$func1_breakpoint_number"
 
     # Continue until the next change, from 0 to 1.
     gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 0.*New value = 1.*ival3 = count; ival4 = count;.*" "watchpoint hit, second time"
 
@@ skipping 42 matching lines @@
 
 # Test disabling watchpoints.
 
 proc test_disabling_watchpoints {} {
     global gdb_prompt
     global binfile
     global srcfile
     global decimal
     global hex
 
-    # "info watch" is the same as "info break"
-    gdb_test "info watch" "\[0-9]+\[ \]*.*watchpoint.*ival3\r\n\.*\[0-9\]+ times.*" "watchpoints found in watchpoint/breakpoint table"
+    gdb_test "info watch" "\[0-9]+\[ \]*.*watchpoint.*ival3.*" "watchpoints found in watchpoint/breakpoint table"
 
     # Ensure that the watchpoint is disabled when we startup.
 
     if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_disabling_watchpoints" ] { 
       return 0; 
     }
 
 
     # Run until we get to the first marker function.
 
     gdb_run_cmd
     set timeout 600
-    gdb_expect {
+    set test "run to marker1 in test_disabling_watchpoints"
+    set retcode [gdb_test_multiple "" $test {
         -re "Breakpoint 1, marker1 .*$gdb_prompt $" {
-            pass "run to marker1 in test_disabling_watchpoints"
+            pass $test
         }
-        -re ".*$gdb_prompt $" {
-            fail "run to marker1 in test_disabling_watchpoints"
-            return
-        }
-        timeout {
-            fail "run to marker1 in test_disabling_watchpoints (timeout)"
-            return
-        }
+    }]
+
+    if { $retcode != 0 } {
+        return
     }
 
     # After reaching the marker function, enable the watchpoint.
 
     if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "watchpoint enabled" ] { 
       return ; 
     }
 
 
     # Continue until the first change, from -1 to 0
@@ skipping 75 matching lines @@
         # "until", because compilers don't always arrange the code
         # exactly the same way, and we might get slightly different
         # sequences of statements.  But the following should be true
         # (if not it is a compiler or a debugger bug): The user who
         # does "until" at every statement of a loop should end up
         # stepping through the loop once, and the debugger should not
         # stop for any of the remaining iterations.
 
         gdb_test "until" "ival1 = count.*" "until to ival1 assignment"
         gdb_test "until" "ival3 = count.*" "until to ival3 assignment"
-        send_gdb "until\n"
-        gdb_expect {
+        set test "until out of loop"
+        gdb_test_multiple "until" $test {
             -re "(for \\(count = 0|\}).*$gdb_prompt $" {
-                gdb_test "until" "ival1 = count; /. Outside loop ./" \
-                    "until out of loop"
+                gdb_test "until" "ival1 = count; /. Outside loop ./" $test
             }
             -re "ival1 = count; /. Outside loop ./.*$gdb_prompt $" {
-                pass "until out of loop"
+                pass $test
             }
-            -re ".*$gdb_prompt $" {
-                fail "until out of loop"
-            }
-            default { fail "until out of loop (timeout)" ; return }
         }
 
         gdb_test "step" "ival2 = count.*" "step to ival2 assignment"
     }
 }
 
 # Test stepping and other mundane operations with watchpoints enabled
 proc test_watchpoint_triggered_in_syscall {} {
     global gdb_prompt
 
     # These tests won't work without printf support.
     if [gdb_skip_stdio_test "watchpoints triggered in syscall"] {
         return;
     }
     # Run until we get to the first marker function.
     set x 0
     set y 0
     set testname "Watch buffer passed to read syscall"
     if [runto marker2] then {
         gdb_test "watch buf\[0\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[0\\\]"
         gdb_test "watch buf\[1\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[1\\\]"
         gdb_test "watch buf\[2\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[2\\\]"
         gdb_test "watch buf\[3\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[3\\\]"
         gdb_test "watch buf\[4\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[4\\\]"
         gdb_test "break marker4" ".*Breakpoint.*"
 
         gdb_test_no_output "set doread = 1"
 
-        # If we send_gdb "123\n" before gdb has switched the tty, then it goes
+        # If we send gdb "123\n" before gdb has switched the tty, then it goes
         # to gdb, not the inferior, and we lose.  So that is why we have
         # watchpoint.c prompt us, so we can wait for that prompt.
 
         send_gdb "continue\n";
         gdb_expect {
             -re "Continuing\\.\r\ntype stuff for buf now:" {
                 pass "continue to read"
             }
             default {
                 fail "continue to read";
                 return ;
             }
         }
 
-        send_gdb "123\n"
-        gdb_expect {
+        set test "sent 123"
+        gdb_test_multiple "123" $test {
             -re ".*\[Ww\]atchpoint.*buf\\\[0\\\].*Old value = 0.*New value = 49\[^\n\]*\n" { set x [expr $x+1] ; exp_continue }
             -re ".*\[Ww\]atchpoint.*buf\\\[1\\\].*Old value = 0.*New value = 50\[^\n\]*\n" { set x [expr $x+1] ; exp_continue }
             -re ".*\[Ww\]atchpoint.*buf\\\[2\\\].*Old value = 0.*New value = 51\[^\n\]*\n" { set x [expr $x+1] ; exp_continue }
             -re ".*\[Ww\]atchpoint.*buf\\\[3\\\].*Old value = 0.*New value = 10\[^\n\]*\n" { set x [expr $x+1] ; exp_continue }
-            -re ".*$gdb_prompt $" { pass "sent 123" }
-            timeout { fail "sent 123 (timeout)" }
+            -re ".*$gdb_prompt $" { pass $test }
         }
 
         # Examine the values in buf to see how many watchpoints we
         # should have printed.
-        send_gdb "print buf\[0\]\n"
-        gdb_expect {
-            -re ".*= 49.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[0\]"}
-            -re ".*= 0.*$gdb_prompt $" { pass "print buf\[0\]"}
-            -re ".*$gdb_prompt $" { fail "print buf\[0\]"}
-            default { fail "print buf\[0\]"}
+        set test "print buf\[0\]"
+        gdb_test_multiple $test $test {
+            -re ".*= 49.*$gdb_prompt $" { set y [expr $y+1]; pass $test }
+            -re ".*= 0.*$gdb_prompt $" { $test }
         }
-        send_gdb "print buf\[1\]\n"
-        gdb_expect {
-            -re ".*= 50.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[1\]"}
-            -re ".*= 0.*$gdb_prompt $" { pass "print buf\[1\]"}
-            -re ".*$gdb_prompt $" { fail "print buf\[1\]"}
-            default { fail "print buf\[1\]"}
+        set test "print buf\[1\]"
+        gdb_test_multiple $test $test {
+            -re ".*= 50.*$gdb_prompt $" { set y [expr $y+1]; pass $test }
+            -re ".*= 0.*$gdb_prompt $" { pass $test }
         }
-        send_gdb "print buf\[2\]\n"
-        gdb_expect {
-            -re ".*= 51.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[2\]"}
-            -re ".*= 0.*$gdb_prompt $" { pass "print buf\[2\]"}
-            -re ".*$gdb_prompt $" { fail "print buf\[2\]"}
-            default { fail "print buf\[2\]"}
+        set test "print buf\[2\]"
+        gdb_test_multiple $test $test {
+            -re ".*= 51.*$gdb_prompt $" { set y [expr $y+1]; pass $test }
+            -re ".*= 0.*$gdb_prompt $" { pass $test }
         }
-        send_gdb "print buf\[3\]\n"
-        gdb_expect {
-            -re ".*= 10.*$gdb_prompt $" { set y [expr $y+1]; pass "print buf\[3\]"}
-            -re ".*= 0.*$gdb_prompt $" { pass "print buf\[3\]"}
-            -re ".*$gdb_prompt $" { fail "print buf\[3\]" }
-            default { fail "print buf\[3\]" }
+        set test "print buf\[3\]"
+        gdb_test_multiple $test $test {
+            -re ".*= 10.*$gdb_prompt $" { set y [expr $y+1]; pass $test }
+            -re ".*= 0.*$gdb_prompt $" { pass $test }
         }
 
         # Did we find what we were looking for?  If not, flunk it.
         if [expr $x==$y] then { pass $testname } else { fail "$testname (only triggered $x watchpoints, expected $y)"}
 
         # Continue until we hit the finishing marker function.
         # Make sure we hit no more watchpoints.
         gdb_test "cont" "Continuing.*Breakpoint.*marker4 \\(\\).*" \
             "continue to marker4"
 
@@ skipping 25 matching lines @@
             "did not trigger wrong watchpoint"
 
         # Test watches of things declared locally in a function.
         # In particular, test that a watch of stack-based things
         # is deleted when the stack-based things go out of scope.
         #
         gdb_test_no_output "disable" "disable in test_complex_watchpoint"
         gdb_test "break marker6" ".*Breakpoint.*"
         gdb_test "cont" "Continuing.*Breakpoint.*marker6 \\(\\).*" \
             "continue to marker6"
-        gdb_test "break func2" ".*Breakpoint.*"
-        gdb_test "cont" "Continuing.*func2.*"
+        gdb_breakpoint [gdb_get_line_number "func2 breakpoint here"]
+        gdb_continue_to_breakpoint "func2 breakpoint here"
 
         # Test a watch of a single stack-based variable, whose scope
         # is the function we're now in.  This should auto-delete when
         # execution exits the scope of the watchpoint.
         #
         gdb_test "watch local_a" ".*\[Ww\]atchpoint \[0-9\]*: local_a" "set local watch"
         gdb_test "cont" "\[Ww\]atchpoint.*local_a.*" "trigger local watch"
-        gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" "self-delete local watch"
 
-        gdb_test "cont" "Continuing.*func2.*"
+        set test "self-delete local watch"
+        gdb_test_multiple "cont" $test {
+            -re "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*\r\n$gdb_prompt $" {
+                pass $test
+            }
+            -re "can't compute CFA for this frame.*\r\n$gdb_prompt $" {
+                global compiler_info no_hw
+
+                # GCC < 4.5.0 does not get LOCATIONS_VALID set by dwarf2read.c.
+                # Therefore epilogue unwinder gets applied which is
+                # incompatible with dwarf2_frame_cfa.
+                verbose -log "compiler_info: $compiler_info"
+                if {$no_hw && ([test_compiler_info {gcc-[0-3]-*}]
+                               || [test_compiler_info {gcc-4-[0-4]-*}])} {
+                    xfail "$test (old GCC has broken watchpoints in epilogues)"
+                    return
+                }
+                fail $test
+            }
+        }
+
+        gdb_continue_to_breakpoint "func2 breakpoint here"
         # We should be in "func2" again now.  Test a watch of an
         # expression which includes both a stack-based local and
         # something whose scope is larger than this invocation
         # of "func2".  This should also auto-delete.
         #
         gdb_test "watch local_a + ival5" ".*\[Ww\]atchpoint \[0-9\]*: local_a . ival5" \
                  "set partially local watch"
         gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_a . ival5.*" \
                  "trigger1 partially local watch"
         gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_a . ival5.*" \
                  "trigger2 partially local watch"
         gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \
                  "self-delete partially local watch"
 
         # We should be in "func2" again now.  Test a watch of a
         # static (non-stack-based) local.  Since this has scope
         # across any invocations of "func2", it should not auto-
         # delete.
         #
-        gdb_test "cont" "Continuing.*func2.*"
+        gdb_continue_to_breakpoint "func2 breakpoint here"
         gdb_test "watch static_b" ".*\[Ww\]atchpoint \[0-9\]*: static_b" \
                  "set static local watch"
         gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: static_b.*" \
                  "trigger static local watch"
         gdb_test "cont" "Continuing.*marker6 \\(\\).*" \
                  "continue after trigger static local watch"
         gdb_test "info break" ".*watchpoint.*static_b.*" \
                  "static local watch did not self-delete"
 
         # We should be in "recurser" now.  Test a watch of a stack-
         # based local.  Symbols mentioned in a watchpoint are bound
         # at watchpoint-creation.  Thus, a watch of a stack-based
         # local to a recursing function should be bound only to that
         # one invocation, and should not trigger for other invocations.
         #
         gdb_test "tbreak recurser" ".*breakpoint.*"
         gdb_test "cont" "Continuing.*recurser.*"
+        gdb_test "next" "if \\(x > 0.*" "next past local_x initialization"
         gdb_test "watch local_x" ".*\[Ww\]atchpoint \[0-9\]*: local_x" \
                  "set local watch in recursive call"
         gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_x.*New value = 2.*" \
                  "trigger local watch in recursive call"
         gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \
                  "self-delete local watch in recursive call"
 
+        # Repeat the preceding test, but this time use "recurser::local_x" as
+        # the variable to track.
+        gdb_test "cont" "Continuing.*marker6.*"
+        gdb_test "tbreak recurser" ".*breakpoint.*"
+        gdb_test "cont" "Continuing.*recurser.*"
+        gdb_test "next" "if \\(x > 0.*" "next past local_x initialization"
+        gdb_test "watch recurser::local_x" ".*\[Ww\]atchpoint \[0-9\]*: recurser::local_x" \
+                 "set local watch in recursive call with explicit scope"
+        gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: recurser::local_x.*New value = 2.*" \
+                 "trigger local watch with explicit scope in recursive call"
+        gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \
+                 "self-delete local watch with explicit scope in recursive call (2)"
+
         # Disable everything so we can finish the program at full speed
         gdb_test_no_output "disable" "disable in test_complex_watchpoint"
 
         if [target_info exists gdb,noresults] { return }
 
         gdb_continue_to_end "continue to exit in test_complex_watchpoint"
     }
 }
 
 proc test_watchpoint_and_breakpoint {} {
@@ skipping 14 matching lines @@
                 kfail "gdb/38" "next after watch x"
             }
         }
 
         gdb_test_no_output "delete \$bpnum" "delete watch x"
     }
 }
 
 proc test_constant_watchpoint {} {
     gdb_test "watch 5" "Cannot watch constant value `5'." "number is constant"
+    gdb_test "watch (int *)5" "Cannot watch constant value `\\(int \\*\\)5'." \
+    "number with cast is constant"
     gdb_test "watch marker1" "Cannot watch constant value `marker1'." \
     "marker1 is constant"
     gdb_test "watch count + 6" ".*atchpoint \[0-9\]+: count \\+ 6"
     gdb_test_no_output "delete \$bpnum" "delete watchpoint `count + 6'"
     gdb_test "watch 7 + count" ".*atchpoint \[0-9\]+: 7 \\+ count"
     gdb_test_no_output "delete \$bpnum" "delete watchpoint `7 + count'"
 }
 
 proc test_disable_enable_software_watchpoint {} {
     # This is regression test for a bug that caused `enable' to fail
@@ skipping 18 matching lines @@
 
     gdb_test "watch -location *x" "atchpoint .*: .*" "watch -location .x"
 
     gdb_test "continue" \
         "Continuing.*\[Ww\]atchpoint .*: .*New value = 27.*" \
         "continue with watch -location"
 
     gdb_test_no_output "delete \$bpnum" "delete watch -location"
 }
 
+# Tests watching areas larger than a word.
+
+proc test_wide_location_1 {} {
+    global no_hw
+    global gdb_prompt
+
+    # This test watches two words on most 32-bit ABIs, and one word on
+    # most 64-bit ABIs.
+
+    # Platforms where the target can't watch such a large region
+    # should clear hw_expected below.
+    if { $no_hw || [target_info exists gdb,no_hardware_watchpoints]
+         || [istarget arm*-*-*]
+         || ([istarget powerpc*-*-*] && ![is_lp64_target])} {
+        set hw_expected 0
+    } else {
+        set hw_expected 1
+    }
+
+    gdb_breakpoint [gdb_get_line_number "func6 breakpoint here"]
+    gdb_continue_to_breakpoint "func6 breakpoint here"
+
+    if { $hw_expected } {
+        gdb_test "watch foo2" "Hardware watchpoint .*: .*" "watch foo2"
+        gdb_test "continue" \
+            "Continuing.*Hardware watchpoint .*: .*New value = \\\{val = \\\{0, 11\\\}\\\}.*" \
+            "continue with watch foo2"
+    } else {
+        gdb_test "watch foo2" "atchpoint .*: .*" "watch foo2"
+        set test "continue with watch foo2"
+        gdb_test_multiple "cont" $test {
+            -re "Continuing.*\[Ww\]atchpoint .*: .*New value = \\\{val = \\\{0, 11\\\}\\\}.*$gdb_prompt $" {
+                pass $test
+            }
+            -re "Could not insert hardware breakpoints:.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" {
+                # This may happen with remote targets that support
+                # hardware watchpoints.  We only find out the
+                # watchpoint was too large, for example, at insert
+                # time.  If GDB is ever adjusted to downgrade the
+                # watchpoint automatically in this case, this match
+                # should be removed.
+                pass $test
+            }
+        }
+    }
+
+    gdb_test_no_output "delete \$bpnum" "delete watch foo2"
+}
+
+proc test_wide_location_2 {} {
+    global no_hw
+    global gdb_prompt
+
+    # This test watches four words on most 32-bit ABIs, and two words
+    # on 64-bit ABIs.
+
+    # Platforms where the target can't watch such a large region
+    # should clear hw_expected below.
+    if { $no_hw || [target_info exists gdb,no_hardware_watchpoints]
+         || [istarget arm*-*-*]
+         || [istarget powerpc*-*-*]} {
+        set hw_expected 0
+    } else {
+        set hw_expected 1
+    }
+
+    gdb_breakpoint [gdb_get_line_number "func7 breakpoint here"]
+    gdb_continue_to_breakpoint "func7 breakpoint here"
+
+    if { $hw_expected } {
+        gdb_test "watch foo4" "Hardware watchpoint .*: .*" "watch foo4"
+        gdb_test "continue" \
+            "Continuing.*Hardware watchpoint .*: .*New value = \\\{val = \\\{0, 0, 0, 33\\\}\\\}.*" \
+            "continue with watch foo4"
+    } else {
+        gdb_test "watch foo4" "atchpoint .*: .*" "watch foo4"
+        set test "continue with watch foo4"
+        gdb_test_multiple "cont" $test {
+            -re "Continuing.*\[Ww\]atchpoint .*: .*New value = \\\{val = \\\{0, 0, 0, 33\\\}\\\}.*$gdb_prompt $" {
+                pass $test
+            }
+            -re "Could not insert hardware breakpoints:.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" {
+                # This may happen with remote targets that support
+                # hardware watchpoints.  We only find out the
+                # watchpoint was too large, for example, at insert
+                # time.  If GDB is ever adjusted to downgrade the
+                # watchpoint automatically in this case, this match
+                # should be removed.
+                pass $test
+            }
+        }
+    }
+
+    gdb_test_no_output "delete \$bpnum" "delete watch foo4"
+}
+
 proc test_inaccessible_watchpoint {} {
     global gdb_prompt
 
     # This is a test for watchpoints on currently inaccessible (but later
     # valid) memory.
 
     if [runto func4] then {
         # Make sure we only allow memory access errors.
         set msg "watchpoint refused to insert on nonexistent struct member"
         gdb_test_multiple "watch struct1.nosuchmember" $msg {
@@ skipping 49 matching lines @@
             }
         }
         gdb_test_multiple "next" "next over buffer set" {
             -re ".*atchpoint \[0-9\]+: \\*global_ptr\r\n\r\nOld value = 3 .*\r\nNew value = 7 .*\r\n.*$gdb_prompt $" {
                 pass "next over buffer set"
             }
         }
         gdb_test "delete \$global_ptr_breakpoint_number" ""
         gdb_test "watch **global_ptr_ptr" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr"
         gdb_test "set \$global_ptr_ptr_breakpoint_number = \$bpnum" ""
-        gdb_test "next" ".*global_ptr_ptr = &global_ptr.*" "gloabl_ptr_ptr next"
+        gdb_test "next" ".*global_ptr_ptr = &global_ptr.*" "global_ptr_ptr next"
         gdb_test "next" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\[\r\n\]+Old value = .*\r\nNew value = 7 .*" "next over global_ptr_ptr init"
         gdb_test "next" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\[\r\n\]+Old value = 7 .*\r\nNew value = 9 .*" "next over global_ptr_ptr buffer set"
         gdb_test "next" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\[\r\n\]+Old value = 9 .*\r\nNew value = 5 .*" "next over global_ptr_ptr pointer advance"
         gdb_test_no_output "delete \$global_ptr_ptr_breakpoint_number"
     }
 }
-    
+
+proc test_no_hw_watchpoints {} {
+    global testfile
+
+    clean_restart $testfile
+
+    # Verify that a user can force GDB to use "slow" watchpoints.
+    # (This proves rather little on kernels that don't support
+    # fast watchpoints, but still...)
+    #
+    if ![runto_main] then { fail "watch tests suppressed" }
+
+    gdb_test_no_output "set can-use-hw-watchpoints 0" "disable fast watches"
+
+    gdb_test "show can-use-hw-watchpoints" \
+        "Debugger's willingness to use watchpoint hardware is 0." \
+        "show disable fast watches"
+
+    gdb_test "watch ival3 if  count > 1" \
+        "Watchpoint \[0-9\]*: ival3.*" \
+        "set slow conditional watch"
+
+    gdb_test "continue" \
+        "Watchpoint \[0-9\]*: ival3.*Old value = 1.*New value = 2.*" \
+        "trigger slow conditional watch"
+
+    gdb_test_no_output "delete \$bpnum" "delete watch ival3"
+
+    # We've explicitly disabled hardware watches.  Verify that GDB
+    # refrains from using them.
+    #
+    gdb_test "rwatch ival3" \
+        "Expression cannot be implemented with read/access watchpoint..*" \
+        "rwatch disallowed when can-set-hw-watchpoints cleared"
+
+    # Re-enable hardware watchpoints if necessary.
+    if ![target_info exists gdb,no_hardware_watchpoints] {
+        gdb_test_no_output "set can-use-hw-watchpoints 1" ""
+    }
+}
+
 proc test_watchpoint_in_big_blob {} {
     global gdb_prompt
 
-    gdb_test "watch buf" ".*atchpoint \[0-9\]+: buf"
-    gdb_test "cont" "Continuing.*atchpoint \[0-9\]+: buf\r\n\r\nOld value = .*testte\".*" "watchpoint on buf hit"
+    # On native targets where we do hardware resource accounting, this
+    # may end up as a software watchpoint.
+    set ok 0
+    set test "watch buf"
+    gdb_test_multiple "watch buf" $test {
+        -re "Hardware watchpoint \[0-9\]+: buf.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" {
+            # This may happen with remote targets (where we don't do
+            # resource accounting) that support hardware watchpoints,
+            # when breakpoint always-inserted is on.  The watchpoint
+            # was too large, for example.  If GDB is ever adjusted to
+            # downgrade the watchpoint automatically in this case,
+            # this match should be removed.  Note the breakpoint has
+            # been created, and is in the list, so it needs deleting.
+            pass $test
+        }
+        -re ".*atchpoint \[0-9\]+: buf.*$gdb_prompt $" {
+            pass $test
+            set ok 1
+        }
+    }
+
+    if { $ok } {
+        set test "watchpoint on buf hit"
+        gdb_test_multiple "cont" $test {
+            -re "Continuing.*atchpoint \[0-9\]+: buf\r\n\r\nOld value = .*testte\".*$gdb_prompt $" {
+                pass $test
+            }
+            -re "Could not insert hardware breakpoints:.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" {
+                # This may happen with remote targets that support
+                # hardware watchpoints.  We only find out the
+                # watchpoint was too large, for example, at insert
+                # time.  If GDB is ever adjusted to downgrade the
+                # watchpoint automatically in this case, this match
+                # should be removed.
+                pass $test
+            }
+        }
+    }
 
     gdb_test_no_output "delete \$bpnum" "delete watch buf"
 }
 
 # Start with a fresh gdb.
 
-gdb_exit
-gdb_start
-gdb_reinitialize_dir $srcdir/$subdir
-gdb_load $binfile
 set prev_timeout $timeout
 set timeout 600 
 verbose "Timeout now 600 sec.\n"
 
-if [initialize] then {
+test_no_hw_watchpoints
 
-    test_simple_watchpoint
+proc do_tests {} {
+    global testfile
+    global no_hw
 
-    # The IDT/sim monitor only has 8 (!) open files, of which it uses
-    # 4 (!).  So we have to make sure one program exits before
-    # starting another one.
-    if [istarget "mips-idt-*"] then {
-        gdb_exit
-        gdb_start
-        gdb_reinitialize_dir $srcdir/$subdir
-        gdb_load $binfile
-        initialize
+    clean_restart $testfile
+
+    if {$no_hw || [target_info exists gdb,no_hardware_watchpoints]} {
+        gdb_test_no_output "set can-use-hw-watchpoints 0" ""
     }
 
-    test_disabling_watchpoints
+    if [initialize] then {
 
-    # See above.
-    if [istarget "mips-idt-*"] then {
-        gdb_exit
-        gdb_start
-        gdb_reinitialize_dir $srcdir/$subdir
-        gdb_load $binfile
-        initialize
+        test_simple_watchpoint
+
+        test_disabling_watchpoints
+
+        if ![target_info exists gdb,cannot_call_functions] {
+            test_stepping
+        }
     }
 
-    if ![target_info exists gdb,cannot_call_functions] {
-        test_stepping
+    # Tests below don't rely on the markers and watchpoint set by
+    # `initialize' anymore.
+    clean_restart $testfile
 
-        # See above.
-        if [istarget "mips-idt-*"] then {
-            gdb_exit
-            gdb_start
-            gdb_reinitialize_dir $srcdir/$subdir
-            gdb_load $binfile
-            initialize
-        }
+    if {$no_hw || [target_info exists gdb,no_hardware_watchpoints]} {
+        gdb_test_no_output "set can-use-hw-watchpoints 0" ""
     }
 
     # Only enabled for some targets merely because it has not been tested 
     # elsewhere.
     # On sparc-sun-sunos4.1.3, GDB was running all the way to the marker4 
     # breakpoint before stopping for the watchpoint.  I don't know why.
     if {[istarget "hppa*-*-*"]} then {
         test_watchpoint_triggered_in_syscall
     }
 
-    # See above.
-    if [istarget "mips-idt-*"] then {
-        gdb_exit
-        gdb_start
-        gdb_reinitialize_dir $srcdir/$subdir
-        gdb_load $binfile
-        initialize
-    }
-
-    # Only enabled for some targets merely because it has not been tested 
-    # elsewhere.
-    if {[istarget "hppa*-*-*"] || \
-            [istarget "sparc*-*-sunos*"] || \
-            [istarget "m32r-*-*"]} then {
-        test_complex_watchpoint
-    }
+    test_complex_watchpoint
 
     test_inaccessible_watchpoint
 
-    # Verify that a user can force GDB to use "slow" watchpoints.
-    # (This proves rather little on kernels that don't support
-    # fast watchpoints, but still...)
-    #
-    if ![runto_main] then { fail "watch tests suppressed" }
-
-    send_gdb "set can-use-hw-watchpoints 0\n"
-    gdb_expect {
-      -re "$gdb_prompt $"\
-              {pass "disable fast watches"}
-      timeout {fail "(timeout) disable fast watches"}
-    }
-    send_gdb "show can-use-hw-watchpoints\n"
-    gdb_expect {
-      -re "Debugger's willingness to use watchpoint hardware is 0.*$gdb_prompt $"\
-              {pass "show disable fast watches"}
-      -re "$gdb_prompt $"\
-              {fail "show disable fast watches"}
-      timeout {fail "(timeout) show disable fast watches"}
-    }
-    send_gdb "watch ival3 if  count > 1\n"
-    gdb_expect {
-      -re "Watchpoint \[0-9\]*: ival3.*$gdb_prompt $"\
-              {pass "set slow conditional watch"}
-      -re "$gdb_prompt $"\
-              {fail "set slow conditional watch"}
-      timeout {fail "(timeout) set slow conditional watch"}
-    }
-    send_gdb "continue\n"
-    gdb_expect {
-      -re "Watchpoint \[0-9\]*: ival3.*Old value = 1.*New value = 2.*$gdb_prompt $"\
-              {pass "trigger slow conditional watch"}
-      -re "$gdb_prompt $"\
-              {fail "trigger slow conditional watch"}
-      timeout {fail "(timeout) trigger slow conditional watch"}
-    }
-
-    # We've explicitly disabled hardware watches.  Verify that GDB
-    # refrains from using them.
-    #
-    send_gdb "rwatch ival3\n"
-    gdb_expect {
-      -re "Expression cannot be implemented with read/access watchpoint..*$gdb_prompt $"\
-              {pass "rwatch disallowed when can-set-hw-watchpoints cleared"}
-      -re "$gdb_prompt $"\
-              {fail "rwatch disallowed when can-set-hw-watchpoints cleared"}
-      timeout {fail "(timeout) rwatch disallowed when can-use-hw-watchpoints cleared"}
-    }
-
-    # Read- and access watchpoints are unsupported on HP-UX.  Verify
-    # that GDB gracefully responds to requests to create them.
-    #
-    if [istarget "hppa*-*-hpux*"] then {
-      send_gdb "set can-use-hw-watchpoints 1\n"
-      gdb_expect {
-        -re "$gdb_prompt $"\
-                {pass "enable fast watches"}
-        timeout {fail "(timeout) enable fast watches"}
-      }
-      send_gdb "rwatch ival3\n"
-      gdb_expect {
-        -re "Target does not have this type of hardware watchpoint support.*$gdb_prompt $"\
-                {pass "read watches disallowed"}
-        -re "$gdb_prompt $"\
-                {fail "read watches disallowed"}
-        timeout {fail "(timeout) read watches disallowed"}
-      }
-
-      send_gdb "awatch ival3\n"
-      gdb_expect {
-        -re "Target does not have this type of hardware watchpoint support.*$gdb_prompt $"\
-                {pass "access watches disallowed"}
-        -re "$gdb_prompt $"\
-                {fail "access watches disallowed"}
-        timeout {fail "(timeout) access watches disallowed"}
-      }
-    }
-
-    # See above.
-    if [istarget "mips-idt-*"] then {
-        gdb_exit
-        gdb_start
-        gdb_reinitialize_dir $srcdir/$subdir
-        gdb_load $binfile
-        initialize
-    }
-
     test_watchpoint_and_breakpoint
 
     test_watchpoint_in_big_blob
 
-    # See above.
-    if [istarget "mips-idt-*"] then {
-        clean_restart
-    }
-
     test_constant_watchpoint
 
     test_disable_enable_software_watchpoint
 
     test_watch_location
+
+    test_wide_location_1
+    test_wide_location_2
+}
+
+# On targets that can do hardware watchpoints, run the tests twice:
+# once with hardware watchpoints enabled; another with hardware
+# watchpoints force-disabled.
+
+do_tests
+if ![target_info exists gdb,no_hardware_watchpoints] {
+    with_test_prefix "no-hw" {
+        set no_hw 1
+        do_tests
+    }
 }
 
 # Restore old timeout
 set timeout $prev_timeout
 verbose "Timeout now $timeout sec.\n"