2001-04-26 Michael Snyder <msnyder@redhat.com>

	* thread-db.c (_initialize_thread_db): Add set/show command
	"debug-linux-threads" for debugging output.
	* lin-lwp.c (various): Use global "debug_linux_threads to
	turn on extra debugging output.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 3b18a23220739cc9aadea6f3c50a5692c1e5b18f..7f1161fae82cbb0f53290ed4ae8490a86c2bbe68 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,9 @@
 2001-04-26  Michael Snyder  <msnyder@redhat.com>
 
+       * thread-db.c (_initialize_thread_db): Add set/show command
+       "debug-linux-threads" for debugging output.
+       * lin-lwp.c (various): Use global "debug_linux_threads to 
+       turn on extra debugging output.
        * lin-lwp.c: Minor cleanups in comments.
        * target.c (normal_pid_to_str): Get rid of an ancient hack.
        * remote.c (remote_pid_to_str): New function for remote target.

diff --git a/gdb/lin-lwp.c b/gdb/lin-lwp.c
index 56e7bb238718e1d102f88e6297865c2310d7afd3..7f6f01031738d59769b838d18c5dd84f5a0c719d 100644 (file)
--- a/gdb/lin-lwp.c
+++ b/gdb/lin-lwp.c
@@ -31,11 +31,8 @@
 #include "target.h"
 #include "regcache.h"
 
-#define DEBUG 1
-
-#if DEBUG
+extern int debug_linux_threads;
 extern const char *strsignal (int sig);
-#endif
 
 /* On Linux there are no real LWP's.  The closest thing to LWP's are
    processes sharing the same VM space.  A multi-threaded process is
@@ -521,9 +518,9 @@ stop_wait_callback (struct lwp_info *lp, void *data)
              printf_unfiltered ("[%s exited]\n",
                                 target_pid_to_str (lp->pid));
            }
-#if DEBUG
-         printf ("%s exited.\n", target_pid_to_str (lp->pid));
-#endif
+         if (debug_linux_threads)
+           printf ("%s exited.\n", target_pid_to_str (lp->pid));
+
          delete_lwp (lp->pid);
          return 0;
        }
@@ -549,21 +546,21 @@ stop_wait_callback (struct lwp_info *lp, void *data)
                 If we do not do this, then we run the risk that the
                 user will delete or disable the breakpoint, but the
                 thread will have already tripped on it.  */
