X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbthread.h;h=bdd2bb0d49a038d3a77e60e53d525416700f255d;hb=45e3745ed0e034fdec5beee0738f383bd6e2e045;hp=0c99782174965d17ba5f5839b12251b514d753a5;hpb=243a925328f8e3184b2356bee497181049c0174f;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index 0c99782174..bdd2bb0d49 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -1,5 +1,5 @@ /* Multi-process/thread control defs for GDB, the GNU debugger. - Copyright (C) 1987-2015 Free Software Foundation, Inc. + Copyright (C) 1987-2016 Free Software Foundation, Inc. Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. @@ -30,6 +30,7 @@ struct symtab; #include "btrace.h" #include "common/vec.h" #include "target/waitstatus.h" +#include "cli/cli-utils.h" /* Frontend view of the thread state. Possible extensions: stepping, finishing, until(ling),... */ @@ -187,7 +188,46 @@ struct thread_info ptid_t ptid; /* "Actual process id"; In fact, this may be overloaded with kernel thread id, etc. */ - int num; /* Convenient handle (GDB thread id) */ + + /* Each thread has two GDB IDs. + + a) The thread ID (Id). This consists of the pair of: + + - the number of the thread's inferior and, + + - the thread's thread number in its inferior, aka, the + per-inferior thread number. This number is unique in the + inferior but not unique between inferiors. + + b) The global ID (GId). This is a a single integer unique + between all inferiors. + + E.g.: + + (gdb) info threads -gid + Id GId Target Id Frame + * 1.1 1 Thread A 0x16a09237 in foo () at foo.c:10 + 1.2 3 Thread B 0x15ebc6ed in bar () at foo.c:20 + 1.3 5 Thread C 0x15ebc6ed in bar () at foo.c:20 + 2.1 2 Thread A 0x16a09237 in foo () at foo.c:10 + 2.2 4 Thread B 0x15ebc6ed in bar () at foo.c:20 + 2.3 6 Thread C 0x15ebc6ed in bar () at foo.c:20 + + Above, both inferiors 1 and 2 have threads numbered 1-3, but each + thread has its own unique global ID. */ + + /* The thread's global GDB thread number. This is exposed to MI, + Python/Scheme, visible with "info threads -gid", and is also what + the $_gthread convenience variable is bound to. */ + int global_num; + + /* The per-inferior thread number. This is unique in the inferior + the thread belongs to, but not unique between inferiors. This is + what the $_thread convenience variable is bound to. */ + int per_inf_num; + + /* The inferior this thread belongs to. */ + struct inferior *inf; /* The name of the thread, as specified by the user. This is NULL if the thread does not have a user-given name. */ @@ -265,18 +305,6 @@ struct thread_info when GDB gets back SIGTRAP from step_resume_breakpoint. */ int step_after_step_resume_breakpoint; - /* Per-thread command support. */ - - /* Pointer to what is left to do for an execution command after the - target stops. Used only in asynchronous mode, by targets that - support async execution. Several execution commands use it. */ - struct continuation *continuations; - - /* Similar to the above, but used when a single execution command - requires several resume/stop iterations. Used by the step - command. */ - struct continuation *intermediate_continuations; - /* Pointer to the state machine manager object that handles what is left to do for the thread's execution command after the target stops. Several execution commands use it. */ @@ -365,27 +393,40 @@ extern int thread_has_single_step_breakpoint_here (struct thread_info *tp, struct address_space *aspace, CORE_ADDR addr); -/* Translate the integer thread id (GDB's homegrown id, not the system's) - into a "pid" (which may be overloaded with extra thread information). */ -extern ptid_t thread_id_to_pid (int); +/* Translate the global integer thread id (GDB's homegrown id, not the + system's) into a "pid" (which may be overloaded with extra thread + information). */ +extern ptid_t global_thread_id_to_ptid (int num); + +/* Translate a 'pid' (which may be overloaded with extra thread + information) into the global integer thread id (GDB's homegrown id, + not the system's). */ +extern int ptid_to_global_thread_id (ptid_t ptid); + +/* Returns whether to show inferior-qualified thread IDs, or plain + thread numbers. Inferior-qualified IDs are shown whenever we have + multiple inferiors, or the only inferior left has number > 1. */ +extern int show_inferior_qualified_tids (void); -/* Translate a 'pid' (which may be overloaded with extra thread information) - 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. If there are multiple + inferiors, then this prints the inferior-qualifier form, otherwise + it only prints the thread number. 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); -/* Boolean test for an already-known thread id (GDB's homegrown id, - not the system's). */ -extern int valid_thread_id (int thread); +/* Boolean test for an already-known global thread id (GDB's homegrown + global id, not the system's). */ +extern int valid_global_thread_id (int global_id); /* Search function to lookup a thread by 'pid'. */ extern struct thread_info *find_thread_ptid (ptid_t ptid); -/* Find thread by GDB user-visible thread number. */ -struct thread_info *find_thread_id (int num); +/* Find thread by GDB global thread ID. */ +struct thread_info *find_thread_global_id (int global_id); /* Finds the first thread of the inferior given by PID. If PID is -1, returns the first thread in the list. */ @@ -407,6 +448,16 @@ void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid); typedef int (*thread_callback_func) (struct thread_info *, void *); extern struct thread_info *iterate_over_threads (thread_callback_func, void *); +/* Traverse all threads. */ +#define ALL_THREADS(T) \ + for (T = thread_list; T; T = T->next) \ + +/* Traverse over all threads, sorted by inferior. */ +#define ALL_THREADS_BY_INFERIOR(inf, tp) \ + ALL_INFERIORS (inf) \ + ALL_THREADS (tp) \ + if (inf == tp->inf) + /* Traverse all threads, except those that have THREAD_EXITED state. */ @@ -423,9 +474,14 @@ extern struct thread_info *iterate_over_threads (thread_callback_func, void *); extern int thread_count (void); -/* Switch from one thread to another. */ +/* Switch from one thread to another. Also sets the STOP_PC + global. */ extern void switch_to_thread (ptid_t ptid); +/* Switch from one thread to another. Does not read registers and + sets STOP_PC to -1. */ +extern void switch_to_thread_no_regs (struct thread_info *thread); + /* Marks or clears thread(s) PTID as resumed. If PTID is MINUS_ONE_PTID, applies to all threads. If ptid_is_pid(PTID) is true, applies to all threads of the process pointed at by PTID. */ @@ -507,7 +563,14 @@ extern void thread_command (char *tidstr, int from_tty); `set print thread-events'. */ extern int print_thread_events; -extern void print_thread_info (struct ui_out *uiout, char *threads, +/* Prints the list of threads and their details on UIOUT. If + REQUESTED_THREADS, a list of GDB ids/ranges, is not NULL, only + print threads whose ID is included in the list. If PID is not -1, + only print threads from the process PID. Otherwise, threads from + all attached PIDs are printed. If both REQUESTED_THREADS is not + NULL and PID is not -1, then the thread is printed if it belongs to + the specified process. Otherwise, an error is raised. */ +extern void print_thread_info (struct ui_out *uiout, char *requested_threads, int pid); extern struct cleanup *make_cleanup_restore_current_thread (void); @@ -562,6 +625,16 @@ extern int thread_is_in_step_over_chain (struct thread_info *tp); extern void thread_cancel_execution_command (struct thread_info *thr); +/* Check whether it makes sense to access a register of the current + thread at this point. If not, throw an error (e.g., the thread is + executing). */ +extern void validate_registers_access (void); + +/* Returns whether to show which thread hit the breakpoint, received a + signal, etc. and ended up causing a user-visible stop. This is + true iff we ever detected multiple threads. */ +extern int show_thread_that_caused_stop (void); + extern struct thread_info *thread_list; #endif /* GDBTHREAD_H */