* infrun.c (start_remote): Don't clear thread list here.

	* monitor.c (monitor_open): Include "gdbthread.h".  Clear thread
	list here.
	* remote.c (record_currthread): Upgrade the main thread and its
	entry in the thread list if this is the first time we hear about
	threads.
	(remote_thread_alive): Consider magic_null_ptid or a ptid without
	a tid member always alive.
	(remote_find_new_threads): Don't update the main thread here.
	(remote_start_remote): Clear thread list here.  Always add the
	main thread.
	(extended_remote_attach_1): Add the main thread here.
	(extended_remote_mourn_1): Re-add the main thread here.
	(extended_remote_create_inferior_1): Add a main thread.

	* Makefile.in (monitor.o): Depend on $(gdbthread_h).

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b964cc2..63be2c4 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,24 @@
 2008-06-27  Pedro Alves  <pedro@codesourcery.com>
 
+       * infrun.c (start_remote): Don't clear thread list here.
+       * monitor.c (monitor_open): Include "gdbthread.h".  Clear thread
+       list here.
+       * remote.c (record_currthread): Upgrade the main thread and its
+       entry in the thread list if this is the first time we hear about
+       threads.
+       (remote_thread_alive): Consider magic_null_ptid or a ptid without
+       a tid member always alive.
+       (remote_find_new_threads): Don't update the main thread here.
+       (remote_start_remote): Clear thread list here.  Always add the
+       main thread.
+       (extended_remote_attach_1): Add the main thread here.
+       (extended_remote_mourn_1): Re-add the main thread here.
+       (extended_remote_create_inferior_1): Add a main thread.
+
+       * Makefile.in (monitor.o): Depend on $(gdbthread_h).
+
+2008-06-27  Pedro Alves  <pedro@codesourcery.com>
+
        Use ptid_t.tid to store thread ids instead of ptid_t.pid.
 
        * remote.c (magic_null_ptid, not_sent_ptid, any_thread_ptid): New

diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index f88af05..36186a9 100644 (file)
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -2540,7 +2540,7 @@ mn10300-tdep.o: mn10300-tdep.c $(defs_h) $(arch_utils_h) $(dis_asm_h) \
        $(symtab_h) $(dwarf2_frame_h) $(osabi_h) $(target_h) $(mn10300_tdep_h)
 monitor.o: monitor.c $(defs_h) $(gdbcore_h) $(target_h) $(exceptions_h) \
        $(gdb_string_h) $(command_h) $(serial_h) $(monitor_h) $(gdbcmd_h) \
-       $(inferior_h) $(gdb_regex_h) $(srec_h) $(regcache_h)
+       $(inferior_h) $(gdb_regex_h) $(srec_h) $(regcache_h) $(gdbthread_h)
 mt-tdep.o: mt-tdep.c $(defs_h) $(frame_h) $(frame_unwind_h) $(frame_base_h) \
        $(symtab_h) $(dis_asm_h) $(arch_utils_h) $(gdbtypes_h) \
        $(gdb_string_h) $(regcache_h) $(reggroups_h) $(gdbcore_h) \

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 8aa8039..73b92be 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1281,7 +1281,6 @@ proceed (CORE_ADDR addr, enum target_signal siggnal, int step)
 void
 start_remote (int from_tty)
 {
-  init_thread_list ();
   init_wait_for_inferior ();
   stop_soon = STOP_QUIETLY_REMOTE;
   stepping_over_breakpoint = 0;

diff --git a/gdb/monitor.c b/gdb/monitor.c
index 41308de..43abd02 100644 (file)
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -54,6 +54,7 @@
 #include "gdb_regex.h"
 #include "srec.h"
 #include "regcache.h"
+#include "gdbthread.h"
 
 static char *dev_name;
 static struct target_ops *targ_ops;
@@ -804,6 +805,9 @@ monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
 
   push_target (targ_ops);
 
+  /* Start afresh.  */
+  init_thread_list ();
+
   inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */
 
   /* Give monitor_wait something to read */

diff --git a/gdb/remote.c b/gdb/remote.c
index 62780da..32ee5e4 100644 (file)
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -1089,7 +1089,31 @@ record_currthread (ptid_t 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 (currthread))
-    add_thread (currthread);
+    {
+      if (ptid_equal (pid_to_ptid (ptid_get_pid (currthread)), inferior_ptid))
+       {
+         /* inferior_ptid has no thread member yet.  This can happen
+            with the vAttach -> remote_wait,"TAAthread:" path if the
+            stub doesn't support qC.  This is the first stop reported
+            after an attach, so this is the main thread.  Update the
+            ptid in the thread list.  */
+         struct thread_info *th = find_thread_pid (inferior_ptid);
+         inferior_ptid = th->ptid = currthread;
+       }
+      else if (ptid_equal (magic_null_ptid, inferior_ptid))
+       {
+         /* inferior_ptid is not set yet.  This can happen with the
+            vRun -> remote_wait,"TAAthread:" path if the stub
+            doesn't support qC.  This is the first stop reported
+            after an attach, so this is the main thread.  Update the
+            ptid in the thread list.  */
+         struct thread_info *th = find_thread_pid (inferior_ptid);
+         inferior_ptid = th->ptid = currthread;
+       }
+      else
+       /* This is really a new thread.  Add it.  */
+       add_thread (currthread);
+    }
 }
 
 static char *last_pass_packet;
