projects / deliverable / binutils-gdb.git / blame
| Commit | Line | Data |
|---|---|---|
| c906108c SS |
1 | # quicksort.exp -- Expect script to test gdb with quicksort.c |
| 2 | # Copyright (C) 1992 Free Software Foundation, Inc. | |
| 3 | ||
| 4 | # This program is free software; you can redistribute it and/or modify | |
| 5 | # it under the terms of the GNU General Public License as published by | |
| 6 | # the Free Software Foundation; either version 2 of the License, or | |
| 7 | # (at your option) any later version. | |
| 8 | # | |
| 9 | # This program is distributed in the hope that it will be useful, | |
| 10 | # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 11 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 12 | # GNU General Public License for more details. | |
| 13 | # | |
| 14 | # You should have received a copy of the GNU General Public License | |
| 15 | # along with this program; if not, write to the Free Software | |
| 16 | # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
| 17 | ||
| 18 | # Please email any bugs, comments, and/or additions to this file to: | |
| 19 | # bug-gdb@prep.ai.mit.edu | |
| 20 | ||
| 21 | # use this to debug: | |
| 22 | # | |
| 23 | #log_user 1 | |
| 24 | ||
| 25 | if $tracelevel then { | |
| 26 | strace $tracelevel | |
| 27 | } | |
| 28 | ||
| 29 | if { ![istarget "hppa*-*-hpux10.30"] && ![istarget "hppa*-*-hpux11.*"] } { | |
| 30 | verbose "HPUX thread test ignored for non-hppa or pre-HP/UX-10.30 targets." | |
| 31 | return 0 | |
| 32 | } | |
| 33 | ||
| 34 | set testfile quicksort | |
| 35 | set srcfile ${srcdir}/${subdir}/${testfile}.c | |
| 36 | set binfile ${objdir}/${subdir}/${testfile} | |
| 37 | ||
| 38 | if [get_compiler_info ${binfile}] { | |
| 39 | return -1 | |
| 40 | } | |
| 41 | ||
| 42 | # To build the executable we need to link against the thread library. | |
| 43 | # | |
| 44 | # cc -Ae -g -o quicksort -lpthread quicksort.c | |
| 45 | # | |
| 46 | #compile "${srcfile} -Ae -g -lpthread -o ${binfile}" | |
| 47 | ||
| 48 | if {$gcc_compiled == 0} { | |
| 49 | set additional_flags "additional_flags=-Ae" | |
| 50 | } else { | |
| 51 | set additional_flags "" | |
| 52 | } | |
| 53 | ||
| 54 | if { [gdb_compile "${srcdir}/${subdir}/${testfile}.c" "${binfile}.o" object [list debug $additional_flags]] != "" } { | |
| 55 | gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail." | |
| 56 | } | |
| 57 | remote_exec build "ld /usr/ccs/lib/crt0.o ${binfile}.o -lcl -lpthread -lc /opt/langtools/lib/end.o -o ${binfile}" | |
| 58 | ||
| 59 | ||
| 60 | # Thread stuff is _slow_; prepare for long waits. | |
| 61 | # | |
| 62 | set oldtimeout $timeout | |
| 63 | set timeout [expr "$timeout + 300"] | |
| 64 | set oldverbose $verbose | |
| 65 | #set verbose 40 | |
| 66 | ||
| 67 | # Further, this test has some "null" lines designed | |
| 68 | # to consume output from gdb that was too late to be | |
| 69 | # matched (sequence is "gdb_test" sends; timeout and | |
| 70 | # on to next send; result finally comes in; mismatch). | |
| 71 | # | |
| 72 | # The null command is 'gdb_test "p \$pc" ".*" ""' | |
| 73 | # | |
| 74 | # NOTE: to pass a literal "$", "/" or "*" (etc.) to gdb_test, | |
| 75 | # remember that the pattern will be escaped once and | |
| 76 | # $-evaluated twice: | |
| 77 | # | |
| 78 | # "\\\*" matches "\*" | |
| 79 | # "\$" matches "$" | |
| 80 | # | |
| 81 | proc fix_timeout {} { | |
| 82 | gdb_test "p \$pc" ".*" "" | |
| 83 | } | |
| 84 | ||
| 85 | #========================= | |
| 86 | # | |
| 87 | # Simple sanity test first. | |
| 88 | # | |
| 89 | gdb_exit | |
| 90 | gdb_start | |
| 91 | gdb_reinitialize_dir $srcdir/$subdir | |
| 92 | gdb_load ${binfile} | |
| 93 | ||
| 94 | gdb_test "tb 122" ".*Breakpoint.*" "" | |
| 95 | gdb_test "r" ".*122.*" "" | |
| 96 | gdb_test "thr 99" ".*Thread ID 99 not known.*" "Check too-big thread number" | |
| 97 | gdb_test "tb 145 thr 3" ".*Breakpoint.*" "set thread-specific bp 145" | |
| 98 | gdb_test "tb 146 thr 4" ".*Breakpoint.*" "set thread-specific bp 146" | |
| 99 | gdb_test "c" ".*Switched to thread.*145.*" "auto switch" | |
| 100 | gdb_test "c" ".*Switched to thread.*146.*" "auto switch 2" | |
| 101 | gdb_test "c" ".*Program exited normally.*" "" | |
| 102 | ||
| 103 | #========================= | |
| 104 | # | |
| 105 | # Test that you can't do a thread select after a program runs. | |
| 106 | # | |
| 107 | gdb_test "thread" ".*No stack.*" "No live thread after run" | |
| 108 | gdb_test "thr 2" ".*No stack.*" "Can't set thread after run" | |
| 109 | ||
| 110 | #========================= | |
| 111 | # | |
| 112 | # Test thread command changes, look for frame level reset bug. | |
| 113 | # | |
| 114 | gdb_exit | |
| 115 | gdb_start | |
| 116 | gdb_reinitialize_dir $srcdir/$subdir | |
| 117 | gdb_load ${binfile} | |
| 118 | gdb_test "b 122" ".*" "" | |
| 119 | gdb_test "r" ".*122.*" "" | |
| 120 | ||
| 121 | # Prep for frame level test--go up/info thread/check frame | |
| 122 | # | |
| 123 | gdb_test "up" ".*quick_sort.*" "" | |
| 124 | gdb_test "up" ".*main.*" "" | |
| 125 | ||
| 126 | send_gdb "i th\n" | |
| 127 | gdb_expect { | |
| 128 | -re ".*7 thread.* in .* from .* in .* from .* 6 thread.*$gdb_prompt $" { | |
| 129 | fail "old thread command, says things twice" | |
| 130 | } | |
| 131 | -re ".*7 system thread.*6 system th.*5 sys.*4.*3.*2.*1.*work_init.*$gdb_prompt $" { | |
| 132 | pass "info threads" | |
| 133 | } | |
| 134 | -re ".*$gdb_prompt $" { fail "no info thread command" } | |
| 135 | timeout { fail "timeout" } | |
| 136 | } | |
| 137 | ||
| 138 | # We should have been restored two frames up--check. | |
| 139 | # | |
| 140 | send_gdb "up\n" | |
| 141 | gdb_expect { | |
| 142 | -re ".*Initial frame selected.*$gdb_prompt $" { | |
| 143 | pass "Frame correctly reset after 'info threads'" | |
| 144 | } | |
| 145 | -re ".*quick_sort.*$gdb_prompt $" { | |
| 146 | fail "Old gdb bug; should be fixed someday" | |
| 147 | } | |
| 148 | -re ".*$gdb_prompt $" { | |
| 149 | fail "real bug--FIX!" | |
| 150 | } | |
| 151 | timeout { fail "timeout" } | |
| 152 | } | |
| 153 | ||
| 154 | # Do it again, only just go to a middle frame, and use another thread. | |
| 155 | # | |
| 156 | gdb_test "thr 5" ".*" "" | |
| 157 | gdb_test "bt" ".* ___ksleep.*_lwp_cond_timedwait.*pthread_cond_wait.*worker.*__pthread_create_system.*" "" | |
| 158 | gdb_test "up" ".*1.*_lwp_cond_timedwait.*" "" | |
| 159 | gdb_test "up" ".*2.*pthread_cond_wait.*" "" | |
| 160 | gdb_test "up" ".*3.*worker.*" "" | |
| 161 | gdb_test "i th" ".*7.*6.*work_init.*" "" | |
| 162 | gdb_test "f" ".*3.*worker.*" "Frame restored" | |
| 163 | gdb_test "p wp->max_pile" ".*= 128.*" "can see vars in frame" | |
| 164 | ||
| 165 | # Thread command changes | |
| 166 | # | |
| 167 | gdb_test "thr" ".*Current thread is 5.*" "threads-no-num" | |
| 168 | gdb_test "thr 6" ".*Switching to thread 6.*" "new switch" | |
| 169 | gdb_test "thr" ".*Current thread is 6.*" "check switch" | |
| 170 | #gdb_test "thr 6" ".*Current thread is already 6.*" "dup, no switch" | |
| 171 | gdb_test "thr app all p x" ".*No symbol.*" "" | |
| 172 | gdb_test "thr" ".*Current thread is 6.*" "restore current thread" | |
| 173 | ||
| 174 | #========================= | |
| 175 | # | |
| 176 | # Test new stepping | |
| 177 | # | |
| 178 | ||
| 179 | proc get_hit { } { | |
| 180 | global hit2 | |
| 181 | global hit3 | |
| 182 | global hit4 | |
| 183 | global hit5 | |
| 184 | global hit6 | |
| 185 | global hit7 | |
| 186 | global gdb_prompt | |
| 187 | ||
| 188 | send_gdb "cont\n" | |
| 189 | gdb_expect { | |
| 190 | -re ".*Breakpoint.*145.*$gdb_prompt $" { | |
| 191 | send_gdb "thr\n" | |
| 192 | gdb_expect { | |
| 193 | -re ".*is 7.*$gdb_prompt $" { | |
| 194 | set hit7 [expr "$hit7 + 1"] | |
| 195 | } | |
| 196 | -re ".*is 6.*$gdb_prompt $" { | |
| 197 | set hit6 [expr "$hit6 + 1"] | |
| 198 | } | |
| 199 | -re ".*is 5.*$gdb_prompt $" { | |
| 200 | set hit5 [expr "$hit5 + 1"] | |
| 201 | } | |
| 202 | -re ".*is 4.*$gdb_prompt $" { | |
| 203 | set hit4 [expr "$hit4 + 1"] | |
| 204 | } | |
| 205 | -re ".*is 3.*$gdb_prompt $" { | |
| 206 | set hit3 [expr "$hit3 + 1"] | |
| 207 | } | |
| 208 | -re ".*is 2.*$gdb_prompt $" { | |
| 209 | set hit2 [expr "$hit2 + 1"] | |
| 210 | } | |
| 211 | -re ".*$gdb_prompt $" { | |
| 212 | fail "can't see which thread" | |
| 213 | } | |
| 214 | timeout { fail "timeout" } | |
| 215 | } | |
| 216 | } | |
| 217 | -re ".*$gdb_prompt $" { | |
| 218 | fail "thread command" | |
| 219 | } | |
| 220 | timeout { fail "timeout" } | |
| 221 | } | |
| 222 | } | |
| 223 | ||
| 224 | gdb_exit | |
| 225 | gdb_start | |
| 226 | gdb_reinitialize_dir $srcdir/$subdir | |
| 227 | gdb_load ${binfile} | |
| 228 | gdb_test "break 122" ".*" "" | |
| 229 | gdb_test "run" ".*122.*" "" | |
| 230 | ||
| 231 | # Make sure we hit a bp on every thread. | |
| 232 | # | |
| 233 | # Try one, via thread-specific bps | |
| 234 | # | |
| 235 | gdb_test "break 145 thr 2" ".*" "set thread-specific bp thr 2" | |
| 236 | gdb_test "break 145 thr 3" ".*" "set thread-specific bp thr 3" | |
| 237 | gdb_test "break 145 thr 4" ".*" "set thread-specific bp thr 4" | |
| 238 | gdb_test "break 145 thr 5" ".*" "set thread-specific bp thr 5" | |
| 239 | gdb_test "break 145 thr 6" ".*" "set thread-specific bp thr 6" | |
| 240 | gdb_test "break 145 thr 7" ".*" "set thread-specific bp thr 7" | |
| 241 | ||
| 242 | set hit2 0 | |
| 243 | set hit3 0 | |
| 244 | set hit4 0 | |
| 245 | set hit5 0 | |
| 246 | set hit6 0 | |
| 247 | set hit7 0 | |
| 248 | ||
| 249 | get_hit | |
| 250 | get_hit | |
| 251 | get_hit | |
| 252 | get_hit | |
| 253 | get_hit | |
| 254 | get_hit | |
| 255 | ||
| 256 | if { [expr "$hit2 == 1"] | |
| 257 | && [expr "$hit3 == 1"] | |
| 258 | && [expr "$hit4 == 1"] | |
| 259 | && [expr "$hit5 == 1"] | |
| 260 | && [expr "$hit6 == 1"] | |
| 261 | && [expr "$hit7 == 1"] } { | |
| 262 | pass "thread-specific bps 1" | |
| 263 | } else { | |
| 264 | fail "thread-specific bps 1" | |
| 265 | } | |
| 266 | ||
| 267 | #==================== | |
| 268 | # | |
| 269 | # Now use generic bps | |
| 270 | # | |
| 271 | gdb_exit | |
| 272 | gdb_start | |
| 273 | gdb_reinitialize_dir $srcdir/$subdir | |
| 274 | gdb_load ${binfile} | |
| 275 | gdb_test "b 122" ".*" "" | |
| 276 | gdb_test "r" ".*122.*" "" | |
| 277 | ||
| 278 | # Make sure we hit a bp on every thread. | |
| 279 | # | |
| 280 | # Try two, via non-thread-specific bp | |
| 281 | # | |
| 282 | gdb_test "b 145" ".*" "b 145" | |
| 283 | ||
| 284 | set hit2 0 | |
| 285 | set hit3 0 | |
| 286 | set hit4 0 | |
| 287 | set hit5 0 | |
| 288 | set hit6 0 | |
| 289 | set hit7 0 | |
| 290 | ||
| 291 | get_hit | |
| 292 | get_hit | |
| 293 | get_hit | |
| 294 | get_hit | |
| 295 | get_hit | |
| 296 | get_hit | |
| 297 | ||
| 298 | if { [expr "$hit2 == 1"] | |
| 299 | && [expr "$hit3 == 1"] | |
| 300 | && [expr "$hit4 == 1"] | |
| 301 | && [expr "$hit5 == 1"] | |
| 302 | && [expr "$hit6 == 1"] | |
| 303 | && [expr "$hit7 == 1"] } { | |
| 304 | pass "thread-specific bps 2" | |
| 305 | } else { | |
| 306 | fail "thread-specific bps 2" | |
| 307 | } | |
| 308 | ||
| 309 | #==================== | |
| 310 | # | |
| 311 | # Complicated (original) test next. | |
| 312 | # | |
| 313 | gdb_exit | |
| 314 | gdb_start | |
| 315 | gdb_reinitialize_dir $srcdir/$subdir | |
| 316 | gdb_load ${binfile} | |
| 317 | ||
| 318 | if ![runto_main] then { | |
| 319 | fail "Can't run to main" | |
| 320 | return 0 | |
| 321 | } | |
| 322 | ||
| 323 | # OK, we're at "main", there should be one thread. | |
| 324 | # | |
| 325 | gdb_test "info thread" ".*\\\* 1 system thread .*main.*" "initial thread" | |
| 326 | ||
| 327 | # Try to see the threads being created: set a breakpoint | |
| 328 | # after the creation and go around the loop a few times. | |
| 329 | # | |
| 330 | gdb_test "break 109" "Breakpoint.*109.*" "set bpt" | |
| 331 | ||
| 332 | gdb_test "c" ".*New thread.*Breakpoint.*109.*" "first continue" | |
| 333 | fix_timeout | |
| 334 | ||
| 335 | # Make sure we don't wait (waiting is for attach test) | |
| 336 | # | |
| 337 | gdb_test "set wait_here = 0" ".*" "" | |
| 338 | ||
| 339 | send_gdb "info thr\n" | |
| 340 | gdb_expect { | |
| 341 | -re ".*2 system th.*1 sy.*109.*$gdb_prompt $" { pass "saw thread create" } | |
| 342 | -re ".*1 system thread.*87.*$gdb_prompt $" { fail "didn't see thread create" } | |
| 343 | -re ".*$gdb_prompt $" { fail "no info thread command" } | |
| 344 | timeout { fail "timeout" } | |
| 345 | } | |
| 346 | ||
| 347 | gdb_test "c" ".*New thread.*Breakpoint.*109.*" "continue" | |
| 348 | fix_timeout | |
| 349 | ||
| 350 | send_gdb "info thr\n" | |
| 351 | gdb_expect { | |
| 352 | -re ".*3 system thread.*2 sys.*\\\* 1 system thread.*109.*$gdb_prompt $" { | |
| 353 | pass "saw thread create" } | |
| 354 | -re ".*2 system thread.*1 sys.*109.*$gdb_prompt $" { | |
| 355 | fail "didn't see thread create" | |
| 356 | } | |
| 357 | -re ".*1 system thread.*109.*$gdb_prompt $" { | |
| 358 | fail "didn't see thread create" | |
| 359 | } | |
| 360 | -re ".*$gdb_prompt $" { | |
| 361 | fail "no info thread command" | |
| 362 | } | |
| 363 | timeout { fail "timeout" } | |
| 364 | } | |
| 365 | ||
| 366 | fix_timeout | |
| 367 | gdb_test "clear" ".*Deleted breakpoint.*" "" | |
| 368 | ||
| 369 | # Now go on to the end of thread creation. | |
| 370 | # | |
| 371 | gdb_test "b 122" ".*" "set bpt 122" | |
| 372 | gdb_test "c" ".*New thread.*New thread.*New thread.*122.*" "" | |
| 373 | gdb_test "p \$pc" ".*" "" | |
| 374 | gdb_test "clear" ".*Deleted breakpoint.*" "" | |
| 375 | ||
| 376 | send_gdb "info thr\n" | |
| 377 | gdb_expect { | |
| 378 | -re ".*7 system thread.*6 sys.*5.*1 system thread.*122.*$gdb_prompt $" | |
| 379 | { pass "saw thread creates" } | |
| 380 | -re ".*$gdb_prompt $" | |
| 381 | { fail "no info thread command" } | |
| 382 | timeout { fail "timeout" } | |
| 383 | } | |
| 384 | ||
| 385 | # Try a thread-specific breakpoint; we expect the other threads to | |
| 386 | # be waiting at this point. | |
| 387 | # | |
| 388 | gdb_test "thr 3" ".*Switching to thread.*ksleep.*" "thread switch" | |
| 389 | gdb_test "i th" ".*\\\* 3 system thread.*" "show new current thread" | |
| 390 | ||
| 391 | gdb_test "up" ".*lwp_cond_timedwait.*" "" | |
| 392 | gdb_test "up" ".*pthread_cond_wait.*" "" | |
| 393 | gdb_test "up" ".*worker.*144.*" "" | |
| 394 | ||
| 395 | gdb_test "b 145 th 3" ".*Breakpoint.*145.*" "set thread-specific bp" | |
| 396 | gdb_test "i b" ".*breakpoint.*breakpoint.*145 thread 3.*" "show thread-specific bp" | |
| 397 | ||
| 398 | gdb_test "c" ".*Breakpoint.*145.*145.*" "hit thread-specific bp" | |
| 399 | gdb_test "p \$pc" ".*" "" | |
| 400 | ||
| 401 | # Test thread apply command on thread specific data. | |
| 402 | # | |
| 403 | gdb_test "thre app all p \$pc" ".*Thread 7.*Thread 6.*Thread 5.*Thread 4.*Thread 3.*Thread 2.*Thread 1.*" "thread apply all" | |
| 404 | gdb_test "thr ap 1 3 5 p \$pc" ".*Thread 1.*Thread 3.*Thread 5.*" "thr app 1 3 5" | |
| 405 | ||
| 406 | # Switch again, and test that others continue on a "next" | |
| 407 | # This test _could_ fail due to timing issues, but that's | |
| 408 | # unlikely. | |
| 409 | # | |
| 410 | gdb_test "thr 7" ".*Switching to thread.*" "" | |
| 411 | ||
| 412 | # Make sure that "up" stops at __pthread_exit, or | |
| 413 | # __pthread_create, the pseudo-roots, and that we | |
| 414 | # only see that pseudo-root once. | |
| 415 | # | |
| 416 | send_gdb "bt\n" | |
| 417 | gdb_expect { | |
| 418 | -re ".*Error accessing memory address.*" { fail "bt" } | |
| 419 | -re ".*pthread_create.*pthread_create.*" { fail "bt" } | |
| 420 | -re ".*worker.*pthread_create.*" { pass "bt" } | |
| 421 | -re ".*pthread_exit.*" { pass "bt" } | |
| 422 | timeout { fail "timeout on bt" } | |
| 423 | } | |
| 424 | ||
| 425 | gdb_test "up" ".*" "" | |
| 426 | gdb_test "up" ".*" "" | |
| 427 | gdb_test "up" ".*144.*" "Up 3" | |
| 428 | gdb_test "up" ".*pthread_.*" "Up 4" | |
| 429 | gdb_test "up" ".*Initial frame selected; you cannot go up.*" "catch end of thread stack" | |
| 430 | ||
| 431 | #===================== | |
| 432 | # | |
| 433 | # Things get iffy here; when we step, sometimes the step | |
| 434 | # completes, sometimes it doesn't. When it doesn't, we | |
| 435 | # hit a bp somewhere else and the step never completes | |
| 436 | # (wait_for_inferior just evaporates it). | |
| 437 | # | |
| 438 | # I think the right answer is that any failures here | |
| 439 | # should stick around to trigger later fixing. | |
| 440 | # | |
| 441 | # Here's the plan: | |
| 442 | # | |
| 443 | # Bps at 148 (5) and 154 (6) on thread 7 (two bps so we | |
| 444 | # see the difference between going around the loop and | |
| 445 | # reporting the same bp hit twice). | |
| 446 | # | |
| 447 | # Bp at 144 on thread 3. | |
| 448 | # | |
| 449 | # Step out of a library routine. | |
| 450 | # | |
| 451 | # Either the step will finish or a bp will hit. Try to | |
| 452 | # handle all the cases. | |
| 453 | # | |
| 454 | gdb_test "b 148 thr 7" ".*Breakpoint.*148.*" "" | |
| 455 | gdb_test "b 154 thr 7" ".*Breakpoint.*154.*" "set bpt 2" | |
| 456 | ||
| 457 | set hit_154_bp 0 | |
| 458 | set hit_148_bp 0 | |
| 459 | set hit_145_bp 0 | |
| 460 | set step_completed 0 | |
| 461 | ||
| 462 | # Expect zero hits | |
| 463 | # | |
| 464 | gdb_test "i b" ".*" "" | |
| 465 | ||
| 466 | send_gdb "n\n" | |
| 467 | gdb_expect { | |
| 468 | -re ".*Single stepping.*_lwp_cond_timedwait.*$gdb_prompt $" { | |
| 469 | send_gdb "thr\n" | |
| 470 | gdb_expect { | |
| 471 | -re ".*is 7.*$gdb_prompt $" { | |
| 472 | set step_completed 1 | |
| 473 | pass "completed step in library code" | |
| 474 | } | |
| 475 | -re ".*$gdb_prompt $" { | |
| 476 | fail "completed step in library code, but in wrong thread" | |
| 477 | } | |
| 478 | timeout { fail "timeout" } | |
| 479 | } | |
| 480 | } | |
| 481 | -re ".*Single stepping.*Switched to thread 3.*Breakpoint.*$gdb_prompt $" { | |
| 482 | pass "step cancelled; hit bp due to thread parallelism" | |
| 483 | set hit_145_bp 1 | |
| 484 | } | |
| 485 | -re ".*Single stepping.*Switched to thread 7.*Breakpoint.*148.*$gdb_prompt $" { | |
| 486 | pass "step cancelled; hit bp due to thread parallelism" | |
| 487 | set hit_148_bp 1 | |
| 488 | } | |
| 489 | -re ".*Single stepping.*Switched to thread 7.*Breakpoint.*154.*$gdb_prompt $" { | |
| 490 | pass "step cancelled; hit bp due to thread parallelism" | |
| 491 | set hit_154_bp 1 | |
| 492 | } | |
| 493 | -re ".*$gdb_prompt $" { | |
| 494 | send_gdb "thr\n" | |
| 495 | gdb_expect { | |
| 496 | -re ".*is 7.*$gdb_prompt $" { | |
| 497 | fail "No event?" | |
| 498 | } | |
| 499 | -re ".*$gdb_prompt $" { | |
| 500 | fail "No event" | |
| 501 | } | |
| 502 | timeout { fail "timeout" } | |
| 503 | } | |
| 504 | } | |
| 505 | timeout { fail "timeout" } | |
| 506 | } | |
| 507 | ||
| 508 | # Sometimes used to get SIGTRAP here; that should be fixed | |
| 509 | # | |
| 510 | ||
| 511 | # Expect appropriate hits of bpt; too much work to parse | |
| 512 | # result and check... | |
| 513 | # | |
| 514 | gdb_test "i b" ".*" "" | |
| 515 | ||
| 516 | send_gdb "c\n" | |
| 517 | gdb_expect { | |
| 518 | -re ".*SIGTRAP.*$gdb_prompt $" { | |
| 519 | fail "got SIGTRAP" | |
| 520 | } | |
| 521 | -re ".*Switched to thread 7.*Breakpoint.*154.*$gdb_prompt $" { | |
| 522 | if { $hit_154_bp == 1 } { | |
| 523 | fail "re-hit old bp" | |
| 524 | } else { | |
| 525 | pass "continue; hit parallel event after continue" | |
| 526 | } | |
| 527 | set hit_154_bp 1 | |
| 528 | } | |
| 529 | -re ".*Switched to thread 7.*Breakpoint.*148.*$gdb_prompt $" { | |
| 530 | if { $hit_148_bp == 1 } { | |
| 531 | fail "re-hit old bp" | |
| 532 | } else { | |
| 533 | pass "continue; hit parallel event after continue" | |
| 534 | } | |
| 535 | set hit_148_bp 1 | |
| 536 | } | |
| 537 | -re ".*Breakpoint.*154.*$gdb_prompt $" { | |
| 538 | if { $hit_154_bp == 1 } { | |
| 539 | fail "re-hit old bp" | |
| 540 | } else { | |
| 541 | send_gdb "thr\n" | |
| 542 | gdb_expect { | |
| 543 | -re ".*is 7.*$gdb_prompt $" { | |
| 544 | pass "continue; hit parallel event after continue" | |
| 545 | } | |
| 546 | -re ".*$gdb_prompt $" { | |
| 547 | fail "hit bp in wrong thread" | |
| 548 | } | |
| 549 | timeout { fail "timeout" } | |
| 550 | } | |
| 551 | } | |
| 552 | set hit_154_bp 1 | |
| 553 | } | |
| 554 | -re ".*Breakpoint.*148.*$gdb_prompt $" { | |
| 555 | if { $hit_148_bp == 1 } { | |
| 556 | fail "re-hit old bp" | |
| 557 | } else { | |
| 558 | send_gdb "thr\n" | |
| 559 | gdb_expect { | |
| 560 | -re ".*is 7.*$gdb_prompt $" { | |
| 561 | pass "continue; hit parallel event after continue" | |
| 562 | } | |
| 563 | -re ".*$gdb_prompt $" { | |
| 564 | fail "hit bp in wrong thread" | |
| 565 | } | |
| 566 | timeout { fail "timeout" } | |
| 567 | } | |
| 568 | } | |
| 569 | set hit_148_bp 1 | |
| 570 | } | |
| 571 | -re ".*Breakpoint.*145.*$gdb_prompt $" { | |
| 572 | if { $hit_145_bp == 1 } { | |
| 573 | fail "re-hit old bp" | |
| 574 | } else { | |
| 575 | send_gdb "thr\n" | |
| 576 | gdb_expect { | |
| 577 | -re ".*is 3.*$gdb_prompt $" { | |
| 578 | pass "continue; hit parallel event after continue" | |
| 579 | } | |
| 580 | -re ".*$gdb_prompt $" { | |
| 581 | fail "hit bp in wrong thread" | |
| 582 | } | |
| 583 | timeout { fail "timeout" } | |
| 584 | } | |
| 585 | } | |
| 586 | set hit_145_bp 1 | |
| 587 | } | |
| 588 | -re ".*_lwp_cond_timedwait.*$gdb_prompt $" { | |
| 589 | pass "continue; hit step completion after continue" | |
| 590 | } | |
| 591 | -re ".*Program exited normally.*" { | |
| 592 | fail "Program ended? HOW?" | |
| 593 | } | |
| 594 | -re ".*$gdb_prompt $" { | |
| 595 | fail "Unexpected event" | |
| 596 | } | |
| 597 | timeout { fail "timeout" } | |
| 598 | } | |
| 599 | ||
| 600 | # There are a number of places we _could_ be now; | |
| 601 | # this is the price of really running in parallel. | |
| 602 | # | |
| 603 | send_gdb "n\n" | |
| 604 | gdb_expect { | |
| 605 | -re ".*Switched to thread 7.*pthread_cond_wait.*$gdb_prompt $" { | |
| 606 | if { $step_completed } { | |
| 607 | fail "step already completed" | |
| 608 | } else { | |
| 609 | pass "finish step" | |
| 610 | } | |
| 611 | } | |
| 612 | -re ".*pthread_cond_wait.*$gdb_prompt $" { | |
| 613 | # | |
| 614 | # Unlikely, but we might finish the range step from inside | |
| 615 | # ksleep, before anything else. | |
| 616 | # | |
| 617 | if { $step_completed } { | |
| 618 | fail "step already completed" | |
| 619 | } else { | |
| 620 | send_gdb "thr\n" | |
| 621 | gdb_expect { | |
| 622 | -re ".*is 7.*$gdb_prompt $" { | |
| 623 | pass "finish step" | |
| 624 | } | |
| 625 | -re ".*$gdb_prompt $" { | |
| 626 | fail "step in wrong thread" | |
| 627 | } | |
| 628 | timeout { fail "timeout" } | |
| 629 | } | |
| 630 | } | |
| 631 | } | |
| 632 | -re ".*Switched to thread.*Breakpoint.*145.*$gdb_prompt $" { | |
| 633 | pass "auto-switch thread" | |
| 634 | } | |
| 635 | -re ".*Breakpoint.*145.*$gdb_prompt $" { | |
| 636 | pass "auto-switch not needed, ok" | |
| 637 | } | |
| 638 | -re ".*140.*while.*n_pile.*$gdb_prompt $" { | |
| 639 | # | |
| 640 | # This is just going around the loop from the 154 bp. | |
| 641 | # | |
| 642 | send_gdb "thr\n" | |
| 643 | gdb_expect { | |
| 644 | -re ".*is 7.*$gdb_prompt $" { | |
| 645 | pass "finish step" | |
| 646 | } | |
| 647 | -re ".*$gdb_prompt $" { | |
| 648 | fail "step in wrong thread" | |
| 649 | } | |
| 650 | timeout { fail "timeout" } | |
| 651 | } | |
| 652 | } | |
| 653 | -re ".*149.*ptr = wp.*pile.*$gdb_prompt $" { | |
| 654 | # | |
| 655 | # This is just going around the loop from the 148 bp. | |
| 656 | # | |
| 657 | if { $hit_154_bp } { | |
| 658 | send_gdb "thr\n" | |
| 659 | gdb_expect { | |
| 660 | -re ".*is 7.*$gdb_prompt $" { | |
| 661 | pass "finish step" | |
| 662 | } | |
| 663 | -re ".*$gdb_prompt $" { | |
| 664 | fail "step in wrong thread" | |
| 665 | } | |
| 666 | timeout { fail "timeout" } | |
| 667 | } | |
| 668 | } else { | |
| 669 | pass "step from 149 but didn't hit it first" | |
| 670 | } | |
| 671 | } | |
| 672 | -re ".*Breakpoint 5.*154.*$gdb_prompt $" { | |
| 673 | gdb_test "i b" ".*" "" | |
| 674 | if { $hit_154_bp } { | |
| 675 | fail "hit bp again?" | |
| 676 | } else { | |
| 677 | pass "hit bp" | |
| 678 | } | |
| 679 | } | |
| 680 | -re ".*Breakpoint 5.*148.*$gdb_prompt $" { | |
| 681 | gdb_test "i b" ".*" "" | |
| 682 | if { $hit_148_bp } { | |
| 683 | fail "hit bp again?" | |
| 684 | } else { | |
| 685 | pass "hit bp" | |
| 686 | } | |
| 687 | } | |
| 688 | -re ".*$gdb_prompt $" { | |
| 689 | fail "no step finished" | |
| 690 | } | |
| 691 | timeout { fail "timeout on 'next'" } | |
| 692 | } | |
| 693 | ||
| 694 | # Let's get into some kind of known state again. | |
| 695 | # | |
| 696 | gdb_test "thr 7" ".*" "" | |
| 697 | gdb_test "info thread" ".*" "" | |
| 698 | #gdb_test "i b" ".*" "" | |
| 699 | ||
| 700 | # Leave breakpoint "154 thr 7" as only live bp. | |
| 701 | # | |
| 702 | gdb_test "d 1" ".*" "del main bp" | |
| 703 | gdb_test "d 4" ".*" "thread-specific bpt delete" | |
| 704 | gdb_test "d 5" ".*" "other bp delete" | |
| 705 | send_gdb "i b\n" | |
| 706 | gdb_expect { | |
| 707 | -re ".*breakpoint.*breakpoint.*$gdb_prompt $" { | |
| 708 | fail "more than one bp left" | |
| 709 | } | |
| 710 | -re ".*breakpoint.*154.*thread.*7.*$gdb_prompt $" { | |
| 711 | pass "Only one bp left" | |
| 712 | } | |
| 713 | -re ".*$gdb_prompt $" { | |
| 714 | fail "Wrong or no bp left" | |
| 715 | } | |
| 716 | timeout { fail "timeout on info b" } | |
| 717 | } | |
| 718 | ||
| 719 | send_gdb "c\n" | |
| 720 | gdb_expect { | |
| 721 | -re ".*SIGTRAP.*Switched to thread.*$gdb_prompt $" { | |
| 722 | fail "SIGTRAP error; lost thread-specific bpt" | |
| 723 | } | |
| 724 | -re ".*SIGTRAP.*Switched to thread.*154.*$gdb_prompt $" { | |
| 725 | fail "SIGTRAP, but hit right thread-specific bpt" | |
| 726 | } | |
| 727 | -re ".*Switched to thread.*Breakpoint.*154.*$gdb_prompt $" { | |
| 728 | pass "auto-switch back" | |
| 729 | } | |
| 730 | -re ".*Breakpoint.*154.*$gdb_prompt $" { | |
| 731 | pass "step to bp" | |
| 732 | } | |
| 733 | -re ".*$gdb_prompt $" { | |
| 734 | fail "auto-switch back" | |
| 735 | } | |
| 736 | -re ".*Program exited normally.*$gdb_prompt $" { | |
| 737 | fail "step lost" | |
| 738 | } | |
| 739 | timeout { | |
| 740 | fail "timeout" | |
| 741 | } | |
| 742 | } | |
| 743 | fix_timeout | |
| 744 | ||
| 745 | gdb_test "cle" ".*Deleted breakpoint.*" "delete last breakpoint" | |
| 746 | ||
| 747 | # Sometimes get SIGTRAP here. Continue sometimes gets another... | |
| 748 | # | |
| 749 | send_gdb "c\n" | |
| 750 | gdb_expect { | |
| 751 | -re ".*SIGTRAP.*154.*154.*$gdb_prompt $" { | |
| 752 | fail "SIGTRAP on deleted bp 154 " | |
| 753 | send_gdb "c\n" | |
| 754 | gdb_expect { | |
| 755 | -re ".*$gdb_prompt $" { pass "fixup"} | |
| 756 | timeout { fail "fixup" } | |
| 757 | } | |
| 758 | } | |
| 759 | -re ".*SIGTRAP.*144.*145.*$gdb_prompt $" { | |
| 760 | fail "SIGTRAP on deleted bp 145 " | |
| 761 | send_gdb "c\n" | |
| 762 | gdb_expect { | |
| 763 | -re ".*$gdb_prompt $" { pass "fixup"} | |
| 764 | timeout { fail "fixup" } | |
| 765 | } | |
| 766 | } | |
| 767 | -re ".*SIGTRAP.*148.*148.*$gdb_prompt $" { | |
| 768 | fail "SIGTRAP on deleted bp 148 " | |
| 769 | send_gdb "c\n" | |
| 770 | gdb_expect { | |
| 771 | -re ".*$gdb_prompt $" { pass "fixup"} | |
| 772 | timeout { fail "fixup" } | |
| 773 | } | |
| 774 | } | |
| 775 | -re ".*SIGTRAP.*$gdb_prompt $" { | |
| 776 | fail "unknown SIGTRAP" | |
| 777 | send_gdb "c\n" | |
| 778 | gdb_expect { | |
| 779 | -re ".*$gdb_prompt $" { pass "fixup"} | |
| 780 | timeout { fail "fixup" } | |
| 781 | } | |
| 782 | } | |
| 783 | -re ".*Program exited.*$gdb_prompt $" { | |
| 784 | pass "run to end" | |
| 785 | } | |
| 786 | -re ".*$gdb_prompt $" { | |
| 787 | fail "run to end" | |
| 788 | send_gdb "c\n" | |
| 789 | gdb_expect { | |
| 790 | -re ".*$gdb_prompt $" { pass "fixup"} | |
| 791 | timeout { fail "fixup" } | |
| 792 | } | |
| 793 | } | |
| 794 | timeout { fail "timeout" } | |
| 795 | } | |
| 796 | ||
| 797 | gdb_test "p \$pc" ".*No registers.*" "program done" | |
| 798 | ||
| 799 | # Done! | |
| 800 | # | |
| 801 | gdb_exit | |
| 802 | ||
| 803 | set timeout $oldtimeout | |
| 804 | set verbose $oldverbose | |
| 805 | ||
| 806 | # execute_anywhere "rm -f ${binfile}" | |
| 807 | # | |
| 808 | return 0 | |
| 809 |