X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgdbthread.h;h=ddb7b0f66cd1d96933081ccac9fd420aa5cecc74;hb=bb38e8717f91c94ca6451cb7374feeb285ad2c9c;hp=ca74976fb871e5faf137fe19c7f2e8a3cd51196d;hpb=32400bebb23653900ef060aae37668a2a1961155;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index ca74976fb8..ddb7b0f66c 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -1,6 +1,6 @@ /* 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 Free Software Foundation, Inc. + 2000, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. @@ -29,43 +29,20 @@ struct symtab; #include "ui-out.h" #include "inferior.h" -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) */ - - /* 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_; - - /* 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_; +/* Inferior thread specific part of `struct infcall_control_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,7 +52,7 @@ 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 */ @@ -83,16 +60,10 @@ struct thread_info 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. */ struct frame_id step_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; + /* Similarly, the frame ID of the underlying stack frame (skipping + any inlined frames). */ + struct frame_id step_stack_frame_id; /* Nonzero if we are presently stepping over a breakpoint. @@ -118,6 +89,89 @@ 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 target_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. */ + /* This field is internal to thread.c. Never access it directly, + use is_executing instead. */ + 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 ... } */ + /* 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; + + /* 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; @@ -136,27 +190,40 @@ struct thread_info when we finally do stop stepping. */ bpstat stepping_through_solib_catchpoints; - /* The below are only per-thread in non-stop mode. */ /* 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; - 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; + /* 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; - enum step_over_calls_kind step_over_calls; - 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; - enum target_signal stop_signal; + /* This is used to remember when a fork or vfork event was caught by + a catchpoint, and thus the event is to be followed at the next + resume of the thread, and not immediately. */ + struct target_waitstatus pending_follow; - /* 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. */ + 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 *); }; /* Create an empty thread list, or empty the existing one. */ @@ -184,9 +251,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); @@ -204,11 +274,22 @@ extern int in_thread_list (ptid_t ptid); extern int valid_thread_id (int thread); /* Search function to lookup a thread by 'pid'. */ -extern struct thread_info *find_thread_pid (ptid_t ptid); +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); +/* Finds the first thread of the inferior given by PID. If PID is -1, + returns the first thread in the list. */ +struct thread_info *first_thread_of_process (int pid); + +/* Returns any thread of process 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. */ +extern struct thread_info *any_live_thread_of_process (int pid); + /* Change the ptid of thread OLD_PTID to NEW_PTID. */ void thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid); @@ -219,23 +300,6 @@ extern struct thread_info *iterate_over_threads (thread_callback_func, void *); extern int thread_count (void); -/* infrun context switch: save the debugger state for the given thread. */ -extern void save_infrun_state (ptid_t ptid, - struct continuation *continuations, - struct continuation *intermediate_continuations, - int stop_step, - int step_multi, - enum target_signal stop_signal); - -/* infrun context switch: load the debugger state previously saved - for the given thread. */ -extern void load_infrun_state (ptid_t ptid, - struct continuation **continuations, - struct continuation **intermediate_continuations, - int *stop_step, - int *step_multi, - enum target_signal *stop_signal); - /* Switch from one thread to another. */ extern void switch_to_thread (ptid_t ptid); @@ -243,6 +307,13 @@ extern void switch_to_thread (ptid_t ptid); If PIDGET (PTID) is -1, marks all threads. */ extern void set_running (ptid_t ptid, int running); +/* Marks or clears thread(s) PTID as having been requested to stop. + 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. If STOP, then the THREAD_STOP_REQUESTED + observer is called with PTID as argument. */ +extern void set_stop_requested (ptid_t ptid, int stop); + /* NOTE: Since the thread state is not a boolean, most times, you do not want to check it with negation. If you really want to check if the thread is stopped, @@ -282,6 +353,23 @@ extern void set_executing (ptid_t ptid, int executing); /* Reports if thread PTID is executing. */ extern int is_executing (ptid_t ptid); +/* Merge the executing property of thread PTID over to its thread + state property (frontend running/stopped view). + + "not executing" -> "stopped" + "executing" -> "running" + "exited" -> "exited" + + If PIDGET (PTID) is -1, go over all threads. + + Notifications are only emitted if the thread state did change. */ +extern void finish_thread_state (ptid_t ptid); + +/* Same as FINISH_THREAD_STATE, but with an interface suitable to be + registered as a cleanup. PTID_P points to the ptid_t that is + passed to FINISH_THREAD_STATE. */ +extern void finish_thread_state_cleanup (void *ptid_p); + /* Commands with a prefix of `thread'. */ extern struct cmd_list_element *thread_cmd_list; @@ -289,7 +377,8 @@ 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, int thread, + int pid); extern struct cleanup *make_cleanup_restore_current_thread (void); @@ -297,4 +386,6 @@ extern struct cleanup *make_cleanup_restore_current_thread (void); INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */ extern struct thread_info* inferior_thread (void); +extern void update_thread_list (void); + #endif /* GDBTHREAD_H */