GDB 7.6.50

gdb/testsuite/gdb.base/watchpoint.exp

-# Copyright 1992, 1994-2000, 2007-2012 Free Software Foundation, Inc.
+# Copyright 1992-2013 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)
 
 
-set testfile "watchpoint"
-set srcfile ${testfile}.c
-set binfile ${objdir}/${subdir}/${testfile}
+standard_testfile
 
 if [get_compiler_info] {
     return -1
 }
 
 if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
      untested watchpoint.exp
      return -1
 }
 
@@ skipping 16 matching lines @@
 #       2               Breakpoint      marker2()
 #       3               Watchpoint      ival3
 
 proc initialize {} {
     global gdb_prompt
     global hex
     global decimal
     global srcfile
 
     if [gdb_test "break marker1" "Breakpoint 1 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker1" ] { 
-      return 0; 
+      return 0
     }
 
 
     if [gdb_test "break marker2" "Breakpoint 2 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker2" ] { 
-      return 0; 
+      return 0
     }
 
 
     if [gdb_test "info break" "1\[ \]*breakpoint.*marker1.*\r\n2\[ \]*breakpoint.*marker2.*" "info break in watchpoint.exp" ] { 
-      return 0; 
+      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; 
+      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 0
     }
 
 
     return 1
 }
 
 #
 # Test simple watchpoint.
 #
 
 proc test_simple_watchpoint {} {
     global gdb_prompt
     global hex
     global decimal
 
     # Ensure that the watchpoint is disabled when we startup.
 
     if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_simple_watchpoint" ] { 
-      return 0; 
+      return 0
     }
 
     # Run until we get to the first marker function.
 
     gdb_run_cmd
     set timeout 600
     set test "run to marker1 in test_simple_watchpoint"
     set retcode [gdb_test_multiple "" $test {
         -re "Breakpoint 1, marker1 .*$gdb_prompt $" {
             pass $test
         }
     }]
 
     if { $retcode != 0 } {
         return
     }
 
     # After reaching the marker function, enable the watchpoint.
 
     if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "enable watchpoint" ] { 
-      return ; 
+      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
@@ skipping 46 matching lines @@
 
     # Continue until we hit the finishing marker function.
     # Make sure we hit no more watchpoints.
 
     gdb_test "cont" "Continuing.*Breakpoint.*marker2 \(\).*" \
         "continue to marker2"
 
     # Disable the watchpoint so we run at full speed until we exit.
 
     if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "watchpoint disabled" ] { 
-      return ; 
+      return
     }
 
 
     # Run until process exits.
 
     if [target_info exists gdb,noresults] { return }
 
     gdb_continue_to_end "continue to exit in test_simple_watchpoint"
 }
 
 # Test disabling watchpoints.
 
 proc test_disabling_watchpoints {} {
     global gdb_prompt
     global binfile
     global srcfile
     global decimal
     global hex
 
     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; 
+      return 0
     }
 
 
     # Run until we get to the first marker function.
 
     gdb_run_cmd
     set timeout 600
     set test "run to marker1 in test_disabling_watchpoints"
     set retcode [gdb_test_multiple "" $test {
         -re "Breakpoint 1, marker1 .*$gdb_prompt $" {
             pass $test
         }
     }]
 
     if { $retcode != 0 } {
         return
     }
 
     # After reaching the marker function, enable the watchpoint.
 
     if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "watchpoint enabled" ] { 
-      return ; 
+      return
     }
 
 
     # Continue until the first change, from -1 to 0
     # Don't check the old value, because on VxWorks the variable value
     # will not have been reinitialized.
     gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = .*New value = 0.*ival3 = count; ival4 = count;.*" "watchpoint hit in test_disabling_watchpoints, first time"
     
     # 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 in test_disabling_watchpoints, second time"
     
     # Disable the watchpoint but leave breakpoints
 
     if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint #2 in test_disabling_watchpoints" ] { 
-      return 0; 
+      return 0
     }
 
 
     # Check watchpoint list, looking for the entry that confirms the
     # watchpoint is disabled.
     gdb_test "info watchpoints" "\[0-9]+\[ \]*.*watchpoint\[ \]*keep\[ \]*n\[ \]*ival3\r\n.*" "watchpoint disabled in table"
 
     # Continue until we hit the finishing marker function.
     # Make sure we hit no more watchpoints.
     gdb_test "cont" "Continuing.*Breakpoint.*marker2 \\(\\).*" \
@@ skipping 74 matching lines @@
         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;
+        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
         # 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";
+        send_gdb "continue\n"
         gdb_expect {
             -re "Continuing\\.\r\ntype stuff for buf now:" {
                 pass "continue to read"
             }
             default {
-                fail "continue to read";
-                return ;
+                fail "continue to read"
+                return
             }
         }
 
         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 $test }
@@ skipping 213 matching lines @@
         ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+.pc.*" \
         "watchpoint `\$pc' is enabled"
 
     gdb_test_no_output "delete \$bpnum" "delete watchpoint `\$pc'"
 }
 
 proc test_watch_location {} {
     gdb_breakpoint [gdb_get_line_number "func5 breakpoint here"]
     gdb_continue_to_breakpoint "func5 breakpoint here"
 
+    gdb_test "watch -location nullptr->p->x" \
+        "Cannot access memory at address 0x0"
+
     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.
@@ skipping 189 matching lines @@
     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"
 
+    gdb_test "watch ival3 if  count > 1  thread 1 " \
+         "Watchpoint \[0-9\]*: ival3.*" \
+         "set slow condition watch w/thread"
+
+    gdb_test_no_output "delete \$bpnum" "delete watch w/condition and thread"
+
     # 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..*" \
+        "Can't set read/access watchpoint when hardware watchpoints are disabled." \
         "rwatch disallowed when can-set-hw-watchpoints cleared"
+    gdb_test "awatch ival3" \
+        "Can't set read/access watchpoint when hardware watchpoints are disabled." \
+        "awatch 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
 
@@ skipping 32 matching lines @@
                 # watchpoint automatically in this case, this match
                 # should be removed.
                 pass $test
             }
         }
     }
 
     gdb_test_no_output "delete \$bpnum" "delete watch buf"
 }
 
+proc test_watch_register_location {} {
+    global no_hw
+
+    if {!$no_hw && ![target_info exists gdb,no_hardware_watchpoints]} {
+        # Non-memory read/access watchpoints are not supported, they would
+        # require software read/access watchpoint support (which is not
+        # currently available).
+        gdb_test "rwatch \$pc" \
+            "Expression cannot be implemented with read/access watchpoint..*" \
+            "rwatch disallowed for register based expression"
+        gdb_test "awatch \$pc" \
+            "Expression cannot be implemented with read/access watchpoint..*" \
+            "awatch disallowed for register based expression"
+    }
+}
+
 # Start with a fresh gdb.
 
 set prev_timeout $timeout
 set timeout 600 
 verbose "Timeout now 600 sec.\n"
 
 test_no_hw_watchpoints
 
 proc do_tests {} {
     global testfile
@@ skipping 41 matching lines @@
     test_watchpoint_in_big_blob
 
     test_constant_watchpoint
 
     test_disable_enable_software_watchpoint
 
     test_watch_location
 
     test_wide_location_1
     test_wide_location_2
+
+    test_watch_register_location
 }
 
 # 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"