@@ -1212,6 +1236,16 @@ remote_thread_alive (ptid_t ptid)
   struct remote_state *rs = get_remote_state ();
   int tid = ptid_get_tid (ptid);
 
+  if (ptid_equal (ptid, magic_null_ptid))
+    /* The main thread is always alive.  */
+    return 1;
+
+  if (ptid_get_pid (ptid) != 0 && ptid_get_tid (ptid) == 0)
+    /* The main thread is always alive.  This can happen after a
+       vAttach, if the remote side doesn't support
+       multi-threading.  */
+    return 1;
+
   if (tid < 0)
     xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid);
   else
@@ -1925,9 +1959,6 @@ remote_find_new_threads (void)
 {
   remote_threadlist_iterator (remote_newthread_step, 0,
                              CRAZY_MAX_THREADS);
-  if (ptid_equal (inferior_ptid, magic_null_ptid))
-    /* We don't know the current thread yet.  Query it.  */
-    inferior_ptid = remote_current_thread (inferior_ptid);
 }
 
 /*
@@ -2289,6 +2320,9 @@ remote_start_remote (struct ui_out *uiout, void *opaque)
       strcpy (wait_status, rs->buf);
     }
 
+  /* Start afresh.  */
+  init_thread_list ();
+
   /* Let the stub know that we want it to return the thread.  */
   set_continue_thread (minus_one_ptid);
 
@@ -2304,6 +2338,9 @@ remote_start_remote (struct ui_out *uiout, void *opaque)
   /* Now, if we have thread information, update inferior_ptid.  */
   inferior_ptid = remote_current_thread (inferior_ptid);
 
+  /* Always add the main thread.  */
+  add_thread_silent (inferior_ptid);
+
   get_offsets ();              /* Get text, data & bss offsets.  */
 
   /* Use the previously fetched status.  */
@@ -2934,6 +2971,9 @@ extended_remote_attach_1 (struct target_ops *target, char *args, int from_tty)
   /* Now, if we have thread information, update inferior_ptid.  */
   inferior_ptid = remote_current_thread (inferior_ptid);
 
+  /* Now, add the main thread to the thread list.  */
+  add_thread_silent (inferior_ptid);
+
   attach_flag = 1;
 
   /* Next, if the target can specify a description, read it.  We do
@@ -5152,7 +5192,8 @@ extended_remote_mourn_1 (struct target_ops *target)
       /* Assume that the target has been restarted.  Set inferior_ptid
         so that bits of core GDB realizes there's something here, e.g.,
         so that the user can say "kill" again.  */
-      inferior_ptid = magic_null_ptid;
+      inferior_ptid = remote_current_thread (magic_null_ptid);
+      add_thread_silent (inferior_ptid);
     }
   else
     {
@@ -5267,6 +5308,9 @@ extended_remote_create_inferior_1 (char *exec_file, char *args,
   /* Now mark the inferior as running before we do anything else.  */
   attach_flag = 0;
   inferior_ptid = magic_null_ptid;
+
+  add_thread_silent (inferior_ptid);
+
   target_mark_running (&extended_remote_ops);
 
   /* Get updated offsets, if the stub uses qOffsets.  */