This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [RFA] Try2: Inform about new thread in a single place.


On Friday 21 December 2007 21:51:33 you wrote:
> On Dec 21, 2007 10:04 AM, Vladimir Prus <vladimir@codesourcery.com> wrote:
> > The attached patch merges my patch to report about
> > new thread in a single place with Chris' patch to
> > make reporting of new/dead threads user-controllable.
> > OK?
> 
> Needs to be adjusted for the comments people made on my patch:
> 
> * [drow] new test case won't work for gdbserver.  (I don't see that
> your changes would fix this issue w/ gdbserver, and don't off-hand
> know a gdbserver test to use in the testcase.)

I don't know either. But it seems to be a limitation of gdbserver, so
failing test is actually right thing to have.

> * [eliz] thread-attach -> thread-events in the gdb.texinfo change. *
> (I forgot to change one copy of my old command name)
> 
> * [eliz] GDB -> @value(GDBN} in the gdb.texinfo change as well.

I've missed those, sorry. Here's the revised patch.

- Volodya

[gdb/ChangeLog]
2007-12-21  Vladimir Prus <vladimir@codesourcery.com>
            Chris Demetriou  <cgd@google.com>
        * thread.c (add_thread_silent): Renamed
        from add_thread.
        (print_thread_events): New variable definition.
        (show_print_thread_events): New function.
        (_initialize_thread): Add "set print thread-events" and
        "show print thread-events" commands.
        (add_thread): Announce new thread.
        * gdbthread.h (add_thread_silent): Declare.
        (print_thread_events): New variable declaration.
        * inf-ttrace.c (inf_ttrace_wait): Don't
        inform about new thread, as add_thread is always
        called too, and will take care of that.
        * infrun.c (handle_inferior_event): Likewise.
        * procfs.c (procfs_wait): Likewise.
        * remote.c (remote_currthread): Likewise.
        * sol-thread.c (sol_thread_wait): Likewise.
        * win32-nat.c (get_win32_debug_event): Likewise.
        * linux-thread-db.c (attach_thread): Likewise.
        Remove the verbose parameter.
        (check_event): Make detach_thread be verbose
        only if print_thread_events is set.
        * linux-nat.c (lin_lwp_attach_lwp): Don't inform
        about new thread.  This is called only from
        linux-thread-db.c:attach_thread, which will take care.
        Remove the verbose parameter.
        * linux-nat.h (lin_lwp_attach_lwp): Adjust prototype.

[gdb/doc/ChangeLog]
2007-12-19  Chris Demetriou  <cgd@google.com>

        * gdb.texinfo (Threads): Document new "set print thread-events"
        and "show print thread-events" commands.

[gdb/testsuite/ChangeLog]
2007-12-19  Chris Demetriou  <cgd@google.com>

        * gdb.threads/thread_events.c: New testcase source file.
        * gdb.threads/thread_events.exp: New testcase expect file.
---
 gdb/bsd-uthread.c                           |    2 +-
 gdb/doc/gdb.texinfo                         |   18 +++
 gdb/gdbthread.h                             |   15 ++-
 gdb/inf-ttrace.c                            |    1 -
 gdb/infrun.c                                |    8 +--
 gdb/linux-nat.c                             |    7 +-
 gdb/linux-nat.h                             |    2 +-
 gdb/linux-thread-db.c                       |   17 ++--
 gdb/procfs.c                                |   14 +--
 gdb/remote.c                                |    7 +-
 gdb/sol-thread.c                            |    5 +-
 gdb/testsuite/gdb.threads/thread_events.c   |   55 ++++++++++
 gdb/testsuite/gdb.threads/thread_events.exp |  149 +++++++++++++++++++++++++++
 gdb/thread.c                                |   35 ++++++-
 gdb/win32-nat.c                             |    4 -
 15 files changed, 281 insertions(+), 58 deletions(-)
 create mode 100644 gdb/testsuite/gdb.threads/thread_events.c
 create mode 100644 gdb/testsuite/gdb.threads/thread_events.exp

diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index 3c8714a..064b7de 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c
@@ -366,7 +366,7 @@ bsd_uthread_wait (ptid_t ptid, struct target_waitstatus *status)
   if (ptid_get_tid (ptid) != 0 && !in_thread_list (ptid)
       && ptid_get_tid (inferior_ptid) == 0)
     {
-      add_thread (ptid);
+      add_thread_silent (ptid);
       inferior_ptid = ptid;
     }
 
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 177f791..b7a3867 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -2241,6 +2241,8 @@ programs:
 @item @samp{thread apply [@var{threadno}] [@var{all}] @var{args}},
 a command to apply a command to a list of threads
 @item thread-specific breakpoints
+@item @samp{set print thread-events}, which controls printing of 
+messages on thread start and exit.
 @end itemize
 
 @quotation
@@ -2434,6 +2436,22 @@ threads that you want affected with the command argument
 shown in the first field of the @samp{info threads} display; or it
 could be a range of thread numbers, as in @code{2-4}.  To apply a
 command to all threads, type @kbd{thread apply all @var{command}}.
+
+@kindex set print thread-events
+@cindex print messages on thread start and exit
+@item set print thread-events
+@itemx set print thread-events on
+@itemx set print thread-events off
+The @code{set print thread-events} command allows you to enable or
+disable printing of messages when @value{GDBN} notices that new threads have
+started or that threads have exited.  By default, these messages will
+be printed if detection of these events is supported by the target.
+Note that these messages cannot be disabled on all targets.
+
+@kindex show print thread-events
+@item show print thread-events
+Show whether messages will be printed when GDB detects that threads
+have started and exited.
 @end table
 
 @cindex automatic thread selection
diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index 12e0bcc..011f075 100644
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -69,11 +69,16 @@ struct thread_info
 /* Create an empty thread list, or empty the existing one.  */
 extern void init_thread_list (void);
 
-/* Add a thread to the thread list.
-   Note that add_thread now returns the handle of the new thread,
-   so that the caller may initialize the private thread data.  */
+/* Add a thread to the thread list, print a message
+   that a new thread is found, and return the pointer to
+   the new thread.  Caller my use this pointer to 
+   initialize the private thread data.  */
 extern struct thread_info *add_thread (ptid_t ptid);
 
+/* Same as add_thread, but does not print a message
+   about new thread.  */
+extern struct thread_info *add_thread_silent (ptid_t ptid);
+
 /* Delete an existing thread list entry.  */
 extern void delete_thread (ptid_t);
 
@@ -141,4 +146,8 @@ extern void switch_to_thread (ptid_t ptid);
 /* Commands with a prefix of `thread'.  */
 extern struct cmd_list_element *thread_cmd_list;
 
+/* Print notices on thread events (attach, detach, etc.), set with
+   `set print thread-events'.  */
+extern int print_thread_events;
+
 #endif /* GDBTHREAD_H */
diff --git a/gdb/inf-ttrace.c b/gdb/inf-ttrace.c
index 420133a..ffbfe9c 100644
--- a/gdb/inf-ttrace.c
+++ b/gdb/inf-ttrace.c
@@ -962,7 +962,6 @@ inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
                  sizeof (struct inf_ttrace_private_thread_info));
          inf_ttrace_num_lwps++;
        }
-      printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
       ti = add_thread (ptid);
       ti->private =
        xmalloc (sizeof (struct inf_ttrace_private_thread_info));
diff --git a/gdb/infrun.c b/gdb/infrun.c
index e651425..1cd5e98 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1339,13 +1339,7 @@ handle_inferior_event (struct execution_control_state *ecs)
 
   if (ecs->ws.kind != TARGET_WAITKIND_EXITED
       && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event)
