/* 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 Free Software Foundation, Inc.
+ Copyright (C) 1987-2014 Free Software Foundation, Inc.
Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA.
#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
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. */
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
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
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;
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. */
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);
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. */
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. */
extern void switch_to_thread (ptid_t ptid);
/* Marks thread PTID is running, or stopped.
- If PIDGET (PTID) is -1, marks all threads. */
+ If ptid_get_pid (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.
/* In the frontend's perpective is there any thread running? */
extern int any_running (void);
-/* Marks thread PTID as executing, or not. If PIDGET (PTID) is -1,
+/* Marks thread PTID as executing, or not. If ptid_get_pid (PTID) is -1,
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);
"executing" -> "running"
"exited" -> "exited"
- If PIDGET (PTID) is -1, go over all threads.
+ If ptid_get_pid (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);
`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);
INFERIOR_PTID. INFERIOR_PTID *must* be in the thread list. */
extern struct thread_info* inferior_thread (void);
+extern void update_thread_list (void);
+
+/* 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 */