Use ptid_t.tid to store thread ids instead of ptid_t.pid.

	* gnu-nat.c (inf_validate_procs): If this is the first time we're
	seeing a thread id, extend the main thread's ptid.  If we still
	have pending execs, don't be verbose about new threads.
	(gnu_wait, gnu_resume, gnu_attach, gnu_thread_alive)
	(gnu_pid_to_str, cur_thread, sig_thread_cmd): Adjust.
	* i386gnu-nat.c (gnu_fetch_registers, gnu_store_registers):
	Adjust.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index f5acae2b2ae922a5dcfe77c2f54a4345b4b03c4e..a88d83e74cd8c24bd90273c83be03f910c798c76 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,15 @@
+2008-09-08  Pedro Alves  <pedro@codesourcery.com>
+
+       Use ptid_t.tid to store thread ids instead of ptid_t.pid.
+
+       * gnu-nat.c (inf_validate_procs): If this is the first time we're
+       seeing a thread id, extend the main thread's ptid.  If we still
+       have pending execs, don't be verbose about new threads.
+       (gnu_wait, gnu_resume, gnu_attach, gnu_thread_alive)
+       (gnu_pid_to_str, cur_thread, sig_thread_cmd): Adjust.
+       * i386gnu-nat.c (gnu_fetch_registers, gnu_store_registers):
+       Adjust.
+
 2008-09-08  Pedro Alves  <pedro@codesourcery.com>
 
        * procfs.c (to_attach): Create a procinfo for the current lwp.

diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index 96531a88e0bcdd868d0393d54aa3639f1ead5ed4..3c99eb502da001fa0b11320e722c74cf72abd36e 100644 (file)
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -1066,6 +1066,8 @@ inf_validate_procs (struct inf *inf)
        else
          /* THREADS[I] is a thread we don't know about yet!  */
          {
+           ptid_t ptid;
+
            thread = make_proc (inf, threads[i], next_thread_id++);
            if (last)
              last->next = thread;
@@ -1073,7 +1075,20 @@ inf_validate_procs (struct inf *inf)
              inf->threads = thread;
            last = thread;
            proc_debug (thread, "new thread: %d", threads[i]);
-           add_thread (pid_to_ptid (thread->tid));     /* Tell GDB's generic thread code.  */
+
+           ptid = ptid_build (inf->pid, 0, thread->tid);
+
+           /* Tell GDB's generic thread code.  */
+
+           if (ptid_equal (inferior_ptid, pid_to_ptid (inf->pid)))
+             /* This is the first time we're hearing about thread
+                ids, after a fork-child.  */
+             thread_change_ptid (inferior_ptid, ptid);
+           else if (inf->pending_execs != 0)
+             /* This is a shell thread.  */
+             add_thread_silent (ptid);
+           else
+             add_thread (ptid);
          }
       }
 
@@ -1418,7 +1433,7 @@ struct inf *waiting_inf;
 
 /* Wait for something to happen in the inferior, returning what in STATUS. */
 static ptid_t