-    {
-      add_thread (ecs->ptid);
-
-      ui_out_text (uiout, "[New ");
-      ui_out_text (uiout, target_pid_to_str (ecs->ptid));
-      ui_out_text (uiout, "]\n");
-    }
+    add_thread (ecs->ptid);
 
   switch (ecs->ws.kind)
     {
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 9a39ab6..6466bf0 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -870,7 +870,7 @@ exit_lwp (struct lwp_info *lp)
    be attached.  */
 
 int
-lin_lwp_attach_lwp (ptid_t ptid, int verbose)
+lin_lwp_attach_lwp (ptid_t ptid)
 {
   struct lwp_info *lp;
 
@@ -955,9 +955,6 @@ lin_lwp_attach_lwp (ptid_t ptid, int verbose)
       lp->stopped = 1;
     }
 
-  if (verbose)
-    printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
-
   return 0;
 }
 
@@ -2089,8 +2086,6 @@ retry:
                }
 
              add_thread (lp->ptid);
-             printf_unfiltered (_("[New %s]\n"),
-                                target_pid_to_str (lp->ptid));
            }
 
          /* Save the trap's siginfo in case we need it later.  */
diff --git a/gdb/linux-nat.h b/gdb/linux-nat.h
index 43686cf..9b8d3bf 100644
--- a/gdb/linux-nat.h
+++ b/gdb/linux-nat.h
@@ -95,7 +95,7 @@ void linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked,
 /* linux-nat functions for handling fork events.  */
 extern void linux_enable_event_reporting (ptid_t ptid);
 
-extern int lin_lwp_attach_lwp (ptid_t ptid, int verbose);
+extern int lin_lwp_attach_lwp (ptid_t ptid);
 
 /* Iterator function for lin-lwp's lwp list.  */
 struct lwp_info *iterate_over_lwps (int (*callback) (struct lwp_info *, 
diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c
index d2398df..a271b01 100644
--- a/gdb/linux-thread-db.c
+++ b/gdb/linux-thread-db.c
@@ -118,7 +118,7 @@ static CORE_ADDR td_death_bp_addr;
 /* Prototypes for local functions.  */
 static void thread_db_find_new_threads (void);
 static void attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
-                          const td_thrinfo_t *ti_p, int verbose);
+                          const td_thrinfo_t *ti_p);
 static void detach_thread (ptid_t ptid, int verbose);
  
 
@@ -279,7 +279,7 @@ thread_get_info_callback (const td_thrhandle_t *thp, void *infop)
   if (thread_info == NULL)
     {
       /* New thread.  Attach to it now (why wait?).  */
-      attach_thread (thread_ptid, thp, &ti, 1);
+      attach_thread (thread_ptid, thp, &ti);
       thread_info = find_thread_pid (thread_ptid);
       gdb_assert (thread_info != NULL);
     }
@@ -670,7 +670,7 @@ thread_db_new_objfile (struct objfile *objfile)
 
 static void
 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
-              const td_thrinfo_t *ti_p, int verbose)
+              const td_thrinfo_t *ti_p)
 {
   struct thread_info *tp;
   td_err_e err;
@@ -702,7 +702,7 @@ attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
     return;                    /* A zombie thread -- do not attach.  */
 
   /* Under GNU/Linux, we have to attach to each and every thread.  */
-  if (lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0) < 0)
+  if (lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid))) < 0)
     return;
 
   /* Add the thread to GDB's thread list.  */
@@ -710,9 +710,6 @@ attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
   tp->private = xmalloc (sizeof (struct private_thread_info));
   memset (tp->private, 0, sizeof (struct private_thread_info));
 
-  if (verbose)
-    printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid));
-
   /* Enable thread event reporting for this thread.  */
   err = td_thr_event_enable_p (th_p, 1);
   if (err != TD_OK)
@@ -843,7 +840,7 @@ check_event (ptid_t ptid)
        case TD_CREATE:
          /* Call attach_thread whether or not we already know about a
             thread with this thread ID.  */
