http://sourceware.org/ml/gdb-patches/2007-06/msg00479.html

Index: gdb/linux-thread-db.c
===================================================================
--- gdb/linux-thread-db.c.orig	2006-10-20 03:08:14.000000000 +0200
+++ gdb/linux-thread-db.c	2008-03-01 14:45:52.000000000 +0100
@@ -213,6 +213,21 @@
     }
 }
 
+/* Return 1 if any threads have been registered.  There may be none if
+   the threading library is not fully initialized yet.  */
+
+static int
+have_threads_callback (struct thread_info *thread, void *dummy)
+{
+  return 1;
+}
+
+static int
+have_threads (void)
+{
+  return iterate_over_threads (have_threads_callback, NULL) != NULL;
+}
+
 /* A callback function for td_ta_thr_iter, which we use to map all
    threads to LWPs.
 
@@ -700,23 +715,6 @@
 }
 
 static void
-thread_db_attach (char *args, int from_tty)
-{
-  target_beneath->to_attach (args, from_tty);
-
-  /* Destroy thread info; it's no longer valid.  */
-  init_thread_list ();
-
-  /* The child process is now the actual multi-threaded
-     program.  Snatch its process ID...  */
-  proc_handle.pid = GET_PID (inferior_ptid);
-
-  /* ...and perform the remaining initialization steps.  */
-  enable_thread_event_reporting ();
-  thread_db_find_new_threads ();
-}
-
-static void
 detach_thread (ptid_t ptid, int verbose)
 {
   struct thread_info *thread_info;
@@ -742,14 +740,13 @@
   disable_thread_event_reporting ();
 
   /* There's no need to save & restore inferior_ptid here, since the
-     inferior is supposed to be survive this function call.  */
+     inferior is not supposed to survive this function call.  */
   inferior_ptid = lwp_from_thread (inferior_ptid);
 
-  /* Forget about the child's process ID.  We shouldn't need it
-     anymore.  */
-  proc_handle.pid = 0;
-
   target_beneath->to_detach (args, from_tty);
+
+  /* Should this be done by detach_command?  */
+  target_mourn_inferior ();
 }
 
 static int
@@ -870,12 +867,6 @@
 
   ptid = target_beneath->to_wait (ptid, ourstatus);
 
-  if (proc_handle.pid == 0)
-    /* The current child process isn't the actual multi-threaded
-       program yet, so don't try to do any special thread-specific
-       post-processing and bail out early.  */
-    return ptid;
-
   if (ourstatus->kind == TARGET_WAITKIND_EXITED
     || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
     return pid_to_ptid (-1);
@@ -889,23 +880,32 @@
       return pid_to_ptid (GET_PID (ptid));
     }
 
+  /* If we do not know about the main thread yet, this would be a good time to
+     find it.  */
+  if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads ())
+    thread_db_find_new_threads ();
+
   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
     /* Check for a thread event.  */
     check_event (ptid);
 
-  if (!ptid_equal (trap_ptid, null_ptid))
-    trap_ptid = thread_from_lwp (trap_ptid);
+  if (have_threads ())
+    {
+      /* Change ptids back into the higher level PID + TID format.  If
+	 the thread is dead and no longer on the thread list, we will
+	 get back a dead ptid.  This can occur if the thread death
+	 event gets postponed by other simultaneous events.  In such a
+	 case, we want to just ignore the event and continue on.  */
+
+      if (!ptid_equal (trap_ptid, null_ptid))
+	trap_ptid = thread_from_lwp (trap_ptid);
+
+      ptid = thread_from_lwp (ptid);
+      if (GET_PID (ptid) == -1)
+	ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
+    }
 
-  /* Change the ptid back into the higher level PID + TID format.
-     If the thread is dead and no longer on the thread list, we will 
-     get back a dead ptid.  This can occur if the thread death event
-     gets postponed by other simultaneous events.  In such a case, 
-     we want to just ignore the event and continue on.  */
-  ptid = thread_from_lwp (ptid);
-  if (GET_PID (ptid) == -1)
-    ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
-  
   return ptid;
 }
 
@@ -944,30 +944,6 @@
 }
 
 static void
-thread_db_create_inferior (char *exec_file, char *allargs, char **env,
-			   int from_tty)
-{
-  unpush_target (&thread_db_ops);
-  using_thread_db = 0;
-  target_beneath->to_create_inferior (exec_file, allargs, env, from_tty);
-}
-
-static void
-thread_db_post_startup_inferior (ptid_t ptid)
-{
-  if (proc_handle.pid == 0)
-    {
-      /* The child process is now the actual multi-threaded
-         program.  Snatch its process ID...  */
-      proc_handle.pid = GET_PID (ptid);
-
-      /* ...and perform the remaining initialization steps.  */
-      enable_thread_event_reporting ();
-      thread_db_find_new_threads ();
-    }
-}
-
-static void
 thread_db_mourn_inferior (void)
 {
   /* Forget about the child's process ID.  We shouldn't need it
@@ -1002,6 +978,22 @@
 
   ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, ti.ti_tid);
 
+  if (ti.ti_tid == 0)
+    {
+      /* A thread ID of zero means that this is the main thread, but
+	 glibc has not yet initialized thread-local storage and the
+	 pthread library.  We do not know what the thread's TID will
+	 be yet.  Just enable event reporting and otherwise ignore
+	 it.  */
+
+      err = td_thr_event_enable_p (th_p, 1);
+      if (err != TD_OK)
+	error (_("Cannot enable thread event reporting for %s: %s"),
+	       target_pid_to_str (ptid), thread_db_err_str (err));
+
+      return 0;
+    }
+
   if (!in_thread_list (ptid))
     attach_thread (ptid, th_p, &ti, 1);
 
