X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fgdbthread.h;h=c3b85dc7058d44a299de3adeb5dac7fe0fd39934;hb=c1e36e3e919994da4fa0da232b173939f3e44bb8;hp=e89e88d346abee90ca880747c233f430f9233236;hpb=8aeb23f3648c6ef10c5715e30f04563d1cc28709;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index e89e88d346..c3b85dc705 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -1,6 +1,5 @@ /* Multi-process/thread control defs for GDB, the GNU debugger. - Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1997, 1998, 1999, - 2000, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 1987-2013 Free Software Foundation, Inc. Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. @@ -28,44 +27,31 @@ struct symtab; #include "frame.h" #include "ui-out.h" #include "inferior.h" +#include "btrace.h" -struct thread_info +/* Frontend view of the thread state. Possible extensions: stepping, + finishing, until(ling),... */ +enum thread_state { - struct thread_info *next; - ptid_t ptid; /* "Actual process id"; - In fact, this may be overloaded with - kernel thread id, etc. */ - int num; /* Convenient handle (GDB thread id) */ + THREAD_STOPPED, + THREAD_RUNNING, + THREAD_EXITED, +}; - /* Non-zero means the thread is executing. Note: this is different - from saying that there is an active target and we are stopped at - a breakpoint, for instance. This is a real indicator whether the - thread is off and running. */ - /* This field is internal to thread.c. Never access it directly, - use is_executing instead. */ - int executing_; +/* Inferior thread specific part of `struct infcall_control_state'. - /* Frontend view of the thread state. Note that the RUNNING/STOPPED - states are different from EXECUTING. When the thread is stopped - internally while handling an internal event, like a software - single-step breakpoint, EXECUTING will be false, but running will - still be true. As a possible future extension, this could turn - into enum { stopped, exited, stepping, finishing, until(ling), - running ... } */ - /* This field is internal to thread.c. Never access it directly, - use is_running instead. */ - int state_; - - /* If this is > 0, then it means there's code out there that relies - on this thread being listed. Don't delete it from the lists even - if we detect it exiting. */ - int refcount; + Inferior process counterpart is `struct inferior_control_state'. */ +struct thread_control_state +{ /* User/external stepping state. */ /* Step-resume or longjmp-resume breakpoint. */ struct breakpoint *step_resume_breakpoint; + /* Exception-resume breakpoint. */ + struct breakpoint *exception_resume_breakpoint; + /* Range to single step within. If this is nonzero, respond to a single-step signal by continuing @@ -75,10 +61,18 @@ struct thread_info step for a single instruction (FIXME: it might clean up wait_for_inferior in a minor way if this were changed to the address of the instruction and that address plus one. But maybe - not.). */ + not). */ CORE_ADDR step_range_start; /* Inclusive */ CORE_ADDR step_range_end; /* Exclusive */ + /* If GDB issues a target step request, and this is nonzero, the + target should single-step this thread once, and then continue + single-stepping it without GDB core involvement as long as the + thread stops in the step range above. If this is zero, the + target should ignore the step range, and only issue one single + step. */ + int may_range_step; + /* Stack frame address as of when stepping command was issued. This is how we know when we step into a subroutine call, and how to set the frame for the breakpoint used to step out. */ @@ -88,17 +82,6 @@ struct thread_info any inlined frames). */ struct frame_id step_stack_frame_id; - int current_line; - struct symtab *current_symtab; - - /* Internal stepping state. */ - - /* Record the pc of the thread the last time it stopped. This is - maintained by proceed and keep_going, and used in - adjust_pc_after_break to distinguish a hardware single-step - SIGTRAP from a breakpoint SIGTRAP. */ - CORE_ADDR prev_pc; - /* Nonzero if we are presently stepping over a breakpoint. If we hit a breakpoint or watchpoint, and then continue, we need @@ -123,24 +106,99 @@ struct thread_info by keep_going. */ int trap_expected; + /* Nonzero if the thread is being proceeded for a "finish" command + or a similar situation when stop_registers should be saved. */ + int proceed_to_finish; + + /* Nonzero if the thread is being proceeded for an inferior function + call. */ + int in_infcall; + + enum step_over_calls_kind step_over_calls; + + /* Nonzero if stopped due to a step command. */ + int stop_step; + + /* Chain containing status of breakpoint(s) the thread stopped + at. */ + bpstat stop_bpstat; +}; + +/* Inferior thread specific part of `struct infcall_suspend_state'. + + Inferior process counterpart is `struct inferior_suspend_state'. */ + +struct thread_suspend_state +{ + /* Last signal that the inferior received (why it stopped). */ + enum gdb_signal stop_signal; +}; + +struct thread_info +{ + struct thread_info *next; + ptid_t ptid; /* "Actual process id"; + In fact, this may be overloaded with + kernel thread id, etc. */ + int num; /* Convenient handle (GDB thread id) */ + + /* The name of the thread, as specified by the user. This is NULL + if the thread does not have a user-given name. */ + char *name; + + /* Non-zero means the thread is executing. Note: this is different + from saying that there is an active target and we are stopped at + a breakpoint, for instance. This is a real indicator whether the + thread is off and running. */ + int executing; + + /* Frontend view of the thread state. Note that the RUNNING/STOPPED + states are different from EXECUTING. When the thread is stopped + internally while handling an internal event, like a software + single-step breakpoint, EXECUTING will be false, but running will + still be true. As a possible future extension, this could turn + into enum { stopped, exited, stepping, finishing, until(ling), + running ... } */ + int state; + + /* If this is > 0, then it means there's code out there that relies + on this thread being listed. Don't delete it from the lists even + if we detect it exiting. */ + int refcount; + + /* State of GDB control of inferior thread execution. + See `struct thread_control_state'. */ + struct thread_control_state control; + + /* State of inferior thread to restore after GDB is done with an inferior + call. See `struct thread_suspend_state'. */ + struct thread_suspend_state suspend; + + int current_line; + struct symtab *current_symtab; + + /* Internal stepping state. */ + + /* Record the pc of the thread the last time it stopped. This is + maintained by proceed and keep_going, and used in + adjust_pc_after_break to distinguish a hardware single-step + SIGTRAP from a breakpoint SIGTRAP. */ + CORE_ADDR prev_pc; + /* Should we step over breakpoint next time keep_going is called? */ int stepping_over_breakpoint; /* Set to TRUE if we should finish single-stepping over a breakpoint - after hitting the current step-resume breakpoint. */ + after hitting the current step-resume breakpoint. The context here + is that GDB is to do `next' or `step' while signal arrives. + When stepping over a breakpoint and signal arrives, GDB will attempt + to skip signal handler, so it inserts a step_resume_breakpoint at the + signal return address, and resume inferior. + step_after_step_resume_breakpoint is set to TRUE at this moment in + order to keep GDB in mind that there is still a breakpoint to step over + when GDB gets back SIGTRAP from step_resume_breakpoint. */ int step_after_step_resume_breakpoint; - /* This is set TRUE when a catchpoint of a shared library event - triggers. Since we don't wish to leave the inferior in the - solib hook when we report the event, we step the inferior - back to user code before stopping and reporting the event. */ - int stepping_through_solib_after_catch; - - /* When stepping_through_solib_after_catch is TRUE, this is a - list of the catchpoints that should be reported as triggering - when we finally do stop stepping. */ - bpstat stepping_through_solib_catchpoints; - /* Per-thread command support. */ /* Pointer to what is left to do for an execution command after the @@ -153,19 +211,6 @@ struct thread_info command. */ struct continuation *intermediate_continuations; - /* Nonzero if the thread is being proceeded for a "finish" command - or a similar situation when stop_registers should be saved. */ - int proceed_to_finish; - - /* Nonzero if the thread is being proceeded for an inferior function - call. */ - int in_infcall; - - enum step_over_calls_kind step_over_calls; - - /* Nonzero if stopped due to a step command. */ - int stop_step; - /* If stepping, nonzero means step count is > 1 so don't print frame next time inferior stops if it stops due to stepping. */ int step_multi; @@ -175,22 +220,24 @@ struct thread_info resume of the thread, and not immediately. */ struct target_waitstatus pending_follow; - /* Last signal that the inferior received (why it stopped). */ - enum target_signal stop_signal; - - /* Chain containing status of breakpoint(s) the thread stopped - at. */ - bpstat stop_bpstat; - /* True if this thread has been explicitly requested to stop. */ int stop_requested; + /* The initiating frame of a nexting operation, used for deciding + which exceptions to intercept. If it is null_frame_id no + bp_longjmp or bp_exception but longjmp has been caught just for + bp_longjmp_call_dummy. */ + struct frame_id initiating_frame; + /* Private data used by the target vector implementation. */ struct private_thread_info *private; /* Function that is called to free PRIVATE. If this is NULL, then xfree will be called on PRIVATE. */ void (*private_dtor) (struct private_thread_info *); + + /* Branch trace information for this thread. */ + struct btrace_thread_info btrace; }; /* Create an empty thread list, or empty the existing one. */ @@ -218,9 +265,12 @@ extern void delete_thread (ptid_t); exited, for example. */ extern void delete_thread_silent (ptid_t); -/* Delete a step_resume_breakpoint from the thread database. */ +/* Delete a step_resume_breakpoint from the thread database. */ extern void delete_step_resume_breakpoint (struct thread_info *); +/* Delete an exception_resume_breakpoint from the thread database. */ +extern void delete_exception_resume_breakpoint (struct thread_info *); + /* 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); @@ -251,7 +301,7 @@ struct thread_info *first_thread_of_process (int pid); extern struct thread_info *any_thread_of_process (int pid); /* Returns any non-exited thread of process PID, giving preference for - already stopped threads. */ + not executing threads. */ extern struct thread_info *any_live_thread_of_process (int pid); /* Change the ptid of thread OLD_PTID to NEW_PTID. */ @@ -262,6 +312,11 @@ 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) + extern int thread_count (void); /* Switch from one thread to another. */ @@ -310,7 +365,7 @@ extern int any_running (void); marks all threads. Note that this is different from the running state. See the - description of state_ and executing_ fields of struct + description of state and executing fields of struct thread_info. */ extern void set_executing (ptid_t ptid, int executing); @@ -341,7 +396,7 @@ extern struct cmd_list_element *thread_cmd_list; `set print thread-events'. */ extern int print_thread_events; -extern void print_thread_info (struct ui_out *uiout, int thread, +extern void print_thread_info (struct ui_out *uiout, char *threads, int pid); extern struct cleanup *make_cleanup_restore_current_thread (void); @@ -352,6 +407,10 @@ extern struct thread_info* inferior_thread (void); extern void update_thread_list (void); -extern int currently_stepping (struct thread_info *tp); +/* Return true if PC is in the stepping range of THREAD. */ + +int pc_in_thread_step_range (CORE_ADDR pc, struct thread_info *thread); + +extern struct thread_info *thread_list; #endif /* GDBTHREAD_H */