-gnu_wait (ptid_t tid, struct target_waitstatus *status)
+gnu_wait (ptid_t ptid, struct target_waitstatus *status)
 {
   struct msg
     {
@@ -1449,7 +1464,7 @@ gnu_wait (ptid_t tid, struct target_waitstatus *status)
 
   waiting_inf = inf;
 
-  inf_debug (inf, "waiting for: %d", PIDGET (tid));
+  inf_debug (inf, "waiting for: %s", target_pid_to_str (ptid));
 
 rewait:
   if (proc_wait_pid != inf->pid && !inf->no_wait)
@@ -1585,20 +1600,24 @@ rewait:
 
   thread = inf->wait.thread;
   if (thread)
-    tid = pid_to_ptid (thread->tid);
+    ptid = ptid_build (inf->pid, 0, thread->tid);
+  else if (ptid_equal (ptid, minus_one_ptid))
+    thread = inf_tid_to_thread (inf, -1);
   else
-    thread = inf_tid_to_thread (inf, PIDGET (tid));
+    thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
 
   if (!thread || thread->port == MACH_PORT_NULL)
     {
       /* TID is dead; try and find a new thread.  */
       if (inf_update_procs (inf) && inf->threads)
-       tid = pid_to_ptid (inf->threads->tid); /* The first available thread.  */
+       ptid = ptid_build (inf->pid, 0, inf->threads->tid); /* The first available thread.  */
       else
-       tid = inferior_ptid;    /* let wait_for_inferior handle exit case */
+       ptid = inferior_ptid;   /* let wait_for_inferior handle exit case */
     }
 
-  if (thread && PIDGET (tid) >= 0 && status->kind != TARGET_WAITKIND_SPURIOUS
+  if (thread
+      && !ptid_equal (ptid, minus_one_ptid)
+      && status->kind != TARGET_WAITKIND_SPURIOUS
       && inf->pause_sc == 0 && thread->pause_sc == 0)
     /* If something actually happened to THREAD, make sure we
        suspend it.  */
@@ -1607,7 +1626,8 @@ rewait:
       inf_update_suspends (inf);
     }
 
-  inf_debug (inf, "returning tid = %d, status = %s (%d)", PIDGET (tid),
+  inf_debug (inf, "returning ptid = %s, status = %s (%d)",
+            target_pid_to_str (ptid),
             status->kind == TARGET_WAITKIND_EXITED ? "EXITED"
             : status->kind == TARGET_WAITKIND_STOPPED ? "STOPPED"
             : status->kind == TARGET_WAITKIND_SIGNALLED ? "SIGNALLED"
@@ -1616,7 +1636,7 @@ rewait:
             : "?",
             status->value.integer);
 
-  return tid;
+  return ptid;
 }
 
 \f
@@ -1934,12 +1954,14 @@ port_msgs_queued (mach_port_t port)
    in multiple events returned by wait).
  */
 static void
-gnu_resume (ptid_t tid, int step, enum target_signal sig)
+gnu_resume (ptid_t ptid, int step, enum target_signal sig)
 {
   struct proc *step_thread = 0;
+  int resume_all;
   struct inf *inf = current_inferior;
 
-  inf_debug (inf, "tid = %d, step = %d, sig = %d", PIDGET (tid), step, sig);
+  inf_debug (inf, "ptid = %s, step = %d, sig = %d",
+            target_pid_to_str (ptid), step, sig);
 
   inf_validate_procinfo (inf);
 
@@ -1967,30 +1989,35 @@ gnu_resume (ptid_t tid, int step, enum target_signal sig)
 
   inf_update_procs (inf);
 
-  if (PIDGET (tid) < 0)
+  /* A specific PTID means `step only this process id'.  */
+  resume_all = ptid_equal (ptid, minus_one_ptid);
+
+  if (resume_all)
     /* Allow all threads to run, except perhaps single-stepping one.  */
     {
       inf_debug (inf, "running all threads; tid = %d", PIDGET (inferior_ptid));
-      tid = inferior_ptid;     /* What to step. */
+      ptid = inferior_ptid;    /* What to step. */
       inf_set_threads_resume_sc (inf, 0, 1);
     }
   else
     /* Just allow a single thread to run.  */
     {
-      struct proc *thread = inf_tid_to_thread (inf, PIDGET (tid));
+      struct proc *thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
       if (!thread)
-       error (_("Can't run single thread id %d: no such thread!"), inf->pid);
-      inf_debug (inf, "running one thread: %d/%d", inf->pid, thread->tid);
+       error (_("Can't run single thread id %s: no such thread!"),
+              target_pid_to_str (ptid));
+      inf_debug (inf, "running one thread: %s", target_pid_to_str (ptid));
       inf_set_threads_resume_sc (inf, thread, 0);
     }
 
   if (step)
     {
-      step_thread = inf_tid_to_thread (inf, PIDGET (tid));
+      step_thread = inf_tid_to_thread (inf, ptid_get_tid (ptid));
       if (!step_thread)
-       warning (_("Can't step thread id %d: no such thread."), PIDGET (tid));
+       warning (_("Can't step thread id %s: no such thread."),
+                target_pid_to_str (ptid));
       else
-       inf_debug (inf, "stepping thread: %d/%d", inf->pid, step_thread->tid);
+       inf_debug (inf, "stepping thread: %s", target_pid_to_str (ptid));
     }
   if (step_thread != inf->step_thread)
     inf_set_step_thread (inf, step_thread);
@@ -2076,7 +2103,10 @@ gnu_create_inferior (char *exec_file, char *allargs, char **env,
     /* Now let the child run again, knowing that it will stop immediately
        because of the ptrace. */
     inf_resume (inf);
-    inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
+
+    /* We now have thread info.  */
+    thread_change_ptid (inferior_ptid,
+                       ptid_build (inf->pid, 0, inf_pick_first_thread ()));
 
     startup_inferior (inf->pending_execs);
   }
@@ -2142,7 +2172,7 @@ gnu_attach (char *args, int from_tty)
   inf_attach (inf, pid);
   inf_update_procs (inf);
 
-  inferior_ptid = pid_to_ptid (inf_pick_first_thread ());
+  inferior_ptid = ptid_build (pid, 0, inf_pick_first_thread ());
 
   attach_flag = 1;
   push_target (&gnu_ops);
@@ -2230,10 +2260,11 @@ gnu_pid_to_exec_file (int pid)
 
 
 static int
-gnu_thread_alive (ptid_t tid)
+gnu_thread_alive (ptid_t ptid)
 {
   inf_update_procs (current_inferior);
-  return !!inf_tid_to_thread (current_inferior, PIDGET (tid));
+  return !!inf_tid_to_thread (current_inferior,
+                             ptid_get_tid (ptid));
 }
 
 \f
@@ -2557,7 +2588,7 @@ proc_string (struct proc *proc)
     sprintf (tid_str, "process %d", proc->inf->pid);
   else
     sprintf (tid_str, "Thread %d.%d",
-            proc->inf->pid, pid_to_thread_id (MERGEPID (proc->tid, 0)));
+            proc->inf->pid, proc->tid);
   return tid_str;
 }
 