@@ -1058,6 +1050,16 @@
   return NULL;
 }
 
+/* Return 1 if this thread has the same LWP as the passed PTID.  */
+
+static int
+same_ptid_callback (struct thread_info *thread, void *arg)
+{
+  ptid_t *ptid_p = arg;
+
+  return GET_LWP (thread->ptid) == GET_LWP (*ptid_p);
+}
+
 /* Get the address of the thread local variable in load module LM which
    is stored at OFFSET within the thread local storage for thread PTID.  */
 
@@ -1066,6 +1068,21 @@
 				    CORE_ADDR lm,
 				    CORE_ADDR offset)
 {
+  /* If we have not discovered any threads yet, check now.  */
+  if (!is_thread (ptid) && !have_threads ())
+    thread_db_find_new_threads ();
+
+  /* Try to find a matching thread if we still have the LWP ID instead
+     of the thread ID.  */
+  if (!is_thread (ptid))
+    {
+      struct thread_info *thread;
+
+      thread = iterate_over_threads (same_ptid_callback, &ptid);
+      if (thread != NULL)
+	ptid = thread->ptid;
+    }
+
   if (is_thread (ptid))
     {
       td_err_e err;
@@ -1125,14 +1142,11 @@
   thread_db_ops.to_shortname = "multi-thread";
   thread_db_ops.to_longname = "multi-threaded child process.";
   thread_db_ops.to_doc = "Threads and pthreads support.";
-  thread_db_ops.to_attach = thread_db_attach;
   thread_db_ops.to_detach = thread_db_detach;
   thread_db_ops.to_resume = thread_db_resume;
   thread_db_ops.to_wait = thread_db_wait;
   thread_db_ops.to_xfer_partial = thread_db_xfer_partial;
   thread_db_ops.to_kill = thread_db_kill;
-  thread_db_ops.to_create_inferior = thread_db_create_inferior;
-  thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
Index: gdb/gdbserver/thread-db.c
===================================================================
--- gdb/gdbserver/thread-db.c.orig	2006-10-17 18:02:27.000000000 +0200
+++ gdb/gdbserver/thread-db.c	2008-03-01 14:44:41.000000000 +0100
@@ -40,6 +40,7 @@
 /* Connection to the libthread_db library.  */
 static td_thragent_t *thread_agent;
 
+static void thread_db_find_new_threads (void);
 static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
 
 static char *
@@ -134,6 +135,8 @@
   td_event_msg_t msg;
   td_err_e err;
   struct inferior_linux_data *tdata;
+  struct thread_info *inferior;
+  struct process_info *process;
 
   if (debug_threads)
     fprintf (stderr, "Thread creation event.\n");
@@ -149,6 +152,14 @@
     fprintf (stderr, "thread getmsg err: %s\n",
 	     thread_db_err_str (err));
 
+  /* If we do not know about the main thread yet, this would be a good time to
+     find it.  We need to do this to pick up the main thread before any newly
+     created threads.  */
+  inferior = (struct thread_info *) all_threads.head;
+  process = get_thread_process (inferior);
+  if (process->thread_known == 0)
+    thread_db_find_new_threads ();
+
   /* msg.event == TD_EVENT_CREATE */
 
   find_new_threads_callback (msg.th_p, NULL);
@@ -231,8 +242,24 @@
     {
       inferior = (struct thread_info *) all_threads.head;
       process = get_thread_process (inferior);
+
       if (process->thread_known == 0)
 	{
+	  /* If the new thread ID is zero, a final thread ID will be
+	     available later.  Do not enable thread debugging yet.  */
+	  if (ti_p->ti_tid == 0)
+	    {
+	      err = td_thr_event_enable (th_p, 1);
+	      if (err != TD_OK)
+		error ("Cannot enable thread event reporting for %d: %s",
+		       ti_p->ti_lid, thread_db_err_str (err));
+	      return;
+	    }
+
+	  if (process->lwpid != ti_p->ti_lid)
+	    fatal ("PID mismatch!  Expected %ld, got %ld",
+		   (long) process->lwpid, (long) ti_p->ti_lid);
+
 	  /* Switch to indexing the threads list by TID.  */
 	  change_inferior_id (&all_threads, ti_p->ti_tid);
 	  goto found;
@@ -331,6 +358,8 @@
 
   process = get_thread_process (thread);
   if (!process->thread_known)
+    thread_db_find_new_threads ();
+  if (!process->thread_known)
     return TD_NOTHR;
 
   err = td_thr_tls_get_addr (&process->th, (psaddr_t) load_module, offset,