/* Data structures associated with breakpoints in GDB.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
#define BREAKPOINT_MAX 16
\f
-/* Type of breakpoint. */
+
+/* Type of breakpoint. */
/* FIXME In the future, we should fold all other breakpoint-like things into
here. This includes:
of scope (with hardware support for watchpoints)). */
bp_call_dummy,
+ /* A breakpoint set on std::terminate, that is used to catch
+ otherwise uncaught exceptions thrown during an inferior call. */
+ bp_std_terminate,
+
/* Some dynamic linkers (HP, maybe Solaris) can arrange for special
code in the inferior to run when significant events occur in the
dynamic linker (for example a library is loaded or unloaded).
bp_overlay_event,
+ /* Master copies of longjmp breakpoints. These are always installed
+ as soon as an objfile containing longjmp is loaded, but they are
+ always disabled. While necessary, temporary clones of bp_longjmp
+ type will be created and enabled. */
+
+ bp_longjmp_master,
+
+ /* Master copies of std::terminate breakpoints. */
+ bp_std_terminate_master,
+
bp_catchpoint,
+
+ bp_tracepoint,
+ bp_fast_tracepoint,
+
+ /* Event for JIT compiled code generation or deletion. */
+ bp_jit_event,
};
/* States of enablement of breakpoint. */
automatically enabled and reset when the call
"lands" (either completes, or stops at another
eventpoint). */
+ bp_startup_disabled,/* The eventpoint has been disabled during inferior
+ startup. This is necessary on some targets where
+ the main executable will get relocated during
+ startup, making breakpoint addresses invalid.
+ The eventpoint will be automatically enabled and
+ reset once inferior startup is complete. */
bp_permanent /* There is a breakpoint instruction hard-wired into
the target's code. Don't try to write another
breakpoint instruction on top of it, or restore
struct bp_target_info
{
+ /* Address space at which the breakpoint was placed. */
+ struct address_space *placed_address_space;
+
/* Address at which the breakpoint was placed. This is normally the
same as ADDRESS from the bp_location, except when adjustment
happens in gdbarch_breakpoint_from_pc. The most common form of
the same parent breakpoint. */
struct bp_location *next;
- /* Pointer to the next breakpoint location, in a global
- list of all breakpoint locations. */
- struct bp_location *global_next;
-
/* Type of this breakpoint location. */
enum bp_loc_type loc_type;
than reference counting. */
struct breakpoint *owner;
- /* Conditional. Break only if this expression's value is nonzero.
- Unlike string form of condition, which is associated with breakpoint,
- this is associated with location, since if breakpoint has several
- locations, the evaluation of expression can be different for
- different locations. */
+ /* Conditional. Break only if this expression's value is nonzero.
+ Unlike string form of condition, which is associated with
+ breakpoint, this is associated with location, since if breakpoint
+ has several locations, the evaluation of expression can be
+ different for different locations. Only valid for real
+ breakpoints; a watchpoint's conditional expression is stored in
+ the owner breakpoint object. */
struct expression *cond;
/* This location's address is in an unloaded solib, and so this
/* Data for specific breakpoint types. These could be a union, but
simplicity is more important than memory usage for breakpoints. */
+ /* Architecture associated with this location's address. May be
+ different from the breakpoint architecture. */
+ struct gdbarch *gdbarch;
+
+ /* The program space associated with this breakpoint location
+ address. Note that an address space may be represented in more
+ than one program space (e.g. each uClinux program will be given
+ its own program space, but there will only be one address space
+ for all of them), but we must not insert more than one location
+ at the same address in the same address space. */
+ struct program_space *pspace;
+
/* Note that zero is a perfectly valid code address on some platforms
(for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL
is not a special value for this field. Valid for all types except
enum print_stop_action (*print_it) (struct breakpoint *);
/* Display information about this breakpoint, for "info breakpoints". */
- void (*print_one) (struct breakpoint *, CORE_ADDR *);
+ void (*print_one) (struct breakpoint *, struct bp_location **);
/* Display information about this breakpoint after setting it (roughly
speaking; this is called from "mention"). */
watch_triggered_yes
};
+/* This is used to declare the VEC syscalls_to_be_caught. */
+DEF_VEC_I(int);
+
typedef struct bp_location *bp_location_p;
DEF_VEC_P(bp_location_p);
+/* A reference-counted struct command_line. This lets multiple
+ breakpoints share a single command list. This is an implementation
+ detail to the breakpoints module. */
+struct counted_command_line;
+
/* Note that the ->silent field is not currently used by any commands
(though the code is in there if it was to be, and set_raw_breakpoint
does set it to 0). I implemented it because I thought it would be
be continued automatically before really stopping. */
int ignore_count;
/* Chain of command lines to execute when this breakpoint is hit. */
- struct command_line *commands;
+ struct counted_command_line *commands;
/* Stack depth (address of frame). If nonzero, break only if fp
equals this. */
struct frame_id frame_id;
+ /* The program space used to set the breakpoint. */
+ struct program_space *pspace;
+
/* String we used to set the breakpoint (malloc'd). */
char *addr_string;
+ /* Architecture we used to set the breakpoint. */
+ struct gdbarch *gdbarch;
/* Language we used to set the breakpoint. */
enum language language;
/* Input radix we used to set the breakpoint. */
/* The largest block within which it is valid, or NULL if it is
valid anywhere (e.g. consists just of global symbols). */
struct block *exp_valid_block;
+ /* The conditional expression if any. NULL if not a watchpoint. */
+ struct expression *cond_exp;
+ /* The largest block within which it is valid, or NULL if it is
+ valid anywhere (e.g. consists just of global symbols). */
+ struct block *cond_exp_valid_block;
/* Value of the watchpoint the last time we checked it, or NULL
when we do not know the value yet or the value was not
readable. VAL is never lazy. */
should be evaluated on the outermost frame. */
struct frame_id watchpoint_frame;
+ /* Holds the thread which identifies the frame this watchpoint
+ should be considered in scope for, or `null_ptid' if the
+ watchpoint should be evaluated in all threads. */
+ ptid_t watchpoint_thread;
+
/* For hardware watchpoints, the triggered status according to the
hardware. */
enum watchpoint_triggered watchpoint_triggered;
- /* Thread number for thread-specific breakpoint, or -1 if don't care */
+ /* Thread number for thread-specific breakpoint, or -1 if don't care. */
int thread;
+ /* Ada task number for task-specific breakpoint, or 0 if don't care. */
+ int task;
+
/* Count of the number of times this breakpoint was taken, dumped
with the info, but not used for anything else. Useful for
seeing how many times you hit a break prior to the program
triggered. */
char *exec_pathname;
+ /* Syscall numbers used for the 'catch syscall' feature.
+ If no syscall has been specified for filtering, its value is NULL.
+ Otherwise, it holds a list of all syscalls to be caught.
+ The list elements are allocated with xmalloc. */
+ VEC(int) *syscalls_to_be_caught;
+
/* Methods associated with this breakpoint. */
struct breakpoint_ops *ops;
no location initially so had no context to parse
the condition in. */
int condition_not_parsed;
+
+ /* Number of times this tracepoint should single-step
+ and collect additional data. */
+ long step_count;
+
+ /* Number of times this tracepoint should be hit before
+ disabling/ending. */
+ int pass_count;
+
+ /* The number of the tracepoint on the target. */
+ int number_on_target;
};
typedef struct breakpoint *breakpoint_p;
is part of the bpstat is copied as well. */
extern bpstat bpstat_copy (bpstat);
-extern bpstat bpstat_stop_status (CORE_ADDR pc, ptid_t ptid);
+extern bpstat bpstat_stop_status (struct address_space *aspace,
+ CORE_ADDR pc, ptid_t ptid);
\f
/* This bpstat_what stuff tells wait_for_inferior what to do with a
breakpoint (a challenging task). */
keep checking. */
BPSTAT_WHAT_CHECK_SHLIBS,
- /* Check the dynamic linker's data structures for new libraries, then
- resume out of the dynamic linker's callback, stop and print. */
- BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK,
+ /* Check for new JITed code. */
+ BPSTAT_WHAT_CHECK_JIT,
/* This is just used to keep track of how many enums there are. */
BPSTAT_WHAT_LAST
};
+/* An enum indicating the kind of "stack dummy" stop. This is a bit
+ of a misnomer because only one kind of truly a stack dummy. */
+enum stop_stack_kind
+ {
+ /* We didn't stop at a stack dummy breakpoint. */
+ STOP_NONE = 0,
+
+ /* Stopped at a stack dummy. */
+ STOP_STACK_DUMMY,
+
+ /* Stopped at std::terminate. */
+ STOP_STD_TERMINATE
+ };
+
struct bpstat_what
{
enum bpstat_what_main_action main_action;
of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
continuing from a call dummy without popping the frame is not a
useful one). */
- int call_dummy;
+ enum stop_stack_kind call_dummy;
};
/* The possible return values for print_bpstat, print_it_normal,
/* Find the bpstat associated with a breakpoint. NULL otherwise. */
bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
-/* Find a step_resume breakpoint associated with this bpstat.
- (If there are multiple step_resume bp's on the list, this function
- will arbitrarily pick one.)
-
- It is an error to use this function if BPSTAT doesn't contain a
- step_resume breakpoint.
-
- See wait_for_inferior's use of this function.
- */
-extern struct breakpoint *bpstat_find_step_resume_breakpoint (bpstat);
-
/* Nonzero if a signal that we got in wait() was due to circumstances
explained by the BS. */
/* Currently that is true if we have hit a breakpoint, or if there is
a watchpoint enabled. */
#define bpstat_explains_signal(bs) ((bs) != NULL)
+/* Nonzero is this bpstat causes a stop. */
+extern int bpstat_causes_stop (bpstat);
+
/* Nonzero if we should step constantly (e.g. watchpoints on machines
without hardware support). This isn't related to a specific bpstat,
just to things like whether watchpoints are set. */
bpstat next;
/* Breakpoint that we are at. */
const struct bp_location *breakpoint_at;
- /* Commands left to be done. */
- struct command_line *commands;
+ /* The associated command list. */
+ struct counted_command_line *commands;
+ /* Commands left to be done. This points somewhere in
+ base_command. */
+ struct command_line *commands_left;
/* Old value associated with a watchpoint. */
struct value *old_val;
/* Prototypes for breakpoint-related functions. */
-extern enum breakpoint_here breakpoint_here_p (CORE_ADDR);
+extern enum breakpoint_here breakpoint_here_p (struct address_space *, CORE_ADDR);
+
+extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
-extern int moribund_breakpoint_here_p (CORE_ADDR);
+extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
-extern int breakpoint_inserted_here_p (CORE_ADDR);
+extern int regular_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
-extern int regular_breakpoint_inserted_here_p (CORE_ADDR);
+extern int software_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
-extern int software_breakpoint_inserted_here_p (CORE_ADDR);
+/* Returns true if there's a hardware watchpoint or access watchpoint
+ inserted in the range defined by ADDR and LEN. */
+extern int hardware_watchpoint_inserted_in_range (struct address_space *,
+ CORE_ADDR addr,
+ ULONGEST len);
-extern int breakpoint_thread_match (CORE_ADDR, ptid_t);
+extern int breakpoint_thread_match (struct address_space *, CORE_ADDR, ptid_t);
extern void until_break_command (char *, int, int);
extern void breakpoint_re_set_thread (struct breakpoint *);
extern struct breakpoint *set_momentary_breakpoint
- (struct symtab_and_line, struct frame_id, enum bptype);
+ (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
extern struct breakpoint *set_momentary_breakpoint_at_pc
- (CORE_ADDR pc, enum bptype type);
+ (struct gdbarch *, CORE_ADDR pc, enum bptype type);
+
+extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
extern void set_ignore_count (int, int, int);
-extern void set_default_breakpoint (int, CORE_ADDR, struct symtab *, int);
+extern void set_default_breakpoint (int, struct program_space *,
+ CORE_ADDR, struct symtab *, int);
extern void breakpoint_init_inferior (enum inf_context);
extern void breakpoint_auto_delete (bpstat);
+/* Return the chain of command lines to execute when this breakpoint
+ is hit. */
+extern struct command_line *breakpoint_commands (struct breakpoint *b);
+
extern void break_command (char *, int);
extern void hbreak_command_wrapper (char *, int);
extern void rwatch_command_wrapper (char *, int);
extern void tbreak_command (char *, int);
-extern void set_breakpoint (char *address, char *condition,
- int hardwareflag, int tempflag,
- int thread, int ignore_count,
- int pending);
+extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
+ char *cond_string, int thread,
+ int parse_condition_and_thread,
+ int tempflag, int hardwareflag, int traceflag,
+ int ignore_count,
+ enum auto_boolean pending_break_support,
+ struct breakpoint_ops *ops,
+ int from_tty,
+ int enabled);
extern void insert_breakpoints (void);
extern int remove_breakpoints (void);
+extern int remove_breakpoints_pid (int pid);
+
/* This function can be used to physically insert eventpoints from the
specified traced inferior process, without modifying the breakpoint
package's state. This can be useful for those targets which support
inferior_ptid. */
extern int detach_breakpoints (int);
-extern void set_longjmp_breakpoint (void);
+/* This function is called when program space PSPACE is about to be
+ deleted. It takes care of updating breakpoints to not reference
+ this PSPACE anymore. */
+extern void breakpoint_program_space_exit (struct program_space *pspace);
+
+extern void set_longjmp_breakpoint (int thread);
extern void delete_longjmp_breakpoint (int thread);
extern void enable_overlay_breakpoints (void);
extern void disable_overlay_breakpoints (void);
+extern void set_std_terminate_breakpoint (void);
+extern void delete_std_terminate_breakpoint (void);
+
/* These functions respectively disable or reenable all currently
enabled watchpoints. When disabled, the watchpoints are marked
call_disabled. When reenabled, they are marked enabled.
extern void enable_watchpoints_after_interactive_call_stop (void);
+/* These functions disable and re-enable all breakpoints during
+ inferior startup. They are intended to be called from solib
+ code where necessary. This is needed on platforms where the
+ main executable is relocated at some point during startup
+ processing, making breakpoint addresses invalid.
+
+ If additional breakpoints are created after the routine
+ disable_breakpoints_before_startup but before the routine
+ enable_breakpoints_after_startup was called, they will also
+ be marked as disabled. */
+extern void disable_breakpoints_before_startup (void);
+extern void enable_breakpoints_after_startup (void);
+
/* For script interpreters that need to define breakpoint commands
after they've already read the commands into a struct command_line. */
extern enum command_control_type commands_from_control_command
extern int get_number_or_range (char **);
+extern struct breakpoint *get_breakpoint (int num);
+
/* The following are for displays, which aren't really breakpoints, but
here is as good a place as any for them. */
extern void enable_breakpoint (struct breakpoint *);
+extern void breakpoint_set_commands (struct breakpoint *b,
+ struct command_line *commands);
+
/* Clear the "inserted" flag in all breakpoints. */
extern void mark_breakpoints_out (void);
extern void make_breakpoint_permanent (struct breakpoint *);
-extern struct breakpoint *create_solib_event_breakpoint (CORE_ADDR);
+extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
+ CORE_ADDR);
-extern struct breakpoint *create_thread_event_breakpoint (CORE_ADDR);
+extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
+ CORE_ADDR);
+
+extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
+ CORE_ADDR);
extern void remove_solib_event_breakpoints (void);
/* Manage a software single step breakpoint (or two). Insert may be called
twice before remove is called. */
-extern void insert_single_step_breakpoint (CORE_ADDR);
+extern void insert_single_step_breakpoint (struct gdbarch *,
+ struct address_space *, CORE_ADDR);
extern void remove_single_step_breakpoints (void);
/* Manage manual breakpoints, separate from the normal chain of
breakpoints. These functions are used in murky target-specific
ways. Please do not add more uses! */
-extern void *deprecated_insert_raw_breakpoint (CORE_ADDR);
-extern int deprecated_remove_raw_breakpoint (void *);
+extern void *deprecated_insert_raw_breakpoint (struct gdbarch *,
+ struct address_space *, CORE_ADDR);
+extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *);
/* Check if any hardware watchpoints have triggered, according to the
target. */
in our opinion won't ever trigger. */
extern void breakpoint_retire_moribund (void);
+/* Set break condition of breakpoint B to EXP. */
+extern void set_breakpoint_condition (struct breakpoint *b, char *exp,
+ int from_tty);
+
+/* Checks if we are catching syscalls or not.
+ Returns 0 if not, greater than 0 if we are. */
+extern int catch_syscall_enabled (void);
+
+/* Checks if we are catching syscalls with the specific
+ syscall_number. Used for "filtering" the catchpoints.
+ Returns 0 if not, greater than 0 if we are. */
+extern int catching_syscall_number (int syscall_number);
+
/* Tell a breakpoint to be quiet. */
extern void make_breakpoint_silent (struct breakpoint *);
+/* Return a tracepoint with the given number if found. */
+extern struct breakpoint *get_tracepoint (int num);
+
+extern struct breakpoint *get_tracepoint_by_number_on_target (int num);
+
+/* Find a tracepoint by parsing a number in the supplied string. */
+extern struct breakpoint *get_tracepoint_by_number (char **arg, int multi_p,
+ int optional_p);
+
+/* Return a vector of all tracepoints currently defined. The vector
+ is newly allocated; the caller should free when done with it. */
+extern VEC(breakpoint_p) *all_tracepoints (void);
+
+extern int is_tracepoint (const struct breakpoint *b);
+
+/* Function that can be passed to read_command_line to validate
+ that each command is suitable for tracepoint command list. */
+extern void check_tracepoint_command (char *line, void *closure);
+
+/* Call at the start and end of an "rbreak" command to register
+ breakpoint numbers for a later "commands" command. */
+extern void start_rbreak_breakpoints (void);
+extern void end_rbreak_breakpoints (void);
+
#endif /* !defined (BREAKPOINT_H) */
projects / deliverable / binutils-gdb.git / blobdiff