-#if DEBUG
-             printf ("Tripped breakpoint at %lx in LWP %d"
-                     " while waiting for SIGSTOP.\n",
-                     (long) read_pc_pid (lp->pid), pid);
-#endif
+
+             if (debug_linux_threads)
+               printf ("Tripped breakpoint at %lx in LWP %d"
+                       " while waiting for SIGSTOP.\n",
+                       (long) read_pc_pid (lp->pid), pid);
+
              /* Set the PC to before the trap.  */
              if (DECR_PC_AFTER_BREAK)
                write_pc_pid (read_pc_pid (pid) - DECR_PC_AFTER_BREAK, pid);
            }
          else
            {
-#if DEBUG
-             printf ("Received %s in LWP %d while waiting for SIGSTOP.\n",
-                     strsignal (WSTOPSIG (status)), pid);
-#endif
+             if (debug_linux_threads)
+               printf ("Received %s in LWP %d while waiting for SIGSTOP.\n",
+                       strsignal (WSTOPSIG (status)), pid);
              /* The thread was stopped with a signal other than
                 SIGSTOP, and didn't accidentiliy trip a breakpoint.
                 Record the wait status.  */
@@ -620,10 +617,9 @@ lin_lwp_wait (int pid, struct target_waitstatus *ourstatus)
       lp = iterate_over_lwps (status_callback, NULL);
       if (lp)
        {
-#if DEBUG
-         printf ("Using pending wait status for LWP %d.\n",
-                 GET_LWP (lp->pid));
-#endif
+         if (debug_linux_threads)
+           printf ("Using pending wait status for LWP %d.\n",
+                   GET_LWP (lp->pid));
          status = lp->status;
          lp->status = 0;
        }
@@ -635,19 +631,18 @@ lin_lwp_wait (int pid, struct target_waitstatus *ourstatus)
     }
   else if (is_lwp (pid))
     {
-#if DEBUG
-      printf ("Waiting for specific LWP %d.\n", GET_LWP (pid));
-#endif
+      if (debug_linux_threads)
+       printf ("Waiting for specific LWP %d.\n", GET_LWP (pid));
+
       /* We have a specific LWP to check.  */
       lp = find_lwp_pid (GET_LWP (pid));
       gdb_assert (lp);
       status = lp->status;
       lp->status = 0;
-#if DEBUG
-      if (status)
+      if (debug_linux_threads)
+       if (status)
          printf ("Using pending wait status for LWP %d.\n",
                  GET_LWP (lp->pid));
-#endif
 
       /* If we have to wait, take into account whether PID is a cloned
          process or not.  And we have to convert it to something that
@@ -725,9 +720,9 @@ lin_lwp_wait (int pid, struct target_waitstatus *ourstatus)
                  printf_unfiltered ("[%s exited]\n",
                                     target_pid_to_str (lp->pid));
                }
-#if DEBUG
-             printf ("%s exited.\n", target_pid_to_str (lp->pid));
-#endif
+             if (debug_linux_threads)
+               printf ("%s exited.\n", target_pid_to_str (lp->pid));
+
              delete_lwp (lp->pid);
 
              /* Make sure there is at least one thread running.  */
@@ -743,10 +738,10 @@ lin_lwp_wait (int pid, struct target_waitstatus *ourstatus)
          if (lp->signalled && WIFSTOPPED (status)
              && WSTOPSIG (status) == SIGSTOP)
            {
-#if DEBUG
-             printf ("Delayed SIGSTOP caught for %s.\n",
-                     target_pid_to_str (lp->pid));
-#endif
+             if (debug_linux_threads)
+               printf ("Delayed SIGSTOP caught for %s.\n",
+                       target_pid_to_str (lp->pid));
+
              /* This is a delayed SIGSTOP.  */
              lp->signalled = 0;
 

diff --git a/gdb/thread-db.c b/gdb/thread-db.c
index e35775173e7b876fe3272c5865696293e6d6ee32..3d5f7b4d06d38d9fa5c3b366d56b3ca63295c586 100644 (file)
--- a/gdb/thread-db.c
+++ b/gdb/thread-db.c
@@ -31,12 +31,16 @@
 #include "symfile.h"
 #include "objfiles.h"
 #include "target.h"
+#include "command.h"
+#include "gdbcmd.h"
 #include "regcache.h"
 
 #ifndef LIBTHREAD_DB_SO
 #define LIBTHREAD_DB_SO "libthread_db.so.1"
 #endif
 
+int debug_linux_threads = 0;   /* Set non-zero for debugging output. */
+
 /* If we're running on Linux, we must explicitly attach to any new threads.  */
 
 /* FIXME: There is certainly some room for improvements:
@@ -51,7 +55,7 @@ static struct target_ops thread_db_ops;
 static struct target_ops *target_beneath;
 
 /* Pointer to the next function on the objfile event chain.  */
-static void (*target_new_objfile_chain) (struct objfile *objfile);
+static void (*new_objfile_event_chain) (struct objfile *objfile);
 
 /* Non-zero if we're using this module's target vector.  */
 static int using_thread_db;
@@ -588,8 +592,8 @@ thread_db_new_objfile (struct objfile *objfile)
     }
 
  quit:
-  if (target_new_objfile_chain)
-    target_new_objfile_chain (objfile);
+  if (new_objfile_event_chain)
+    new_objfile_event_chain (objfile);
 }
 
 static void
@@ -697,11 +701,10 @@ check_event (int pid)
        error ("Thread creation event doesn't match breakpoint.");
 #endif
 
-      /* We may already know about this thread, for instance when the
-         user has issued the `info threads' command before the SIGTRAP
-         for hitting the thread creation breakpoint was reported.  */
-      if (! in_thread_list (pid))
-       attach_thread (pid, msg.th_p, &ti, 1);
+      if (in_thread_list (pid))
+       error ("Spurious thread creation event.");
+
+      attach_thread (pid, msg.th_p, &ti, 1);
       return;
 
     case TD_DEATH:
@@ -1023,7 +1026,12 @@ _initialize_thread_db (void)
       add_target (&thread_db_ops);
 
       /* Add ourselves to objfile event chain.  */
-      target_new_objfile_chain = target_new_objfile_hook;
+      new_objfile_event_chain = target_new_objfile_hook;
       target_new_objfile_hook = thread_db_new_objfile;
     }
+  add_show_from_set (add_set_cmd ("debug-linux-threads", class_support, 
+                                 var_boolean, (char *) &debug_linux_threads,
+                                 "Set debug output for linux-threads \
+on or off.\nUse \"on\" to enable, \"off\" to disable.", &setlist),
+                    &showlist);
 }