From c35fafde7ca3b92581dee5c0ed445de3c667ab2d Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Wed, 1 Apr 2009 22:25:44 +0000 Subject: gdb/gdbserver/ * linux-low.c (linux_wait_for_event): Don't clear the `stepping' flag. (wait_for_sigstop): Don't leave a finished single-step SIGTRAP pending. (linux_continue_one_thread): Only preserve the stepping flag if there's a pending breakpoint. gdb/testsuite/ * gdb.threads/pending-step.c, gdb.threads/pending-step.exp: New. --- gdb/testsuite/gdb.threads/pending-step.c | 61 +++++++++++++++++++ gdb/testsuite/gdb.threads/pending-step.exp | 95 ++++++++++++++++++++++++++++++ 2 files changed, 156 insertions(+) create mode 100644 gdb/testsuite/gdb.threads/pending-step.c create mode 100644 gdb/testsuite/gdb.threads/pending-step.exp (limited to 'gdb/testsuite/gdb.threads') diff --git a/gdb/testsuite/gdb.threads/pending-step.c b/gdb/testsuite/gdb.threads/pending-step.c new file mode 100644 index 0000000..7d25c2d --- /dev/null +++ b/gdb/testsuite/gdb.threads/pending-step.c @@ -0,0 +1,61 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2002, 2003, 2004, 2007, 2008, 2009 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 . */ + +#include +#include +#include + +void *thread_function(void *arg); /* Pointer to function executed by each thread */ + +#define NUM 1 + +unsigned int args[NUM+1]; + +int main() { + int res; + pthread_t threads[NUM]; + void *thread_result; + long i; + + for (i = 1; i <= NUM; i++) + { + args[i] = 1; + res = pthread_create(&threads[i], + NULL, + thread_function, + (void *) i); + } + + /* schedlock.exp: last thread start. */ + args[0] = 1; + thread_function ((void *) 0); + + exit(EXIT_SUCCESS); +} + +void *thread_function(void *arg) { + int my_number = (long) arg; + int *myp = (int *) &args[my_number]; + + /* Don't run forever. Run just short of it :) */ + while (*myp > 0) + { + (*myp) ++; /* insert breakpoint here */ + } + + pthread_exit(NULL); +} diff --git a/gdb/testsuite/gdb.threads/pending-step.exp b/gdb/testsuite/gdb.threads/pending-step.exp new file mode 100644 index 0000000..5df4d4c --- /dev/null +++ b/gdb/testsuite/gdb.threads/pending-step.exp @@ -0,0 +1,95 @@ +# Copyright (C) 2009 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 . + +# Test that a resume cancels a previously unfinished or unreported +# single-step correctly. +# +# The test consists of several threads all running the same loop. +# There is a breakpoint set in the loop, hence all threads may hit it. +# The test then issues several "next" commands in a loop. +# +# scheduler-locking must be set to the default of "off". +# +# Here's what would happen in gdbserver: +# +# 1) We issue a "continue", and wait until a thread hits the +# breakpoint. Could be any thread, but assume thread 1 hits it. +# +# 2) We issue a "next" --- this single-steps thread 1, and resumes all +# other threads. +# +# 3) thread 2, due to scheduler-locking off, hits the breakpoint. +# gdbserver stops all other threads by sending them SIGSTOPs. +# +# 4) While being stopped in step 3, thread 1 reports a SIGTRAP, that +# corresponds to the finished single-step of step 2. gdbserver +# leaves the SIGTRAP pending to report later. +# +# 5) We issue another "next" --- this requests thread 2 to +# single-step, and all other threads to continue, including thread +# 1. Before resuming any thread, gdbserver notices that it +# remembers from step 4 a pending SIGTRAP to report for thread 1, +# so reports it now. +# +# 6) From GDB's perpective, this SIGTRAP can't represent a finished +# single-step, since thread 1 was not single-stepping (it was +# continued in step 5). Neither does this SIGTRAP correspond to a +# breakpoint hit. GDB reports to the user a spurious SIGTRAP. + +set testfile "pending-step" +set srcfile ${testfile}.c +set binfile ${objdir}/${subdir}/${testfile} + +if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } { + return -1 +} + +# Start with a fresh gdb. + +gdb_exit +gdb_start +gdb_reinitialize_dir $srcdir/$subdir +gdb_load ${binfile} + +if ![runto_main] then { + fail "Can't run to main" + return 0 +} + +gdb_breakpoint [gdb_get_line_number "insert breakpoint here"] +gdb_continue_to_breakpoint "continue to first breakpoint hit" + +set test "next in multiple threads with breakpoints" +set iterations 20 +set ok 0 +for {set i 0} {$i < $iterations} {incr i} { + set ok 0 + gdb_test_multiple "next" "$test" { + -re "SIGTRAP.*$gdb_prompt $" { + fail "$test (spurious SIGTRAP)" + } + -re "$gdb_prompt $" { + set ok 1 + } + } + + if { $ok == 0 } { + break + } +} + +if { $ok } { + pass "$test" +} -- cgit v1.1