From 5fd5a4af88d89db13e4f477f20f16882b5917485 Mon Sep 17 00:00:00 2001 From: palves Date: Fri, 27 Jun 2008 11:31:39 +0000 Subject: [PATCH] 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 globals. (general_thread, continue_thread): Change type to ptid_t. (record_currthread): Take a ptid_t parameter instead of an integer. (MAGIC_NULL_PID): Delete. (set_thread): Take a ptid_t parameter and adjust. (set_general_thread, set_continue_thread): New. (remote_thread_alive, remote_newthread_step) (remote_current_thread, remote_find_new_threads) (remote_threads_info, remote_start_remote, remote_vcont_resume) (remote_resume_1, remote_wait, extended_remote_create_inferior_1) (threadalive_test, remote_pid_to_str) (remote_get_thread_local_address): Adjust. (_initialize_remote): Initialize magic_null_ptid, not_sent_ptid and any_thread_ptid. --- gdb/ChangeLog | 21 ++++++ gdb/remote.c | 238 +++++++++++++++++++++++++++++++++++++--------------------- 2 files changed, 172 insertions(+), 87 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 1cfee74ad8..3d18d21d85 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,24 @@ +2008-06-26 Pedro Alves + + 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 + globals. + (general_thread, continue_thread): Change type to ptid_t. + (record_currthread): Take a ptid_t parameter instead of an + integer. + (MAGIC_NULL_PID): Delete. + (set_thread): Take a ptid_t parameter and adjust. + (set_general_thread, set_continue_thread): New. + (remote_thread_alive, remote_newthread_step) + (remote_current_thread, remote_find_new_threads) + (remote_threads_info, remote_start_remote, remote_vcont_resume) + (remote_resume_1, remote_wait, extended_remote_create_inferior_1) + (threadalive_test, remote_pid_to_str) + (remote_get_thread_local_address): Adjust. + (_initialize_remote): Initialize magic_null_ptid, not_sent_ptid + and any_thread_ptid. + 2008-06-26 Jan Kratochvil * configure.ac (--enable-tui): AC_MSG_ERROR for explicit --enable-tui. diff --git a/gdb/remote.c b/gdb/remote.c index ddf259c510..62780da76a 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -138,7 +138,8 @@ static void remote_interrupt_twice (int signo); static void interrupt_query (void); -static void set_thread (int, int); +static void set_general_thread (struct ptid ptid); +static void set_continue_thread (struct ptid ptid); static int remote_thread_alive (ptid_t); @@ -180,7 +181,7 @@ static ptid_t remote_current_thread (ptid_t oldptid); static void remote_find_new_threads (void); -static void record_currthread (int currthread); +static void record_currthread (ptid_t currthread); static int fromhex (int a); @@ -1063,11 +1064,16 @@ static struct async_signal_handler *sigint_remote_token; +static ptid_t magic_null_ptid; +static ptid_t not_sent_ptid; +static ptid_t any_thread_ptid; + +/* These are the threads which we last sent to the remote system. The + TID member will be -1 for all or -2 for not sent yet. */ + +static ptid_t general_thread; +static ptid_t continue_thread; -/* These are the threads which we last sent to the remote system. - -1 for all or -2 for not sent yet. */ -static int general_thread; -static int continue_thread; /* Call this function as a result of 1) A halt indication (T packet) containing a thread id @@ -1076,14 +1082,14 @@ static int continue_thread; */ static void -record_currthread (int currthread) +record_currthread (ptid_t currthread) { general_thread = 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 (pid_to_ptid (currthread))) - add_thread (pid_to_ptid (currthread)); + if (!in_thread_list (currthread)) + add_thread (currthread); } static char *last_pass_packet; @@ -1145,44 +1151,66 @@ remote_pass_signals (void) } } -#define MAGIC_NULL_PID 42000 - +/* If PTID is MAGIC_NULL_PTID, don't set any thread. If PTID is + MINUS_ONE_PTID, set the thread to -1, so the stub returns the + thread. If GEN is set, set the general thread, if not, then set + the step/continue thread. */ static void -set_thread (int th, int gen) +set_thread (struct ptid ptid, int gen) { struct remote_state *rs = get_remote_state (); + ptid_t state = gen ? general_thread : continue_thread; char *buf = rs->buf; - int state = gen ? general_thread : continue_thread; + char *endbuf = rs->buf + get_remote_packet_size (); - if (state == th) + if (ptid_equal (state, ptid)) return; - buf[0] = 'H'; - buf[1] = gen ? 'g' : 'c'; - if (th == MAGIC_NULL_PID) + *buf++ = 'H'; + *buf++ = gen ? 'g' : 'c'; + if (ptid_equal (ptid, magic_null_ptid)) + xsnprintf (buf, endbuf - buf, "0"); + else if (ptid_equal (ptid, any_thread_ptid)) + xsnprintf (buf, endbuf - buf, "0"); + else if (ptid_equal (ptid, minus_one_ptid)) + xsnprintf (buf, endbuf - buf, "-1"); + else { - buf[2] = '0'; - buf[3] = '\0'; + int tid = ptid_get_tid (ptid); + if (tid < 0) + xsnprintf (buf, endbuf - buf, "-%x", -tid); + else + xsnprintf (buf, endbuf - buf, "%x", tid); } - else if (th < 0) - xsnprintf (&buf[2], get_remote_packet_size () - 2, "-%x", -th); - else - xsnprintf (&buf[2], get_remote_packet_size () - 2, "%x", th); - putpkt (buf); + putpkt (rs->buf); getpkt (&rs->buf, &rs->buf_size, 0); if (gen) - general_thread = th; + general_thread = ptid; else - continue_thread = th; + continue_thread = ptid; } + +static void +set_general_thread (struct ptid ptid) +{ + set_thread (ptid, 1); +} + +static void +set_continue_thread (struct ptid ptid) +{ + set_thread (ptid, 0); +} + -/* Return nonzero if the thread TH is still alive on the remote system. */ +/* Return nonzero if the thread PTID is still alive on the remote + system. */ static int remote_thread_alive (ptid_t ptid) { struct remote_state *rs = get_remote_state (); - int tid = PIDGET (ptid); + int tid = ptid_get_tid (ptid); if (tid < 0) xsnprintf (rs->buf, get_remote_packet_size (), "T-%08x", -tid); @@ -1802,7 +1830,7 @@ remote_get_threadlist (int startflag, threadref *nextthread, int result_limit, /* remote_find_new_threads retrieves the thread list and for each thread in the list, looks up the thread in GDB's internal list, - ading the thread if it does not already exist. This involves + adding the thread if it does not already exist. This involves getting partial thread lists from the remote target so, polling the quit_flag is required. */ @@ -1853,9 +1881,8 @@ remote_threadlist_iterator (rmt_thread_action stepfunction, void *context, static int remote_newthread_step (threadref *ref, void *context) { - ptid_t ptid; - - ptid = pid_to_ptid (threadref_to_int (ref)); + int pid = ptid_get_pid (inferior_ptid); + ptid_t ptid = ptid_build (pid, 0, threadref_to_int (ref)); if (!in_thread_list (ptid)) add_thread (ptid); @@ -1868,16 +1895,23 @@ static ptid_t remote_current_thread (ptid_t oldpid) { struct remote_state *rs = get_remote_state (); + char *p = rs->buf; + int tid; + int pid; putpkt ("qC"); getpkt (&rs->buf, &rs->buf_size, 0); if (rs->buf[0] == 'Q' && rs->buf[1] == 'C') - /* Use strtoul here, so we'll correctly parse values whose highest - bit is set. The protocol carries them as a simple series of - hex digits; in the absence of a sign, strtol will see such - values as positive numbers out of range for signed 'long', and - return LONG_MAX to indicate an overflow. */ - return pid_to_ptid (strtoul (&rs->buf[2], NULL, 16)); + { + /* Use strtoul here, so we'll correctly parse values whose + highest bit is set. The protocol carries them as a simple + series of hex digits; in the absence of a sign, strtol will + see such values as positive numbers out of range for signed + 'long', and return LONG_MAX to indicate an overflow. */ + tid = strtoul (&rs->buf[2], NULL, 16); + pid = ptid_get_pid (oldpid); + return ptid_build (pid, 0, tid); + } else return oldpid; } @@ -1891,7 +1925,8 @@ remote_find_new_threads (void) { remote_threadlist_iterator (remote_newthread_step, 0, CRAZY_MAX_THREADS); - if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) /* ack ack ack */ + 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); } @@ -1908,6 +1943,8 @@ remote_threads_info (void) struct remote_state *rs = get_remote_state (); char *bufp; int tid; + int pid; + ptid_t new_thread; if (remote_desc == 0) /* paranoia */ error (_("Command can only be used when connected to the remote target.")); @@ -1930,8 +1967,10 @@ remote_threads_info (void) positive numbers out of range for signed 'long', and return LONG_MAX to indicate an overflow. */ tid = strtoul (bufp, &bufp, 16); - if (tid != 0 && !in_thread_list (pid_to_ptid (tid))) - add_thread (pid_to_ptid (tid)); + pid = ptid_get_pid (inferior_ptid); + new_thread = ptid_build (pid, 0, tid); + if (tid != 0 && !in_thread_list (new_thread)) + add_thread (new_thread); } while (*bufp++ == ','); /* comma-separated list */ putpkt ("qsThreadInfo"); @@ -1974,8 +2013,8 @@ remote_threads_extra_info (struct thread_info *tp) if (use_threadextra_query) { - xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%x", - PIDGET (tp->ptid)); + xsnprintf (rs->buf, get_remote_packet_size (), "qThreadExtraInfo,%lx", + ptid_get_tid (tp->ptid)); putpkt (rs->buf); getpkt (&rs->buf, &rs->buf_size, 0); if (rs->buf[0] != 0) @@ -1991,7 +2030,7 @@ remote_threads_extra_info (struct thread_info *tp) use_threadextra_query = 0; set = TAG_THREADID | TAG_EXISTS | TAG_THREADNAME | TAG_MOREDISPLAY | TAG_DISPLAY; - int_to_threadref (&id, PIDGET (tp->ptid)); + int_to_threadref (&id, ptid_get_tid (tp->ptid)); if (remote_get_threadinfo (&id, set, &threadinfo)) if (threadinfo.active) { @@ -2251,7 +2290,7 @@ remote_start_remote (struct ui_out *uiout, void *opaque) } /* Let the stub know that we want it to return the thread. */ - set_thread (-1, 0); + set_continue_thread (minus_one_ptid); /* Without this, some commands which require an active target (such as kill) won't work. This variable serves (at least) @@ -2260,7 +2299,7 @@ remote_start_remote (struct ui_out *uiout, void *opaque) These functions should be split out into seperate variables, especially since GDB will someday have a notion of debugging several processes. */ - inferior_ptid = pid_to_ptid (MAGIC_NULL_PID); + inferior_ptid = magic_null_ptid; /* Now, if we have thread information, update inferior_ptid. */ inferior_ptid = remote_current_thread (inferior_ptid); @@ -2690,8 +2729,8 @@ remote_open_1 (char *name, int from_tty, struct target_ops *target, int extended init_all_packet_configs (); rs->explicit_packet_size = 0; - general_thread = -2; - continue_thread = -2; + general_thread = not_sent_ptid; + continue_thread = not_sent_ptid; /* Probe for ability to use "ThreadInfo" query, as required. */ use_threadinfo_query = 1; @@ -2891,6 +2930,10 @@ extended_remote_attach_1 (struct target_ops *target, char *args, int from_tty) target_mark_running (target); inferior_ptid = pid_to_ptid (pid); + + /* Now, if we have thread information, update inferior_ptid. */ + inferior_ptid = remote_current_thread (inferior_ptid); + attach_flag = 1; /* Next, if the target can specify a description, read it. We do @@ -3020,10 +3063,10 @@ remote_vcont_probe (struct remote_state *rs) /* Resume the remote inferior by using a "vCont" packet. The thread to be resumed is PTID; STEP and SIGGNAL indicate whether the - resumed thread should be single-stepped and/or signalled. If PTID's - PID is -1, then all threads are resumed; the thread to be stepped and/or - signalled is given in the global INFERIOR_PTID. This function returns - non-zero iff it resumes the inferior. + resumed thread should be single-stepped and/or signalled. If PTID + equals minus_one_ptid, then all threads are resumed; the thread to + be stepped and/or signalled is given in the global INFERIOR_PTID. + This function returns non-zero iff it resumes the inferior. This function issues a strict subset of all possible vCont commands at the moment. */ @@ -3032,7 +3075,6 @@ static int remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal) { struct remote_state *rs = get_remote_state (); - int pid = PIDGET (ptid); char *outbuf; struct cleanup *old_cleanup; @@ -3046,11 +3088,12 @@ remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal) about overflowing BUF. Should there be a generic "multi-part-packet" packet? */ - if (PIDGET (inferior_ptid) == MAGIC_NULL_PID) + if (ptid_equal (ptid, magic_null_ptid)) { - /* MAGIC_NULL_PTID means that we don't have any active threads, so we - don't have any PID numbers the inferior will understand. Make sure - to only send forms that do not specify a PID. */ + /* MAGIC_NULL_PTID means that we don't have any active threads, + so we don't have any TID numbers the inferior will + understand. Make sure to only send forms that do not specify + a TID. */ if (step && siggnal != TARGET_SIGNAL_0) outbuf = xstrprintf ("vCont;S%02x", siggnal); else if (step) @@ -3060,31 +3103,31 @@ remote_vcont_resume (ptid_t ptid, int step, enum target_signal siggnal) else outbuf = xstrprintf ("vCont;c"); } - else if (pid == -1) + else if (ptid_equal (ptid, minus_one_ptid)) { /* Resume all threads, with preference for INFERIOR_PTID. */ + int tid = ptid_get_tid (inferior_ptid); if (step && siggnal != TARGET_SIGNAL_0) - outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal, - PIDGET (inferior_ptid)); + outbuf = xstrprintf ("vCont;S%02x:%x;c", siggnal, tid); else if (step) - outbuf = xstrprintf ("vCont;s:%x;c", PIDGET (inferior_ptid)); + outbuf = xstrprintf ("vCont;s:%x;c", tid); else if (siggnal != TARGET_SIGNAL_0) - outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal, - PIDGET (inferior_ptid)); + outbuf = xstrprintf ("vCont;C%02x:%x;c", siggnal, tid); else outbuf = xstrprintf ("vCont;c"); } else { /* Scheduler locking; resume only PTID. */ + int tid = ptid_get_tid (ptid); if (step && siggnal != TARGET_SIGNAL_0) - outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, pid); + outbuf = xstrprintf ("vCont;S%02x:%x", siggnal, tid); else if (step) - outbuf = xstrprintf ("vCont;s:%x", pid); + outbuf = xstrprintf ("vCont;s:%x", tid); else if (siggnal != TARGET_SIGNAL_0) - outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, pid); + outbuf = xstrprintf ("vCont;C%02x:%x", siggnal, tid); else - outbuf = xstrprintf ("vCont;c:%x", pid); + outbuf = xstrprintf ("vCont;c:%x", tid); } gdb_assert (outbuf && strlen (outbuf) < get_remote_packet_size ()); @@ -3108,7 +3151,6 @@ remote_resume (ptid_t ptid, int step, enum target_signal siggnal) { struct remote_state *rs = get_remote_state (); char *buf; - int pid = PIDGET (ptid); last_sent_signal = siggnal; last_sent_step = step; @@ -3120,11 +3162,12 @@ remote_resume (ptid_t ptid, int step, enum target_signal siggnal) if (remote_vcont_resume (ptid, step, siggnal)) goto done; - /* All other supported resume packets do use Hc, so call set_thread. */ - if (pid == -1) - set_thread (0, 0); /* Run any thread. */ + /* All other supported resume packets do use Hc, so set the continue + thread. */ + if (ptid_equal (ptid, minus_one_ptid)) + set_continue_thread (any_thread_ptid); else - set_thread (pid, 0); /* Run this thread. */ + set_continue_thread (ptid); buf = rs->buf; if (siggnal != TARGET_SIGNAL_0) @@ -3347,9 +3390,7 @@ remote_console_output (char *msg) } /* Wait until the remote machine stops, then return, - storing status in STATUS just as `wait' would. - Returns "pid", which in the case of a multi-threaded - remote OS, is the thread-id. */ + storing status in STATUS just as `wait' would. */ static ptid_t remote_wait (ptid_t ptid, struct target_waitstatus *status) @@ -3357,6 +3398,7 @@ remote_wait (ptid_t ptid, struct target_waitstatus *status) struct remote_state *rs = get_remote_state (); struct remote_arch_state *rsa = get_remote_arch_state (); ULONGEST thread_num = -1; + ULONGEST process_num = -1; ULONGEST addr; int solibs_changed = 0; @@ -3453,7 +3495,6 @@ Packet: '%s'\n"), if (strncmp (p, "thread", p1 - p) == 0) { p_temp = unpack_varlen_hex (++p1, &thread_num); - record_currthread (thread_num); p = p_temp; } else if ((strncmp (p, "watch", p1 - p) == 0) @@ -3575,8 +3616,12 @@ Packet: '%s'\n"), got_status: if (thread_num != -1) { - return pid_to_ptid (thread_num); + ptid_t ptid; + ptid = ptid_build (ptid_get_pid (inferior_ptid), 0, thread_num); + record_currthread (ptid); + return ptid; } + return inferior_ptid; } @@ -3779,7 +3824,7 @@ remote_fetch_registers (struct regcache *regcache, int regnum) struct remote_arch_state *rsa = get_remote_arch_state (); int i; - set_thread (PIDGET (inferior_ptid), 1); + set_general_thread (inferior_ptid); if (regnum >= 0) { @@ -3928,7 +3973,7 @@ remote_store_registers (struct regcache *regcache, int regnum) struct remote_arch_state *rsa = get_remote_arch_state (); int i; - set_thread (PIDGET (inferior_ptid), 1); + set_general_thread (inferior_ptid); if (regnum >= 0) { @@ -5107,7 +5152,7 @@ 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 = pid_to_ptid (MAGIC_NULL_PID); + inferior_ptid = magic_null_ptid; } else { @@ -5221,7 +5266,7 @@ 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 = pid_to_ptid (MAGIC_NULL_PID); + inferior_ptid = magic_null_ptid; target_mark_running (&extended_remote_ops); /* Get updated offsets, if the stub uses qOffsets. */ @@ -6143,7 +6188,7 @@ threadset_test_cmd (char *cmd, int tty) int sample_thread = SAMPLE_THREAD; printf_filtered (_("Remote threadset test\n")); - set_thread (sample_thread, 1); + set_general_thread (sample_thread); } @@ -6151,8 +6196,10 @@ static void threadalive_test (char *cmd, int tty) { int sample_thread = SAMPLE_THREAD; + int pid = ptid_get_pid (inferior_ptid); + ptid_t ptid = ptid_build (pid, 0, sample_thread); - if (remote_thread_alive (pid_to_ptid (sample_thread))) + if (remote_thread_alive (ptid)) printf_filtered ("PASS: Thread alive test\n"); else printf_filtered ("FAIL: Thread alive test\n"); @@ -6265,10 +6312,21 @@ Fetch and print the remote list of thread identifiers, one pkt only")); static char * remote_pid_to_str (ptid_t ptid) { - static char buf[32]; + static char buf[64]; - xsnprintf (buf, sizeof buf, "Thread %d", ptid_get_pid (ptid)); - return buf; + if (ptid_equal (magic_null_ptid, ptid)) + { + xsnprintf (buf, sizeof buf, "Thread
"); + return buf; + } + else if (ptid_get_tid (ptid) != 0) + { + xsnprintf (buf, sizeof buf, "Thread %ld", + ptid_get_tid (ptid)); + return buf; + } + + return normal_pid_to_str (ptid); } /* Get the address of the thread local variable in OBJFILE which is @@ -6285,7 +6343,7 @@ remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset) strcpy (p, "qGetTLSAddr:"); p += strlen (p); - p += hexnumstr (p, PIDGET (ptid)); + p += hexnumstr (p, ptid_get_tid (ptid)); *p++ = ','; p += hexnumstr (p, offset); *p++ = ','; @@ -7479,4 +7537,10 @@ Tells gdb whether to control the remote inferior in asynchronous mode."), /* Eventually initialize fileio. See fileio.c */ initialize_remote_fileio (remote_set_cmdlist, remote_show_cmdlist); + + /* Take advantage of the fact that the LWP field is not used, to tag + special ptids with it set to != 0. */ + magic_null_ptid = ptid_build (0, 1, -1); + not_sent_ptid = ptid_build (0, 1, -2); + any_thread_ptid = ptid_build (0, 1, 0); } -- 2.11.0