/* Data structures associated with breakpoints in GDB.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
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_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,
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
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
/* Display information about this breakpoint after setting it (roughly
speaking; this is called from "mention"). */
void (*print_mention) (struct breakpoint *);
+
+ /* Print to FP the CLI command that recreates this breakpoint. */
+ void (*print_recreate) (struct breakpoint *, struct ui_file *fp);
};
enum watchpoint_triggered
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. */
/* 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;
disabling/ending. */
int pass_count;
- /* Chain of action lines to execute when this tracepoint is hit. */
- struct action_line *actions;
+ /* 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). */
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 (CORE_ADDR);
+extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
-extern int breakpoint_inserted_here_p (CORE_ADDR);
+extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
-extern int regular_breakpoint_inserted_here_p (CORE_ADDR);
+extern int regular_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
-extern int software_breakpoint_inserted_here_p (CORE_ADDR);
+extern int software_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
-extern int breakpoint_thread_match (CORE_ADDR, ptid_t);
+/* 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 (struct address_space *, CORE_ADDR, ptid_t);
extern void until_break_command (char *, int, int);
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 (struct gdbarch *gdbarch,
- char *address, char *condition,
- int hardwareflag, int tempflag,
- int thread, int ignore_count,
- int pending,
- int enabled);
+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);
+/* 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.
/* Manage a software single step breakpoint (or two). Insert may be called
twice before remove is called. */
-extern void insert_single_step_breakpoint (struct gdbarch *, 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 (struct gdbarch *, CORE_ADDR);
+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
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);
/* 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);
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