-         attach_thread (ptid, msg.th_p, &ti, 1);
+         attach_thread (ptid, msg.th_p, &ti);
 
          break;
 
@@ -852,7 +849,7 @@ check_event (ptid_t ptid)
          if (!in_thread_list (ptid))
            error (_("Spurious thread death event."));
 
-         detach_thread (ptid, 1);
+         detach_thread (ptid, print_thread_events);
 
          break;
 
@@ -976,7 +973,7 @@ find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
     }
 
   if (!in_thread_list (ptid))
-    attach_thread (ptid, th_p, &ti, 1);
+    attach_thread (ptid, th_p, &ti);
 
   return 0;
 }
diff --git a/gdb/procfs.c b/gdb/procfs.c
index 4bd1fa8..86382bb 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -4119,11 +4119,8 @@ wait_again:
                    temp_ptid = MERGEPID (pi->pid, temp_tid);
                    /* If not in GDB's thread list, add it.  */
                    if (!in_thread_list (temp_ptid))
-                     {
-                       printf_filtered (_("[New %s]\n"),
-                                        target_pid_to_str (temp_ptid));
-                       add_thread (temp_ptid);
-                     }
+                     add_thread (temp_ptid);
+
                    /* Return to WFI, but tell it to immediately resume. */
                    status->kind = TARGET_WAITKIND_SPURIOUS;
                    return inferior_ptid;
@@ -4189,11 +4186,7 @@ wait_again:
                    /* If not in GDB's thread list, add it.  */
                    temp_ptid = MERGEPID (pi->pid, temp_tid);
                    if (!in_thread_list (temp_ptid))
-                     {
-                       printf_filtered (_("[New %s]\n"),
-                                        target_pid_to_str (temp_ptid));
-                       add_thread (temp_ptid);
-                     }
+                     add_thread (temp_ptid);
 
                    status->kind = TARGET_WAITKIND_STOPPED;
                    status->value.sig = 0;
@@ -4280,7 +4273,6 @@ wait_again:
                   * If we don't create a procinfo, resume may be unhappy
                   * later.
                   */
-                 printf_filtered (_("[New %s]\n"), target_pid_to_str (retval));
                  add_thread (retval);
                  if (find_procinfo (PIDGET (retval), TIDGET (retval)) == NULL)
                    create_procinfo (PIDGET (retval), TIDGET (retval));
diff --git a/gdb/remote.c b/gdb/remote.c
index 452af07..69faedb 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1049,12 +1049,7 @@ record_currthread (int currthread)
   /* If this is a new thread, add it to GDB's thread list.
      If we leave it up to WFI to do this, bad things will happen.  */
   if (!in_thread_list (pid_to_ptid (currthread)))
-    {
-      add_thread (pid_to_ptid (currthread));
-      ui_out_text (uiout, "[New ");
-      ui_out_text (uiout, target_pid_to_str (pid_to_ptid (currthread)));
-      ui_out_text (uiout, "]\n");
-    }
+    add_thread (pid_to_ptid (currthread));
 }
 
 static char *last_pass_packet;
diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index bf40696..c139397 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -461,10 +461,7 @@ sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
       if (is_thread (rtnval)
          && !ptid_equal (rtnval, save_ptid)
          && !in_thread_list (rtnval))
