Add a new function to print a thread ID, in the style of paddress,
plongest, etc. and adjust all CLI-reachable paths to use it.
This gives us a single place to tweak to print inferior-qualified
thread IDs later:
- [Switching to thread 1 (Thread 0x7ffff7fc2740 (LWP 8155))]
+ [Switching to thread 1.1 (Thread 0x7ffff7fc2740 (LWP 8155))]
etc., though for now, this has no user-visible change.
No regressions on x86_64 Fedora 20.
gdb/ChangeLog:
2016-01-13 Pedro Alves <palves@redhat.com>
* breakpoint.c (remove_threaded_breakpoints)
(print_one_breakpoint_location): Use print_thread_id.
* btrace.c (btrace_enable, btrace_disable, btrace_teardown)
(btrace_fetch, btrace_clear): Use print_thread_id.
* common/print-utils.c (CELLSIZE): Delete.
(get_cell): Rename to ...
(get_print_cell): ... this and made extern. Adjust call callers.
Adjust to use PRINT_CELL_SIZE.
* common/print-utils.h (get_print_cell): Declare.
(PRINT_CELL_SIZE): New.
* gdbthread.h (print_thread_id): Declare.
* infcmd.c (signal_command): Use print_thread_id.
* inferior.c (print_inferior): Use print_thread_id.
* infrun.c (handle_signal_stop)
(insert_exception_resume_breakpoint)
(insert_exception_resume_from_probe)
(print_signal_received_reason): Use print_thread_id.
* record-btrace.c (record_btrace_info)
(record_btrace_resume_thread, record_btrace_cancel_resume)
(record_btrace_step_thread, record_btrace_wait): Use
print_thread_id.
* thread.c (thread_apply_all_command): Use print_thread_id.
(print_thread_id): New function.
(thread_apply_command): Use print_thread_id.
(thread_command, thread_find_command, do_captured_thread_select):
Use print_thread_id.
+2016-01-13 Pedro Alves <palves@redhat.com>
+
+ * breakpoint.c (remove_threaded_breakpoints)
+ (print_one_breakpoint_location): Use print_thread_id.
+ * btrace.c (btrace_enable, btrace_disable, btrace_teardown)
+ (btrace_fetch, btrace_clear): Use print_thread_id.
+ * common/print-utils.c (CELLSIZE): Delete.
+ (get_cell): Rename to ...
+ (get_print_cell): ... this and made extern. Adjust call callers.
+ Adjust to use PRINT_CELL_SIZE.
+ * common/print-utils.h (get_print_cell): Declare.
+ (PRINT_CELL_SIZE): New.
+ * gdbthread.h (print_thread_id): Declare.
+ * infcmd.c (signal_command): Use print_thread_id.
+ * inferior.c (print_inferior): Use print_thread_id.
+ * infrun.c (handle_signal_stop)
+ (insert_exception_resume_breakpoint)
+ (insert_exception_resume_from_probe)
+ (print_signal_received_reason): Use print_thread_id.
+ * record-btrace.c (record_btrace_info)
+ (record_btrace_resume_thread, record_btrace_cancel_resume)
+ (record_btrace_step_thread, record_btrace_wait): Use
+ print_thread_id.
+ * thread.c (thread_apply_all_command): Use print_thread_id.
+ (print_thread_id): New function.
+ (thread_apply_command): Use print_thread_id.
+ (thread_command, thread_find_command, do_captured_thread_select):
+ Use print_thread_id.
+
2016-01-13 Pedro Alves <palves@redhat.com>
* NEWS: Mention InferiorThread.inferior.
b->disposition = disp_del_at_next_stop;
printf_filtered (_("\
-Thread-specific breakpoint %d deleted - thread %d no longer in the thread list.\n"),
- b->number, tp->num);
+Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
+ b->number, print_thread_id (tp));
/* Hide it from the user. */
b->number = 0;
if (!part_of_multiple && b->thread != -1)
{
+ struct thread_info *thr = find_thread_id (b->thread);
+
/* FIXME should make an annotation for this. */
ui_out_text (uiout, "\tstop only in thread ");
- ui_out_field_int (uiout, "thread", b->thread);
+ ui_out_field_string (uiout, "thread", print_thread_id (thr));
ui_out_text (uiout, "\n");
}
if (!target_supports_btrace (conf->format))
error (_("Target does not support branch tracing."));
- DEBUG ("enable thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
+ DEBUG ("enable thread %s (%s)", print_thread_id (tp),
+ target_pid_to_str (tp->ptid));
tp->btrace.target = target_enable_btrace (tp->ptid, conf);
if (btp->target == NULL)
return;
- DEBUG ("disable thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
+ DEBUG ("disable thread %s (%s)", print_thread_id (tp),
+ target_pid_to_str (tp->ptid));
target_disable_btrace (btp->target);
btp->target = NULL;
if (btp->target == NULL)
return;
- DEBUG ("teardown thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
+ DEBUG ("teardown thread %s (%s)", print_thread_id (tp),
+ target_pid_to_str (tp->ptid));
target_teardown_btrace (btp->target);
btp->target = NULL;
struct cleanup *cleanup;
int errcode;
- DEBUG ("fetch thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
+ DEBUG ("fetch thread %s (%s)", print_thread_id (tp),
+ target_pid_to_str (tp->ptid));
btinfo = &tp->btrace;
tinfo = btinfo->target;
struct btrace_thread_info *btinfo;
struct btrace_function *it, *trash;
- DEBUG ("clear thread %d (%s)", tp->num, target_pid_to_str (tp->ptid));
+ DEBUG ("clear thread %s (%s)", print_thread_id (tp),
+ target_pid_to_str (tp->ptid));
/* Make sure btrace frames that may hold a pointer into the branch
trace data are destroyed. */
#include "print-utils.h"
/* Temporary storage using circular buffer. */
+/* Number of cells in the circular buffer. */
#define NUMCELLS 16
-#define CELLSIZE 50
/* Return the next entry in the circular buffer. */
-static char *
-get_cell (void)
+char *
+get_print_cell (void)
{
- static char buf[NUMCELLS][CELLSIZE];
+ static char buf[NUMCELLS][PRINT_CELL_SIZE];
static int cell = 0;
if (++cell >= NUMCELLS)
/* Steal code from valprint.c:print_decimal(). Should this worry
about the real size of addr as the above does? */
unsigned long temp[3];
- char *str = get_cell ();
+ char *str = get_print_cell ();
int i = 0;
do
switch (i)
{
case 1:
- xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
+ xsnprintf (str, PRINT_CELL_SIZE, "%s%0*lu", sign, width, temp[0]);
break;
case 2:
- xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
+ xsnprintf (str, PRINT_CELL_SIZE, "%s%0*lu%09lu", sign, width,
temp[1], temp[0]);
break;
case 3:
- xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
+ xsnprintf (str, PRINT_CELL_SIZE, "%s%0*lu%09lu%09lu", sign, width,
temp[2], temp[1], temp[0]);
break;
default:
octal2str (ULONGEST addr, int width)
{
unsigned long temp[3];
- char *str = get_cell ();
+ char *str = get_print_cell ();
int i = 0;
do
{
case 1:
if (temp[0] == 0)
- xsnprintf (str, CELLSIZE, "%*o", width, 0);
+ xsnprintf (str, PRINT_CELL_SIZE, "%*o", width, 0);
else
- xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
+ xsnprintf (str, PRINT_CELL_SIZE, "0%0*lo", width, temp[0]);
break;
case 2:
- xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
+ xsnprintf (str, PRINT_CELL_SIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
break;
case 3:
- xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
+ xsnprintf (str, PRINT_CELL_SIZE, "0%0*lo%010lo%010lo", width,
temp[2], temp[1], temp[0]);
break;
default:
switch (sizeof_l)
{
case 8:
- str = get_cell ();
- xsnprintf (str, CELLSIZE, "%08lx%08lx",
+ str = get_print_cell ();
+ xsnprintf (str, PRINT_CELL_SIZE, "%08lx%08lx",
(unsigned long) (l >> thirty_two),
(unsigned long) (l & 0xffffffff));
break;
case 4:
- str = get_cell ();
- xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
+ str = get_print_cell ();
+ xsnprintf (str, PRINT_CELL_SIZE, "%08lx", (unsigned long) l);
break;
case 2:
- str = get_cell ();
- xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
+ str = get_print_cell ();
+ xsnprintf (str, PRINT_CELL_SIZE, "%04x", (unsigned short) (l & 0xffff));
break;
default:
str = phex (l, sizeof (l));
{
unsigned long high = (unsigned long) (l >> thirty_two);
- str = get_cell ();
+ str = get_print_cell ();
if (high == 0)
- xsnprintf (str, CELLSIZE, "%lx",
+ xsnprintf (str, PRINT_CELL_SIZE, "%lx",
(unsigned long) (l & 0xffffffff));
else
- xsnprintf (str, CELLSIZE, "%lx%08lx", high,
+ xsnprintf (str, PRINT_CELL_SIZE, "%lx%08lx", high,
(unsigned long) (l & 0xffffffff));
break;
}
case 4:
- str = get_cell ();
- xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
+ str = get_print_cell ();
+ xsnprintf (str, PRINT_CELL_SIZE, "%lx", (unsigned long) l);
break;
case 2:
- str = get_cell ();
- xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
+ str = get_print_cell ();
+ xsnprintf (str, PRINT_CELL_SIZE, "%x", (unsigned short) (l & 0xffff));
break;
default:
str = phex_nz (l, sizeof (l));
char *
hex_string (LONGEST num)
{
- char *result = get_cell ();
+ char *result = get_print_cell ();
- xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
+ xsnprintf (result, PRINT_CELL_SIZE, "0x%s", phex_nz (num, sizeof (num)));
return result;
}
char *
hex_string_custom (LONGEST num, int width)
{
- char *result = get_cell ();
- char *result_end = result + CELLSIZE - 1;
+ char *result = get_print_cell ();
+ char *result_end = result + PRINT_CELL_SIZE - 1;
const char *hex = phex_nz (num, sizeof (num));
int hex_len = strlen (hex);
if (hex_len > width)
width = hex_len;
- if (width + 2 >= CELLSIZE)
+ if (width + 2 >= PRINT_CELL_SIZE)
internal_error (__FILE__, __LINE__, _("\
hex_string_custom: insufficient space to store result"));
const char *
core_addr_to_string (const CORE_ADDR addr)
{
- char *str = get_cell ();
+ char *str = get_print_cell ();
strcpy (str, "0x");
strcat (str, phex (addr, sizeof (addr)));
const char *
core_addr_to_string_nz (const CORE_ADDR addr)
{
- char *str = get_cell ();
+ char *str = get_print_cell ();
strcpy (str, "0x");
strcat (str, phex_nz (addr, sizeof (addr)));
const char *
host_address_to_string_1 (const void *addr)
{
- char *str = get_cell ();
+ char *str = get_print_cell ();
- xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr)));
+ xsnprintf (str, PRINT_CELL_SIZE, "0x%s",
+ phex_nz ((uintptr_t) addr, sizeof (addr)));
return str;
}
#ifndef COMMON_CELLS_H
#define COMMON_CELLS_H
+/* How many characters (including the terminating null byte) fit in a
+ cell. */
+#define PRINT_CELL_SIZE 50
+
/* %d for LONGEST. The result is stored in a circular static buffer,
NUMCELLS deep. */
#define host_address_to_string(ADDR) \
host_address_to_string_1 ((const void *) (ADDR))
+/* Return the next entry in the circular print buffer. */
+
+extern char *get_print_cell (void);
+
#endif /* COMMON_CELLS_H */
into the integer thread id (GDB's homegrown id, not the system's). */
extern int pid_to_thread_id (ptid_t ptid);
+/* Return a string version of THR's thread ID. The result is stored
+ in a circular static buffer, NUMCELLS deep. */
+const char *print_thread_id (struct thread_info *thr);
+
/* Boolean test for an already-known pid (which may be overloaded with
extra thread information). */
extern int in_thread_list (ptid_t ptid);
{
if (!must_confirm)
printf_unfiltered (_("Note:\n"));
- printf_unfiltered (_(" Thread %d previously stopped with signal %s, %s.\n"),
- tp->num,
+ printf_unfiltered (_(" Thread %s previously stopped with signal %s, %s.\n"),
+ print_thread_id (tp),
gdb_signal_to_name (tp->suspend.stop_signal),
gdb_signal_to_string (tp->suspend.stop_signal));
must_confirm = 1;
}
if (must_confirm
- && !query (_("Continuing thread %d (the current thread) with specified signal will\n"
+ && !query (_("Continuing thread %s (the current thread) with specified signal will\n"
"still deliver the signals noted above to their respective threads.\n"
"Continue anyway? "),
- inferior_thread ()->num))
+ print_thread_id (inferior_thread ())))
error (_("Not confirmed."));
}
switch_to_thread (tp->ptid);
}
- printf_filtered (_("[Switching to thread %d (%s)] "),
- pid_to_thread_id (inferior_ptid),
+ printf_filtered (_("[Switching to thread %s (%s)] "),
+ print_thread_id (inferior_thread ()),
target_pid_to_str (inferior_ptid));
}
else
ui_out_text (uiout, "\n[");
ui_out_field_string (uiout, "thread-name",
target_pid_to_str (t->ptid));
- ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num);
+ ui_out_field_fmt (uiout, "thread-id", "] #%s", print_thread_id (t));
ui_out_text (uiout, " stopped");
}
else
}
printf_unfiltered (_("Recorded %u instructions in %u functions (%u gaps) "
- "for thread %d (%s).\n"), insns, calls, gaps,
- tp->num, target_pid_to_str (tp->ptid));
+ "for thread %s (%s).\n"), insns, calls, gaps,
+ print_thread_id (tp), target_pid_to_str (tp->ptid));
if (btrace_is_replaying (tp))
printf_unfiltered (_("Replay in progress. At instruction %u.\n"),
{
struct btrace_thread_info *btinfo;
- DEBUG ("resuming thread %d (%s): %x (%s)", tp->num,
+ DEBUG ("resuming thread %s (%s): %x (%s)", print_thread_id (tp),
target_pid_to_str (tp->ptid), flag, btrace_thread_flag_to_str (flag));
btinfo = &tp->btrace;
if (flags == 0)
return;
- DEBUG ("cancel resume thread %d (%s): %x (%s)", tp->num,
+ DEBUG ("cancel resume thread %s (%s): %x (%s)",
+ print_thread_id (tp),
target_pid_to_str (tp->ptid), flags,
btrace_thread_flag_to_str (flags));
flags = btinfo->flags & (BTHR_MOVE | BTHR_STOP);
btinfo->flags &= ~(BTHR_MOVE | BTHR_STOP);
- DEBUG ("stepping thread %d (%s): %x (%s)", tp->num,
+ DEBUG ("stepping thread %s (%s): %x (%s)", print_thread_id (tp),
target_pid_to_str (tp->ptid), flags,
btrace_thread_flag_to_str (flags));
/* We moved the replay position but did not update registers. */
registers_changed_ptid (eventing->ptid);
- DEBUG ("wait ended by thread %d (%s): %s", eventing->num,
+ DEBUG ("wait ended by thread %s (%s): %s",
+ print_thread_id (eventing),
target_pid_to_str (eventing->ptid),
target_waitstatus_to_string (status));
restore_current_thread_cleanup_dtor);
}
+/* See gdbthread.h. */
+
+const char *
+print_thread_id (struct thread_info *thr)
+{
+ char *s = get_print_cell ();
+
+ xsnprintf (s, PRINT_CELL_SIZE, "%d", thr->num);
+ return s;
+}
+
/* If non-zero tp_array_compar should sort in ascending order, otherwise in
descending order. */
if (thread_alive (tp_array[k]))
{
switch_to_thread (tp_array[k]->ptid);
- printf_filtered (_("\nThread %d (%s):\n"),
- tp_array[k]->num,
+ printf_filtered (_("\nThread %s (%s):\n"),
+ print_thread_id (tp_array[k]),
target_pid_to_str (inferior_ptid));
execute_command (cmd, from_tty);
do_cleanups (old_chain);
}
+/* Implementation of the "thread apply" command. */
+
static void
thread_apply_command (char *tidlist, int from_tty)
{
if (target_has_stack)
{
+ struct thread_info *tp = inferior_thread ();
+
if (is_exited (inferior_ptid))
- printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
- pid_to_thread_id (inferior_ptid),
+ printf_filtered (_("[Current thread is %s (%s) (exited)]\n"),
+ print_thread_id (tp),
target_pid_to_str (inferior_ptid));
else
- printf_filtered (_("[Current thread is %d (%s)]\n"),
- pid_to_thread_id (inferior_ptid),
+ printf_filtered (_("[Current thread is %s (%s)]\n"),
+ print_thread_id (tp),
target_pid_to_str (inferior_ptid));
}
else
{
if (tp->name != NULL && re_exec (tp->name))
{
- printf_filtered (_("Thread %d has name '%s'\n"),
- tp->num, tp->name);
+ printf_filtered (_("Thread %s has name '%s'\n"),
+ print_thread_id (tp), tp->name);
match++;
}
tmp = target_thread_name (tp);
if (tmp != NULL && re_exec (tmp))
{
- printf_filtered (_("Thread %d has target name '%s'\n"),
- tp->num, tmp);
+ printf_filtered (_("Thread %s has target name '%s'\n"),
+ print_thread_id (tp), tmp);
match++;
}
tmp = target_pid_to_str (tp->ptid);
if (tmp != NULL && re_exec (tmp))
{
- printf_filtered (_("Thread %d has target id '%s'\n"),
- tp->num, tmp);
+ printf_filtered (_("Thread %s has target id '%s'\n"),
+ print_thread_id (tp), tmp);
match++;
}
tmp = target_extra_thread_info (tp);
if (tmp != NULL && re_exec (tmp))
{
- printf_filtered (_("Thread %d has extra info '%s'\n"),
- tp->num, tmp);
+ printf_filtered (_("Thread %s has extra info '%s'\n"),
+ print_thread_id (tp), tmp);
match++;
}
}
annotate_thread_changed ();
ui_out_text (uiout, "[Switching to thread ");
- ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid));
+ ui_out_field_string (uiout, "new-thread-id", print_thread_id (tp));
ui_out_text (uiout, " (");
ui_out_text (uiout, target_pid_to_str (inferior_ptid));
ui_out_text (uiout, ")]");
projects / binutils-gdb.git / commitdiff