From 617fd3b510ba316db1303cfcc77ac598209a8cb7 Mon Sep 17 00:00:00 2001 From: Pedro Alves Date: Mon, 8 Sep 2008 21:33:25 +0000 Subject: [PATCH] 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. --- gdb/ChangeLog | 12 +++++++ gdb/gnu-nat.c | 88 ++++++++++++++++++++++++++++++++--------------- gdb/i386gnu-nat.c | 14 ++++---- 3 files changed, 80 insertions(+), 34 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index f5acae2b2ae..a88d83e74cd 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,15 @@ +2008-09-08 Pedro Alves + + 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 * procfs.c (to_attach): Create a procinfo for the current lwp. diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c index 96531a88e0b..3c99eb502da 100644 --- 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; } @@ -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)); } @@ -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 564ace6b45f..6545d08604e 100644 --- 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) { -- 2.30.2