-       {
-         printf_filtered ("[New %s]\n", target_pid_to_str (rtnval));
-         add_thread (rtnval);
-       }
+       add_thread (rtnval);
     }
 
   /* During process initialization, we may get here without the thread
diff --git a/gdb/testsuite/gdb.threads/thread_events.c b/gdb/testsuite/gdb.threads/thread_events.c
new file mode 100644
index 0000000..9b7edcd
--- /dev/null
+++ b/gdb/testsuite/gdb.threads/thread_events.c
@@ -0,0 +1,55 @@
+/* Copyright (C) 2007 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 Chris Demetriou (cgd@google.com).  */
+
+/* Simple test to trigger thread events (thread start, thread exit).  */
+
+#include <pthread.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void *
+threadfunc (void *arg)
+{
+  printf ("in threadfunc\n");
+  return NULL;
+}
+
+static void
+after_join_func (void)
+{
+  printf ("finished\n");
+}
+
+int main (int argc, char *argv[])
+{
+  pthread_t thread;
+
+  if (pthread_create (&thread, NULL, threadfunc, NULL) != 0)
+    {
+      printf ("pthread_create failed\n");
+      exit (1);
+    }
+
+  if (pthread_join (thread, NULL) != 0)
+    {
+      printf ("pthread_join failed\n");
+      exit (1);
+    }
+
+  after_join_func ();
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.threads/thread_events.exp b/gdb/testsuite/gdb.threads/thread_events.exp
new file mode 100644
index 0000000..6a65915
--- /dev/null
+++ b/gdb/testsuite/gdb.threads/thread_events.exp
@@ -0,0 +1,149 @@
+# Copyright (C) 2007 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/>.
+
+# Please email any bugs, comments, and/or additions to this file to:
+# bug-gdb@prep.ai.mit.edu
+
+# This file was written by Chris Demetriou (cgd@google.com).
+# It tests printing of thread event (start, exit) information, and
+# disabling of those messages.
+#
+# Note: the format of thread event messages (and also whether or not
+# messages are printed and can be disabled) is dependent on the target
+# thread support code.
+
+# This test has only been verified with Linux targets, and would need
+# to be generalized to support other targets
+if ![istarget *-*-linux*] then {
+    return
+}
+
+if $tracelevel then {
+        strace $tracelevel
+}
+
+set prms_id 0
+set bug_id 0
+
+set testfile "thread_events"
+set srcfile ${testfile}.c
+set binfile ${objdir}/${subdir}/${testfile}
+
+if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
+    return -1
+}
+
+proc gdb_test_thread_start {messages_enabled command pattern message} {
+  global gdb_prompt
+
+  if { $messages_enabled } {
+    set events_expected 1
+  } else {
+    set events_expected 0
+  }
+  set events_seen 0
+
+  return [gdb_test_multiple $command $message {
+    -re "\\\[New Thread \[^\]\]*\\\]\r\n" {
+      incr events_seen;
+      exp_continue;
+    }
+    -re "\[\r\n\]*($pattern)\[\r\n\]+$gdb_prompt $" {
+      if { $events_seen != $events_expected } {
+        fail "$message (saw $events_seen, expected $events_expected)"
+      } else {
+        pass "$message"
+      }
+    }
+  }]
+}
+
+proc gdb_test_thread_exit {messages_enabled command pattern message} {
+  global gdb_prompt
+
+  if { $messages_enabled } {
+    set events_expected 1
+  } else {
+    set events_expected 0
+  }
+  set events_seen 0
+
+  return [gdb_test_multiple $command $message {
+    -re "\\\[Thread \[^\]\]* exited\\\]\r\n" {
+      incr events_seen
+      exp_continue;
+    }
+    -re "\[\r\n\]*($pattern)\[\r\n\]+$gdb_prompt $" {
+      if { $events_seen != $events_expected } {
+        fail "$message (saw $events_seen, expected $events_expected)"
+      } else {
+        pass "$message"
+      }
+    }
+  }]
+}
+
+proc test_thread_messages {enabled} {
+  global srcdir subdir binfile srcfile
+
+  if { $enabled } {
+    set enabled_string "with messages enabled"
+  } else {
+    set enabled_string "with messages disabled"
+  }
+
+  gdb_start
+  gdb_reinitialize_dir $srcdir/$subdir
+  gdb_load ${binfile}
+
+  if { $enabled } {
+     gdb_test "set print thread-events on"
+  } else {
+     gdb_test "set print thread-events off"
+  }
+
+  # The initial thread may log a 'New Thread' message, but we don't
+  # check for it.
+  if ![runto_main] then {
+     fail "Can't run to main $enabled_string"
+     return 1
+  }
+
+  gdb_test "break threadfunc" \
+      "Breakpoint.*at.* file .*$srcfile, line.*" \
+      "breakpoint at threadfunc $enabled_string"
+  gdb_test "break after_join_func" \
+      "Breakpoint.*at.* file .*$srcfile, line.*" \
+      "breakpoint at after_join_func $enabled_string"
+
+  # continue to threadfunc breakpoint.  A thread will start.
+  # Expect to see a thread start message, if messages are enabled.
+  gdb_test_thread_start $enabled "continue" \
+       ".*Breakpoint .*,.*threadfunc.*at.*$srcfile:.*" \
+       "continue to threadfunc $enabled_string"
+
+  # continue to after_join_func breakpoint.  A thread will exit.
+  # Expect to see a thread exit message, if messages are enabled.
+  gdb_test_thread_exit $enabled "continue" \
+       ".*Breakpoint .*,.*after_join_func.*at.*$srcfile:.*" \
+       "continue to after_join_func $enabled_string"
+
+  delete_breakpoints
+
+  gdb_exit
+}
+
+test_thread_messages 0
+test_thread_messages 1
diff --git a/gdb/thread.c b/gdb/thread.c
index 3c8644b..4df3f57 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -116,11 +116,8 @@ init_thread_list (void)
   thread_list = NULL;
 }
 