@@ -2565,7 +2596,7 @@ static char *
 gnu_pid_to_str (ptid_t ptid)
 {
   struct inf *inf = current_inferior;
-  int tid = PIDGET (ptid);
+  int tid = ptid_get_tid (ptid);
   struct proc *thread = inf_tid_to_thread (inf, tid);
 
   if (thread)
@@ -2706,7 +2737,8 @@ static struct proc *
 cur_thread (void)
 {
   struct inf *inf = cur_inf ();
-  struct proc *thread = inf_tid_to_thread (inf, PIDGET (inferior_ptid));
+  struct proc *thread = inf_tid_to_thread (inf,
+                                          ptid_get_tid (inferior_ptid));
   if (!thread)
     error (_("No current thread."));
   return thread;
@@ -2888,7 +2920,7 @@ set_sig_thread_cmd (char *args, int from_tty)
     inf->signal_thread = 0;
   else
     {
-      int tid = PIDGET (thread_id_to_pid (atoi (args)));
+      int tid = ptid_get_tid (thread_id_to_pid (atoi (args)));
       if (tid < 0)
        error (_("Thread ID %s not known.  Use the \"info threads\" command to\n"
               "see the IDs of currently known threads."), args);

diff --git a/gdb/i386gnu-nat.c b/gdb/i386gnu-nat.c
index 564ace6b45f5865b5a79d58416564c7b069b2780..6545d08604ebb9afa053f89a7819ff8ec2e15e12 100644 (file)
--- a/gdb/i386gnu-nat.c
+++ b/gdb/i386gnu-nat.c
@@ -118,10 +118,11 @@ gnu_fetch_registers (struct regcache *regcache, int regno)
   /* Make sure we know about new threads.  */
   inf_update_procs (current_inferior);
 
-  thread = inf_tid_to_thread (current_inferior, PIDGET (inferior_ptid));
+  thread = inf_tid_to_thread (current_inferior,
+                             ptid_get_tid (inferior_ptid));
   if (!thread)
-    error (_("Can't fetch registers from thread %d: No such thread"),
-          PIDGET (inferior_ptid));
+    error (_("Can't fetch registers from thread %s: No such thread"),
+          target_pid_to_str (inferior_ptid));
 
   if (regno < I386_NUM_GREGS || regno == -1)
     {
@@ -209,10 +210,11 @@ gnu_store_registers (struct regcache *regcache, int regno)
   /* Make sure we know about new threads.  */
   inf_update_procs (current_inferior);
 
-  thread = inf_tid_to_thread (current_inferior, PIDGET (inferior_ptid));
+  thread = inf_tid_to_thread (current_inferior,
+                             ptid_get_tid (inferior_ptid));
   if (!thread)
-    error (_("Couldn't store registers into thread %d: No such thread"),
-          PIDGET (inferior_ptid));
+    error (_("Couldn't store registers into thread %s: No such thread"),
+          target_pid_to_str (inferior_ptid));
 
   if (regno < I386_NUM_GREGS || regno == -1)
     {