1# Copyright 1992-2017 Free Software Foundation, Inc. 2 3# This program is free software; you can redistribute it and/or modify 4# it under the terms of the GNU General Public License as published by 5# the Free Software Foundation; either version 3 of the License, or 6# (at your option) any later version. 7# 8# This program is distributed in the hope that it will be useful, 9# but WITHOUT ANY WARRANTY; without even the implied warranty of 10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11# GNU General Public License for more details. 12# 13# You should have received a copy of the GNU General Public License 14# along with this program. If not, see <http://www.gnu.org/licenses/>. 15 16# This file was written by Fred Fish. (fnf@cygnus.com) 17 18 19standard_testfile 20 21if [get_compiler_info] { 22 return -1 23} 24 25if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } { 26 untested "failed to compile" 27 return -1 28} 29 30# True if we're forcing no hardware watchpoints. 31set no_hw 0 32 33# Prepare for watchpoint tests by setting up two breakpoints and one 34# watchpoint. 35# 36# We use breakpoints at marker functions to get past all the startup code, 37# so we can get to the watchpoints in a reasonable amount of time from a 38# known starting point. 39# 40# For simplicity, so we always know how to reference specific breakpoints or 41# watchpoints by number, we expect a particular ordering and numbering of 42# each in the combined breakpoint/watchpoint table, as follows: 43# 44# Number What Where 45# 1 Breakpoint marker1() 46# 2 Breakpoint marker2() 47# 3 Watchpoint ival3 48 49proc initialize {} { 50 global gdb_prompt 51 global hex 52 global decimal 53 global srcfile 54 55 if [gdb_test "break marker1" "Breakpoint 1 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker1" ] { 56 return 0 57 } 58 59 60 if [gdb_test "break marker2" "Breakpoint 2 at $hex: file .*$srcfile, line $decimal.*" "set breakpoint at marker2" ] { 61 return 0 62 } 63 64 65 if [gdb_test "info break" "1\[ \]*breakpoint.*marker1.*\r\n2\[ \]*breakpoint.*marker2.*" "info break in watchpoint.exp" ] { 66 return 0 67 } 68 69 gdb_test "watch ival3" ".*\[Ww\]atchpoint 3: ival3.*" "set watchpoint on ival3" 70 71 if [gdb_test "info watch" "3\[ \]*.*watchpoint.*ival3" "watchpoint found in watchpoint/breakpoint table" ] { 72 return 0 73 } 74 75 76 # After installing the watchpoint, we disable it until we are ready 77 # to use it. This allows the test program to run at full speed until 78 # we get to the first marker function. 79 80 if [gdb_test "disable 3" "disable 3\[\r\n\]+" "disable watchpoint" ] { 81 return 0 82 } 83 84 85 return 1 86} 87 88# 89# Test simple watchpoint. 90# 91 92proc test_simple_watchpoint {} { 93 global gdb_prompt 94 global hex 95 global decimal 96 97 # Ensure that the watchpoint is disabled when we startup. 98 99 if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_simple_watchpoint" ] { 100 return 0 101 } 102 103 # Run until we get to the first marker function. 104 105 gdb_run_cmd 106 set timeout 600 107 set test "run to marker1 in test_simple_watchpoint" 108 set retcode [gdb_test_multiple "" $test { 109 -re "Breakpoint 1, marker1 .*$gdb_prompt $" { 110 pass $test 111 } 112 }] 113 114 if { $retcode != 0 } { 115 return 116 } 117 118 # After reaching the marker function, enable the watchpoint. 119 120 if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "enable watchpoint" ] { 121 return 122 } 123 124 125 gdb_test "break func1" "Breakpoint.*at.*" 126 gdb_test_no_output "set \$func1_breakpoint_number = \$bpnum" 127 128 gdb_test "continue" "Continuing.*Breakpoint \[0-9\]*, func1.*" \ 129 "continue to breakpoint at func1" 130 131 # Continue until the first change, from -1 to 0 132 133 set test "watchpoint hit, first time" 134 gdb_test_multiple "cont" $test { 135 -re "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 = count; ival4 = count;.*$gdb_prompt $" { 136 pass $test 137 } 138 -re "Continuing.*Breakpoint.*func1.*$gdb_prompt $" { 139 setup_xfail "m68*-*-*" 2597 140 fail "thought it hit breakpoint at func1 twice" 141 gdb_test_no_output "delete \$func1_breakpoint_number" 142 gdb_test "continue" "\ 143Continuing.*\[Ww\]atchpoint.*ival3.*Old value = -1.*New value = 0.*ival3 = count;" \ 144 $test 145 } 146 } 147 148 # Check that the hit count is reported correctly 149 gdb_test "info break" ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+ival3\r\n\[ \t]+breakpoint already hit 1 time.*" "watchpoint hit count is 1" 150 151 gdb_test_no_output "delete \$func1_breakpoint_number" 152 153 # Continue until the next change, from 0 to 1. 154 gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 0.*New value = 1.*ival3 = count; ival4 = count;.*" "watchpoint hit, second time" 155 156 # Check that the hit count is reported correctly 157 gdb_test "info break" ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+ival3\r\n\[ \t]+breakpoint already hit 2 times.*" "watchpoint hit count is 2" 158 159 # Continue until the next change, from 1 to 2. 160 gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 1.*New value = 2.*ival3 = count; ival4 = count;.*" "watchpoint hit, third time" 161 162 # Check that the hit count is reported correctly 163 gdb_test "info break" ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+ival3\r\n\[ \t]+breakpoint already hit 3 times.*" "watchpoint hit count is 3" 164 165 # Continue until the next change, from 2 to 3. 166 gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 2.*New value = 3.*ival3 = count; ival4 = count;.*" "watchpoint hit, fourth time" 167 168 # Check that the hit count is reported correctly 169 gdb_test "info break" ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+ival3\r\n\[ \t]+breakpoint already hit 4 times.*" "watchpoint hit count is 4" 170 171 # Continue until the next change, from 3 to 4. 172 # Note that this one is outside the loop. 173 174 gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = 3.*New value = 4.*ival3 = count; ival4 = count;.*" "watchpoint hit, fifth time" 175 176 # Check that the hit count is reported correctly 177 gdb_test "info break" ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+ival3\r\n\[ \t]+breakpoint already hit 5 times.*" "watchpoint hit count is 5" 178 179 # Continue until we hit the finishing marker function. 180 # Make sure we hit no more watchpoints. 181 182 gdb_test "cont" "Continuing.*Breakpoint.*marker2 \(\).*" \ 183 "continue to marker2" 184 185 # Disable the watchpoint so we run at full speed until we exit. 186 187 if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "watchpoint disabled" ] { 188 return 189 } 190 191 192 # Run until process exits. 193 194 if [target_info exists gdb,noresults] { return } 195 196 gdb_continue_to_end "continue to exit in test_simple_watchpoint" 197} 198 199# Test disabling watchpoints. 200 201proc test_disabling_watchpoints {} { 202 global gdb_prompt 203 global binfile 204 global srcfile 205 global decimal 206 global hex 207 208 gdb_test "info watch" "\[0-9]+\[ \]*.*watchpoint.*ival3.*" "watchpoints found in watchpoint/breakpoint table" 209 210 # Ensure that the watchpoint is disabled when we startup. 211 212 if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint in test_disabling_watchpoints" ] { 213 return 0 214 } 215 216 217 # Run until we get to the first marker function. 218 219 gdb_run_cmd 220 set timeout 600 221 set test "run to marker1 in test_disabling_watchpoints" 222 set retcode [gdb_test_multiple "" $test { 223 -re "Breakpoint 1, marker1 .*$gdb_prompt $" { 224 pass $test 225 } 226 }] 227 228 if { $retcode != 0 } { 229 return 230 } 231 232 # After reaching the marker function, enable the watchpoint. 233 234 if [gdb_test "enable 3" "^enable 3\[\r\n\]+" "watchpoint enabled" ] { 235 return 236 } 237 238 239 # Continue until the first change, from -1 to 0 240 # Don't check the old value, because on VxWorks the variable value 241 # will not have been reinitialized. 242 gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ival3.*Old value = .*New value = 0.*ival3 = count; ival4 = count;.*" "watchpoint hit in test_disabling_watchpoints, first time" 243 244 # Continue until the next change, from 0 to 1. 245 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" 246 247 # Disable the watchpoint but leave breakpoints 248 249 if [gdb_test "disable 3" "^disable 3\[\r\n\]+" "disable watchpoint #2 in test_disabling_watchpoints" ] { 250 return 0 251 } 252 253 254 # Check watchpoint list, looking for the entry that confirms the 255 # watchpoint is disabled. 256 gdb_test "info watchpoints" "\[0-9]+\[ \]*.*watchpoint\[ \]*keep\[ \]*n\[ \]*ival3\r\n.*" "watchpoint disabled in table" 257 258 # Continue until we hit the finishing marker function. 259 # Make sure we hit no more watchpoints. 260 gdb_test "cont" "Continuing.*Breakpoint.*marker2 \\(\\).*" \ 261 "disabled watchpoint skipped" 262 263 if [target_info exists gdb,noresults] { return } 264 265 gdb_continue_to_end "continue to exit in test_disabling_watchpoints" 266} 267 268# Test stepping and other mundane operations with watchpoints enabled 269proc test_stepping {} { 270 global gdb_prompt 271 272 if [runto marker1] then { 273 gdb_test "watch ival2" ".*\[Ww\]atchpoint \[0-9\]*: ival2" 274 275 # Well, let's not be too mundane. It should be a *bit* of a challenge 276 gdb_test "break func2 if 0" "Breakpoint.*at.*" 277 gdb_test "p \$func2_breakpoint_number = \$bpnum" " = .*" 278 279 gdb_test "p func1 ()" "= 73" \ 280 "calling function with watchpoint enabled" 281 282 # 283 # "finish" brings us back to main. 284 # On some targets (e.g. alpha) gdb will stop from the finish in midline 285 # of the marker1 call. This is due to register restoring code on 286 # the alpha and might be caused by stack adjustment instructions 287 # on other targets. In this case we will step once more. 288 # 289 290 send_gdb "finish\n" 291 gdb_expect { 292 -re "Run.*exit from.*marker1.* at" { 293 pass "finish from marker1" 294 } 295 default { fail "finish from marker1 (timeout)" ; return } 296 } 297 298 gdb_expect { 299 -re "marker1 \\(\\);.*$gdb_prompt $" { 300 send_gdb "step\n" 301 exp_continue 302 } 303 -re "func1 \\(\\);.*$gdb_prompt $" { 304 pass "back at main from marker1" 305 } 306 -re ".*$gdb_prompt $" { 307 fail "back at main from marker1" 308 } 309 default { fail "back at main from marker1 (timeout)" ; return } 310 } 311 312 gdb_test "next" "for \\(count = 0.*" "next to `for' in watchpoint.exp" 313 314 # Now test that "until" works. It's a bit tricky to test 315 # "until", because compilers don't always arrange the code 316 # exactly the same way, and we might get slightly different 317 # sequences of statements. But the following should be true 318 # (if not it is a compiler or a debugger bug): The user who 319 # does "until" at every statement of a loop should end up 320 # stepping through the loop once, and the debugger should not 321 # stop for any of the remaining iterations. 322 323 gdb_test "until" "ival1 = count.*" "until to ival1 assignment" 324 gdb_test "until" "ival3 = count.*" "until to ival3 assignment" 325 set test "until out of loop" 326 gdb_test_multiple "until" $test { 327 -re "(for \\(count = 0|\}).*$gdb_prompt $" { 328 gdb_test "until" "ival1 = count; /. Outside loop ./" $test 329 } 330 -re "ival1 = count; /. Outside loop ./.*$gdb_prompt $" { 331 pass $test 332 } 333 } 334 335 gdb_test "step" "ival2 = count.*" "step to ival2 assignment" 336 } 337} 338 339# Test stepping and other mundane operations with watchpoints enabled 340proc test_watchpoint_triggered_in_syscall {} { 341 global gdb_prompt 342 343 # These tests won't work without printf support. 344 if [gdb_skip_stdio_test "watchpoints triggered in syscall"] { 345 return 346 } 347 # Run until we get to the first marker function. 348 set x 0 349 set y 0 350 set testname "watch buffer passed to read syscall" 351 if [runto marker2] then { 352 gdb_test "watch buf\[0\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[0\\\]" 353 gdb_test "watch buf\[1\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[1\\\]" 354 gdb_test "watch buf\[2\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[2\\\]" 355 gdb_test "watch buf\[3\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[3\\\]" 356 gdb_test "watch buf\[4\]" ".*\[Ww\]atchpoint \[0-9\]*: buf\\\[4\\\]" 357 gdb_test "break marker4" ".*Breakpoint.*" 358 359 gdb_test_no_output "set doread = 1" 360 361 # If we send gdb "123\n" before gdb has switched the tty, then it goes 362 # to gdb, not the inferior, and we lose. So that is why we have 363 # watchpoint.c prompt us, so we can wait for that prompt. 364 365 send_gdb "continue\n" 366 gdb_expect { 367 -re "Continuing\\.\r\ntype stuff for buf now:" { 368 pass "continue to read" 369 } 370 default { 371 fail "continue to read" 372 return 373 } 374 } 375 376 set test "sent 123" 377 gdb_test_multiple "123" $test { 378 -re ".*\[Ww\]atchpoint.*buf\\\[0\\\].*Old value = 0.*New value = 49\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } 379 -re ".*\[Ww\]atchpoint.*buf\\\[1\\\].*Old value = 0.*New value = 50\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } 380 -re ".*\[Ww\]atchpoint.*buf\\\[2\\\].*Old value = 0.*New value = 51\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } 381 -re ".*\[Ww\]atchpoint.*buf\\\[3\\\].*Old value = 0.*New value = 10\[^\n\]*\n" { set x [expr $x+1] ; exp_continue } 382 -re ".*$gdb_prompt $" { pass $test } 383 } 384 385 # Examine the values in buf to see how many watchpoints we 386 # should have printed. 387 set test "print buf\[0\]" 388 gdb_test_multiple $test $test { 389 -re ".*= 49.*$gdb_prompt $" { set y [expr $y+1]; pass $test } 390 -re ".*= 0.*$gdb_prompt $" { $test } 391 } 392 set test "print buf\[1\]" 393 gdb_test_multiple $test $test { 394 -re ".*= 50.*$gdb_prompt $" { set y [expr $y+1]; pass $test } 395 -re ".*= 0.*$gdb_prompt $" { pass $test } 396 } 397 set test "print buf\[2\]" 398 gdb_test_multiple $test $test { 399 -re ".*= 51.*$gdb_prompt $" { set y [expr $y+1]; pass $test } 400 -re ".*= 0.*$gdb_prompt $" { pass $test } 401 } 402 set test "print buf\[3\]" 403 gdb_test_multiple $test $test { 404 -re ".*= 10.*$gdb_prompt $" { set y [expr $y+1]; pass $test } 405 -re ".*= 0.*$gdb_prompt $" { pass $test } 406 } 407 408 # Did we find what we were looking for? If not, flunk it. 409 if [expr $x==$y] then { pass $testname } else { fail "$testname (only triggered $x watchpoints, expected $y)"} 410 411 # Continue until we hit the finishing marker function. 412 # Make sure we hit no more watchpoints. 413 gdb_test "cont" "Continuing.*Breakpoint.*marker4 \\(\\).*" \ 414 "continue to marker4" 415 416 # Disable everything so we can finish the program at full speed 417 gdb_test_no_output "disable" "disable in test_watchpoint_triggered_in_syscall" 418 419 if [target_info exists gdb,noresults] { return } 420 421 gdb_continue_to_end "continue to exit in test_watchpoint_triggered_in_syscall" 422 } 423} 424 425# Do a simple test of of watching through a pointer when the pointer 426# itself changes. Should add some more complicated stuff here. 427 428proc test_complex_watchpoint {} { 429 global gdb_prompt 430 431 if [runto marker4] then { 432 gdb_test "watch ptr1->val" ".*\[Ww\]atchpoint \[0-9\]*: ptr1->val" 433 gdb_test "break marker5" ".*Breakpoint.*" 434 435 gdb_test "cont" "Continuing.*\[Ww\]atchpoint.*ptr1->val.*Old value = 1.*New value = 2.*" "test complex watchpoint" 436 437 # Continue until we hit the marker5 function. 438 # Make sure we hit no more watchpoints. 439 440 gdb_test "cont" "Continuing.*Breakpoint.*marker5 \\(\\).*" \ 441 "did not trigger wrong watchpoint" 442 443 # Test watches of things declared locally in a function. 444 # In particular, test that a watch of stack-based things 445 # is deleted when the stack-based things go out of scope. 446 # 447 gdb_test_no_output "disable" "disable in test_complex_watchpoint" 448 gdb_test "break marker6" ".*Breakpoint.*" 449 gdb_test "cont" "Continuing.*Breakpoint.*marker6 \\(\\).*" \ 450 "continue to marker6" 451 gdb_breakpoint [gdb_get_line_number "func2 breakpoint here"] 452 gdb_continue_to_breakpoint "func2 breakpoint here" 453 454 # Test a watch of a single stack-based variable, whose scope 455 # is the function we're now in. This should auto-delete when 456 # execution exits the scope of the watchpoint. 457 # 458 gdb_test "watch local_a" ".*\[Ww\]atchpoint \[0-9\]*: local_a" "set local watch" 459 gdb_test "cont" "\[Ww\]atchpoint.*local_a.*" "trigger local watch" 460 461 set test "self-delete local watch" 462 gdb_test_multiple "cont" $test { 463 -re "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*\r\n$gdb_prompt $" { 464 pass $test 465 } 466 -re "can't compute CFA for this frame.*\r\n$gdb_prompt $" { 467 global no_hw 468 469 # GCC < 4.5.0 does not get LOCATIONS_VALID set by dwarf2read.c. 470 # Therefore epilogue unwinder gets applied which is 471 # incompatible with dwarf2_frame_cfa. 472 if {$no_hw && ([test_compiler_info {gcc-[0-3]-*}] 473 || [test_compiler_info {gcc-4-[0-4]-*}])} { 474 xfail "$test (old GCC has broken watchpoints in epilogues)" 475 return 476 } 477 fail $test 478 } 479 } 480 481 gdb_continue_to_breakpoint "func2 breakpoint here" 482 # We should be in "func2" again now. Test a watch of an 483 # expression which includes both a stack-based local and 484 # something whose scope is larger than this invocation 485 # of "func2". This should also auto-delete. 486 # 487 gdb_test "watch local_a + ival5" ".*\[Ww\]atchpoint \[0-9\]*: local_a . ival5" \ 488 "set partially local watch" 489 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_a . ival5.*" \ 490 "trigger1 partially local watch" 491 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_a . ival5.*" \ 492 "trigger2 partially local watch" 493 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \ 494 "self-delete partially local watch" 495 496 # We should be in "func2" again now. Test a watch of a 497 # static (non-stack-based) local. Since this has scope 498 # across any invocations of "func2", it should not auto- 499 # delete. 500 # 501 gdb_continue_to_breakpoint "func2 breakpoint here" 502 gdb_test "watch static_b" ".*\[Ww\]atchpoint \[0-9\]*: static_b" \ 503 "set static local watch" 504 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: static_b.*" \ 505 "trigger static local watch" 506 gdb_test "cont" "Continuing.*marker6 \\(\\).*" \ 507 "continue after trigger static local watch" 508 gdb_test "info break" ".*watchpoint.*static_b.*" \ 509 "static local watch did not self-delete" 510 511 # We should be in "recurser" now. Test a watch of a stack- 512 # based local. Symbols mentioned in a watchpoint are bound 513 # at watchpoint-creation. Thus, a watch of a stack-based 514 # local to a recursing function should be bound only to that 515 # one invocation, and should not trigger for other invocations. 516 # 517 gdb_test "tbreak recurser" ".*breakpoint.*" 518 gdb_test "cont" "Continuing.*recurser.*" 519 gdb_test "next" "if \\(x > 0.*" "next past local_x initialization" 520 gdb_test "watch local_x" ".*\[Ww\]atchpoint \[0-9\]*: local_x" \ 521 "set local watch in recursive call" 522 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: local_x.*New value = 2.*" \ 523 "trigger local watch in recursive call" 524 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \ 525 "self-delete local watch in recursive call" 526 527 # Repeat the preceding test, but this time use "recurser::local_x" as 528 # the variable to track. 529 gdb_test "cont" "Continuing.*marker6.*" 530 gdb_test "tbreak recurser" ".*breakpoint.*" 531 gdb_test "cont" "Continuing.*recurser.*" 532 gdb_test "next" "if \\(x > 0.*" "next past local_x initialization" 533 gdb_test "watch recurser::local_x" ".*\[Ww\]atchpoint \[0-9\]*: recurser::local_x" \ 534 "set local watch in recursive call with explicit scope" 535 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .*: recurser::local_x.*New value = 2.*" \ 536 "trigger local watch with explicit scope in recursive call" 537 gdb_test "cont" "Continuing.*\[Ww\]atchpoint .* deleted because the program has left the block in.*which its expression is valid.*" \ 538 "self-delete local watch with explicit scope in recursive call (2)" 539 540 # Disable everything so we can finish the program at full speed 541 gdb_test_no_output "disable" "disable in test_complex_watchpoint" 542 543 if [target_info exists gdb,noresults] { return } 544 545 gdb_continue_to_end "continue to exit in test_complex_watchpoint" 546 } 547} 548 549proc test_watchpoint_and_breakpoint {} { 550 global gdb_prompt 551 552 # This is a test for PR breakpoints/7143, which involves setting a 553 # watchpoint right after you've reached a breakpoint. 554 555 if [runto func3] then { 556 gdb_breakpoint [gdb_get_line_number "second x assignment"] 557 gdb_continue_to_breakpoint "second x assignment" 558 gdb_test "watch x" ".*atchpoint \[0-9\]+: x" 559 gdb_test "next" \ 560 ".*atchpoint \[0-9\]+: x\r\n\r\nOld value = 0\r\nNew value = 1\r\n.*" \ 561 "next after watch x" 562 563 gdb_test_no_output "delete \$bpnum" "delete watch x" 564 } 565} 566 567proc test_constant_watchpoint {} { 568 gdb_test "watch 5" "Cannot watch constant value `5'." "number is constant" 569 gdb_test "watch (int *)5" "Cannot watch constant value `\\(int \\*\\)5'." \ 570 "number with cast is constant" 571 gdb_test "watch marker1" "Cannot watch constant value `marker1'." \ 572 "marker1 is constant" 573 gdb_test "watch count + 6" ".*atchpoint \[0-9\]+: count \\+ 6" 574 gdb_test_no_output "delete \$bpnum" "delete watchpoint `count + 6'" 575 gdb_test "watch 7 + count" ".*atchpoint \[0-9\]+: 7 \\+ count" 576 gdb_test_no_output "delete \$bpnum" "delete watchpoint `7 + count'" 577} 578 579proc test_disable_enable_software_watchpoint {} { 580 # This is regression test for a bug that caused `enable' to fail 581 # for software watchpoints. 582 583 # Watch something not memory to force a software watchpoint. 584 gdb_test {watch $pc} ".*atchpoint \[0-9\]+: .pc" 585 586 gdb_test_no_output "disable \$bpnum" "disable watchpoint `\$pc'" 587 gdb_test_no_output "enable \$bpnum" "reenable watchpoint `\$pc'" 588 589 gdb_test "info watchpoint \$bpnum" \ 590 ".*watchpoint\[ \t\]+keep\[ \t\]+y\[ \t\]+.pc.*" \ 591 "watchpoint `\$pc' is enabled" 592 593 gdb_test_no_output "delete \$bpnum" "delete watchpoint `\$pc'" 594} 595 596proc test_watch_location {} { 597 global gdb_prompt 598 599 gdb_breakpoint [gdb_get_line_number "func5 breakpoint here"] 600 gdb_continue_to_breakpoint "func5 breakpoint here" 601 602 # Check first if a null pointer can be dereferenced on the target. 603 gdb_test_multiple "p *nullptr" "" { 604 -re "Cannot access memory at address 0x0.*$gdb_prompt $" { 605 gdb_test "watch -location nullptr->p->x" \ 606 "Cannot access memory at address 0x0" 607 } 608 -re ".*$gdb_prompt $" { 609 # Null pointer dereference is legitimate. 610 } 611 } 612 613 gdb_test "watch -location *x" "atchpoint .*: .*" "watch -location .x" 614 615 gdb_test "continue" \ 616 "Continuing.*\[Ww\]atchpoint .*: .*New value = 27.*" \ 617 "continue with watch -location" 618 619 gdb_test_no_output "delete \$bpnum" "delete watch -location" 620} 621 622# Tests watching areas larger than a word. 623 624proc test_wide_location_1 {} { 625 global no_hw 626 global gdb_prompt 627 628 # This test watches two words on most 32-bit ABIs, and one word on 629 # most 64-bit ABIs. 630 631 # Platforms where the target can't watch such a large region 632 # should clear hw_expected below. 633 if { $no_hw || [target_info exists gdb,no_hardware_watchpoints] 634 || [istarget arm*-*-*] 635 || ([istarget powerpc*-*-*] && ![is_lp64_target])} { 636 set hw_expected 0 637 } else { 638 set hw_expected 1 639 } 640 641 gdb_breakpoint [gdb_get_line_number "func6 breakpoint here"] 642 gdb_continue_to_breakpoint "func6 breakpoint here" 643 644 if { $hw_expected } { 645 gdb_test "watch foo2" "Hardware watchpoint .*: .*" "watch foo2" 646 gdb_test "continue" \ 647 "Continuing.*Hardware watchpoint .*: .*New value = \\\{val = \\\{0, 11\\\}\\\}.*" \ 648 "continue with watch foo2" 649 } else { 650 gdb_test "watch foo2" "atchpoint .*: .*" "watch foo2" 651 set test "continue with watch foo2" 652 gdb_test_multiple "cont" $test { 653 -re "Continuing.*\[Ww\]atchpoint .*: .*New value = \\\{val = \\\{0, 11\\\}\\\}.*$gdb_prompt $" { 654 pass $test 655 } 656 -re "Could not insert hardware breakpoints:.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" { 657 # This may happen with remote targets that support 658 # hardware watchpoints. We only find out the 659 # watchpoint was too large, for example, at insert 660 # time. If GDB is ever adjusted to downgrade the 661 # watchpoint automatically in this case, this match 662 # should be removed. 663 pass $test 664 } 665 } 666 } 667 668 gdb_test_no_output "delete \$bpnum" "delete watch foo2" 669} 670 671proc test_wide_location_2 {} { 672 global no_hw 673 global gdb_prompt 674 675 # This test watches four words on most 32-bit ABIs, and two words 676 # on 64-bit ABIs. 677 678 # Platforms where the target can't watch such a large region 679 # should clear hw_expected below. 680 if { $no_hw || [target_info exists gdb,no_hardware_watchpoints] 681 || [istarget arm*-*-*] 682 || [istarget powerpc*-*-*]} { 683 set hw_expected 0 684 } else { 685 set hw_expected 1 686 } 687 688 gdb_breakpoint [gdb_get_line_number "func7 breakpoint here"] 689 gdb_continue_to_breakpoint "func7 breakpoint here" 690 691 if { $hw_expected } { 692 gdb_test "watch foo4" "Hardware watchpoint .*: .*" "watch foo4" 693 gdb_test "continue" \ 694 "Continuing.*Hardware watchpoint .*: .*New value = \\\{val = \\\{0, 0, 0, 33\\\}\\\}.*" \ 695 "continue with watch foo4" 696 } else { 697 gdb_test "watch foo4" "atchpoint .*: .*" "watch foo4" 698 set test "continue with watch foo4" 699 gdb_test_multiple "cont" $test { 700 -re "Continuing.*\[Ww\]atchpoint .*: .*New value = \\\{val = \\\{0, 0, 0, 33\\\}\\\}.*$gdb_prompt $" { 701 pass $test 702 } 703 -re "Could not insert hardware breakpoints:.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" { 704 # This may happen with remote targets that support 705 # hardware watchpoints. We only find out the 706 # watchpoint was too large, for example, at insert 707 # time. If GDB is ever adjusted to downgrade the 708 # watchpoint automatically in this case, this match 709 # should be removed. 710 pass $test 711 } 712 } 713 } 714 715 gdb_test_no_output "delete \$bpnum" "delete watch foo4" 716} 717 718proc test_inaccessible_watchpoint {} { 719 global gdb_prompt 720 721 # This is a test for watchpoints on currently inaccessible (but later 722 # valid) memory. 723 724 if [runto func4] then { 725 # Make sure we only allow memory access errors. 726 set msg "watchpoint refused to insert on nonexistent struct member" 727 gdb_test_multiple "watch struct1.nosuchmember" $msg { 728 -re ".*atchpoint \[0-9\]+: struct1.nosuchmember.*$gdb_prompt $" { 729 # PR breakpoints/9681 730 fail $msg 731 } 732 -re "There is no member named nosuchmember\\..*$gdb_prompt $" { 733 pass $msg 734 } 735 } 736 737 # See whether a watchpoint on a normal variable is a hardware 738 # watchpoint or not. The watchpoints on NULL should be hardware 739 # iff this one is. 740 set watchpoint_msg "Watchpoint" 741 gdb_test_multiple "watch global_ptr" "watch global_ptr" { 742 -re "Watchpoint \[0-9\]+: global_ptr\r\n.*$gdb_prompt $" { 743 pass "watch global_ptr" 744 } 745 -re "Hardware watchpoint \[0-9\]+: global_ptr\r\n.*$gdb_prompt $" { 746 set watchpoint_msg "Hardware watchpoint" 747 pass "watch global_ptr" 748 } 749 } 750 delete_breakpoints 751 752 # Make sure that we can watch a constant address, and correctly 753 # use a HW watchpoint if supported. 754 gdb_test "watch *(int *) 0" \ 755 "$watchpoint_msg \[0-9\]+: \\*\\(int \\*\\) 0" 756 delete_breakpoints 757 758 # The same, but using -location through an indirection. 759 gdb_test "watch -location *global_ptr" \ 760 "$watchpoint_msg \[0-9\]+: \-location \\*global_ptr" 761 delete_breakpoints 762 763 # This step requires two HW watchpoints. Since some platforms only 764 # have a single one, accept either SW or HW watchpoint in this case. 765 if {[skip_hw_watchpoint_multi_tests]} { 766 set watchpoint_msg "(Watchpoint|Hardware watchpoint)" 767 } 768 769 gdb_test "watch *global_ptr" "$watchpoint_msg \[0-9\]+: \\\*global_ptr" 770 gdb_test "set \$global_ptr_breakpoint_number = \$bpnum" "" 771 gdb_test "next" ".*global_ptr = buf.*" "global_ptr next" 772 gdb_test_multiple "next" "next over ptr init" { 773 -re ".*atchpoint \[0-9\]+: \\*global_ptr\r\n\r\nOld value = .*\r\nNew value = 3 .*\r\n.*$gdb_prompt $" { 774 # We can not test for <unknown> here because NULL may be readable. 775 # This test does rely on *NULL != 3. 776 pass "next over ptr init" 777 } 778 } 779 gdb_test_multiple "next" "next over buffer set" { 780 -re ".*atchpoint \[0-9\]+: \\*global_ptr\r\n\r\nOld value = 3 .*\r\nNew value = 7 .*\r\n.*$gdb_prompt $" { 781 pass "next over buffer set" 782 } 783 } 784 gdb_test "delete \$global_ptr_breakpoint_number" "" 785 gdb_test "watch **global_ptr_ptr" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr" 786 gdb_test "set \$global_ptr_ptr_breakpoint_number = \$bpnum" "" 787 gdb_test "next" ".*global_ptr_ptr = &global_ptr.*" "global_ptr_ptr next" 788 gdb_test "next" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\[\r\n\]+Old value = .*\r\nNew value = 7 .*" "next over global_ptr_ptr init" 789 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" 790 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" 791 gdb_test_no_output "delete \$global_ptr_ptr_breakpoint_number" 792 } 793} 794 795proc test_no_hw_watchpoints {} { 796 global testfile 797 798 clean_restart $testfile 799 800 # Verify that a user can force GDB to use "slow" watchpoints. 801 # (This proves rather little on kernels that don't support 802 # fast watchpoints, but still...) 803 # 804 if ![runto_main] then { fail "watch tests suppressed" } 805 806 gdb_test_no_output "set can-use-hw-watchpoints 0" "disable fast watches" 807 808 gdb_test "show can-use-hw-watchpoints" \ 809 "Debugger's willingness to use watchpoint hardware is 0." \ 810 "show disable fast watches" 811 812 gdb_test "watch ival3 if count > 1" \ 813 "Watchpoint \[0-9\]*: ival3.*" \ 814 "set slow conditional watch" 815 816 gdb_test "continue" \ 817 "Watchpoint \[0-9\]*: ival3.*Old value = 1.*New value = 2.*" \ 818 "trigger slow conditional watch" 819 820 gdb_test_no_output "delete \$bpnum" "delete watch ival3" 821 822 gdb_test "watch ival3 if count > 1 thread 1 " \ 823 "Watchpoint \[0-9\]*: ival3.*" \ 824 "set slow condition watch w/thread" 825 826 gdb_test_no_output "delete \$bpnum" "delete watch w/condition and thread" 827 828 # We've explicitly disabled hardware watches. Verify that GDB 829 # refrains from using them. 830 # 831 gdb_test "rwatch ival3" \ 832 "Can't set read/access watchpoint when hardware watchpoints are disabled." \ 833 "rwatch disallowed when can-set-hw-watchpoints cleared" 834 gdb_test "awatch ival3" \ 835 "Can't set read/access watchpoint when hardware watchpoints are disabled." \ 836 "awatch disallowed when can-set-hw-watchpoints cleared" 837 838 839 # Re-enable hardware watchpoints if necessary. 840 if ![target_info exists gdb,no_hardware_watchpoints] { 841 gdb_test_no_output "set can-use-hw-watchpoints 1" "" 842 } 843} 844 845proc test_watchpoint_in_big_blob {} { 846 global gdb_prompt 847 848 # On native targets where we do hardware resource accounting, this 849 # may end up as a software watchpoint. 850 set ok 0 851 set test "watch buf" 852 gdb_test_multiple "watch buf" $test { 853 -re "Hardware watchpoint \[0-9\]+: buf.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" { 854 # This may happen with remote targets (where we don't do 855 # resource accounting) that support hardware watchpoints, 856 # when breakpoint always-inserted is on. The watchpoint 857 # was too large, for example. If GDB is ever adjusted to 858 # downgrade the watchpoint automatically in this case, 859 # this match should be removed. Note the breakpoint has 860 # been created, and is in the list, so it needs deleting. 861 pass $test 862 } 863 -re ".*atchpoint \[0-9\]+: buf.*$gdb_prompt $" { 864 pass $test 865 set ok 1 866 } 867 } 868 869 if { $ok } { 870 set test "watchpoint on buf hit" 871 gdb_test_multiple "cont" $test { 872 -re "Continuing.*atchpoint \[0-9\]+: buf\r\n\r\nOld value = .*testte\".*$gdb_prompt $" { 873 pass $test 874 } 875 -re "Could not insert hardware breakpoints:.*You may have requested too many hardware breakpoints/watchpoints.*$gdb_prompt $" { 876 # This may happen with remote targets that support 877 # hardware watchpoints. We only find out the 878 # watchpoint was too large, for example, at insert 879 # time. If GDB is ever adjusted to downgrade the 880 # watchpoint automatically in this case, this match 881 # should be removed. 882 pass $test 883 } 884 } 885 } 886 887 gdb_test_no_output "delete \$bpnum" "delete watch buf" 888} 889 890proc test_watch_register_location {} { 891 global no_hw 892 893 if {!$no_hw && ![target_info exists gdb,no_hardware_watchpoints]} { 894 # Non-memory read/access watchpoints are not supported, they would 895 # require software read/access watchpoint support (which is not 896 # currently available). 897 gdb_test "rwatch \$pc" \ 898 "Expression cannot be implemented with read/access watchpoint..*" \ 899 "rwatch disallowed for register based expression" 900 gdb_test "awatch \$pc" \ 901 "Expression cannot be implemented with read/access watchpoint..*" \ 902 "awatch disallowed for register based expression" 903 } 904} 905 906# Start with a fresh gdb. 907 908set prev_timeout $timeout 909set timeout 600 910verbose "Timeout now 600 sec.\n" 911 912test_no_hw_watchpoints 913 914proc do_tests {} { 915 global testfile 916 global no_hw 917 918 clean_restart $testfile 919 920 if {$no_hw || [target_info exists gdb,no_hardware_watchpoints]} { 921 gdb_test_no_output "set can-use-hw-watchpoints 0" "" 922 } 923 924 if [initialize] then { 925 926 test_simple_watchpoint 927 928 test_disabling_watchpoints 929 930 if ![target_info exists gdb,cannot_call_functions] { 931 test_stepping 932 } 933 } 934 935 # Tests below don't rely on the markers and watchpoint set by 936 # `initialize' anymore. 937 clean_restart $testfile 938 939 if {$no_hw || [target_info exists gdb,no_hardware_watchpoints]} { 940 gdb_test_no_output "set can-use-hw-watchpoints 0" "" 941 } 942 943 # Only enabled for some targets merely because it has not been tested 944 # elsewhere. 945 # On sparc-sun-sunos4.1.3, GDB was running all the way to the marker4 946 # breakpoint before stopping for the watchpoint. I don't know why. 947 if {[istarget "hppa*-*-*"]} then { 948 test_watchpoint_triggered_in_syscall 949 } 950 951 test_complex_watchpoint 952 953 test_inaccessible_watchpoint 954 955 test_watchpoint_and_breakpoint 956 957 test_watchpoint_in_big_blob 958 959 test_constant_watchpoint 960 961 test_disable_enable_software_watchpoint 962 963 test_watch_location 964 965 test_wide_location_1 966 test_wide_location_2 967 968 test_watch_register_location 969} 970 971# On targets that can do hardware watchpoints, run the tests twice: 972# once with hardware watchpoints enabled; another with hardware 973# watchpoints force-disabled. 974 975do_tests 976if ![target_info exists gdb,no_hardware_watchpoints] { 977 with_test_prefix "no-hw" { 978 set no_hw 1 979 do_tests 980 } 981} 982 983# Restore old timeout 984set timeout $prev_timeout 985verbose "Timeout now $timeout sec.\n" 986