-/* add_thread now returns a pointer to the new thread_info, 
-   so that back_ends can initialize their private data.  */
-
 struct thread_info *
-add_thread (ptid_t ptid)
+add_thread_silent (ptid_t ptid)
 {
   struct thread_info *tp;
 
@@ -133,6 +130,17 @@ add_thread (ptid_t ptid)
   return tp;
 }
 
+struct thread_info *
+add_thread (ptid_t ptid)
+{
+  struct thread_info *result = add_thread_silent (ptid);
+
+  if (print_thread_events)
+    printf_filtered (_("[New %s]\n"), target_pid_to_str (ptid));
+  
+  return result;
+}
+
 void
 delete_thread (ptid_t ptid)
 {
@@ -675,6 +683,17 @@ thread_command (char *tidstr, int from_tty)
   gdb_thread_select (uiout, tidstr, NULL);
 }
 
+/* Print notices when new threads are attached and detached.  */
+int print_thread_events = 1;
+static void
+show_print_thread_events (struct ui_file *file, int from_tty,
+                          struct cmd_list_element *c, const char *value)
+{
+  fprintf_filtered (file, _("\
+Printing of thread events is %s.\n"),
+                    value);
+}
+
 static int
 do_captured_thread_select (struct ui_out *uiout, void *tidstr)
 {
@@ -737,4 +756,12 @@ The new thread ID must be currently known."),
 
   if (!xdb_commands)
     add_com_alias ("t", "thread", class_run, 1);
+
+  add_setshow_boolean_cmd ("thread-events", no_class,
+         &print_thread_events, _("\
+Set printing of thread events (e.g., thread start and exit)."), _("\
+Show printing of thread events (e.g., thread start and exit)."), NULL,
+         NULL,
+         show_print_thread_events,
+         &setprintlist, &showprintlist);
 }
diff --git a/gdb/win32-nat.c b/gdb/win32-nat.c
index 07ebef9..9818839 100644
--- a/gdb/win32-nat.c
+++ b/gdb/win32-nat.c
@@ -1317,10 +1317,6 @@ get_win32_debug_event (int pid, struct target_waitstatus *ourstatus)
       /* Record the existence of this thread */
       th = win32_add_thread (current_event.dwThreadId,
                             current_event.u.CreateThread.hThread);
-      if (info_verbose)
-       printf_unfiltered ("[New %s]\n",
-                          target_pid_to_str (
-                            pid_to_ptid (current_event.dwThreadId)));
       retval = current_event.dwThreadId;
       break;
 
-- 
1.5.3.5


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]