#include "ax.h"
#include "command.h"
#include "break-common.h"
+#include "probe.h"
struct value;
struct block;
/* 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
- adjustment is stripping an alternate ISA marker from the PC which
- is used to determine the type of breakpoint to insert. */
+ /* Address at which the breakpoint was placed. This is normally
+ the same as REQUESTED_ADDRESS, except when adjustment happens in
+ gdbarch_breakpoint_from_pc. The most common form of adjustment
+ is stripping an alternate ISA marker from the PC which is used
+ to determine the type of breakpoint to insert. */
CORE_ADDR placed_address;
+ /* Address at which the breakpoint was requested. */
+ CORE_ADDR reqstd_address;
+
/* If this is a ranged breakpoint, then this field contains the
length of the range that will be watched for execution. */
int length;
/* If the location comes from a probe point, this is the probe associated
with it. */
- struct probe *probe;
+ struct bound_probe probe;
char *function_name;
then an error occurred reading the value. */
int val_valid;
+ /* When watching the location of a bitfield, contains the offset and size of
+ the bitfield. Otherwise contains 0. */
+ int val_bitpos;
+ int val_bitsize;
+
/* Holds the frame address which identifies the frame this
watchpoint should be evaluated in, or `null' if the watchpoint
should be evaluated on the outermost frame. */
extern int software_breakpoint_inserted_here_p (struct address_space *,
CORE_ADDR);
+extern int single_step_breakpoint_inserted_here_p (struct address_space *,
+ 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 *,
extern int breakpoint_thread_match (struct address_space *,
CORE_ADDR, ptid_t);
+/* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
+ same breakpoint location. In most targets, this can only be true
+ if ASPACE1 matches ASPACE2. On targets that have global
+ breakpoints, the address space doesn't really matter. */
+
+extern int breakpoint_address_match (struct address_space *aspace1,
+ CORE_ADDR addr1,
+ struct address_space *aspace2,
+ CORE_ADDR addr2);
+
extern void until_break_command (char *, int, int);
/* Initialize a struct bp_location. */
extern void
add_catch_command (char *name, char *docstring,
- void (*sfunc) (char *args, int from_tty,
- struct cmd_list_element *command),
+ cmd_sfunc_ftype *sfunc,
completer_ftype *completer,
void *user_data_catch,
void *user_data_tcatch);
extern void delete_longjmp_breakpoint_at_next_stop (int thread);
extern struct breakpoint *set_longjmp_breakpoint_for_call_dummy (void);
-extern void check_longjmp_breakpoint_for_call_dummy (int thread);
+extern void check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp);
extern void enable_overlay_breakpoints (void);
extern void disable_overlay_breakpoints (void);
extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
CORE_ADDR);
+/* Create an solib event breakpoint at ADDRESS in the current program
+ space, and immediately try to insert it. Returns a pointer to the
+ breakpoint on success. Deletes the new breakpoint and returns NULL
+ if inserting the breakpoint fails. */
+extern struct breakpoint *create_and_insert_solib_event_breakpoint
+ (struct gdbarch *gdbarch, CORE_ADDR address);
+
extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
CORE_ADDR);
extern void remove_solib_event_breakpoints (void);
+/* Mark solib event breakpoints of the current program space with
+ delete at next stop disposition. */
+extern void remove_solib_event_breakpoints_at_next_stop (void);
+
extern void remove_thread_event_breakpoints (void);
extern void disable_breakpoints_in_shlibs (void);
const gdb_byte *writebuf_org,
ULONGEST memaddr, LONGEST len);
-extern int breakpoints_always_inserted_mode (void);
+/* Return true if breakpoints should be inserted now. That'll be the
+ case if either:
+
+ - the target has global breakpoints.
+
+ - "breakpoint always-inserted" is on, and the target has
+ execution.
+
+ - threads are executing.
+*/
+extern int breakpoints_should_be_inserted_now (void);
/* Called each time new event from target is processed.
Retires previously deleted breakpoint locations that
/* Find a tracepoint by parsing a number in the supplied string. */
extern struct tracepoint *
get_tracepoint_by_number (char **arg,
- struct get_number_or_range_state *state,
- int optional_p);
+ struct get_number_or_range_state *state);
/* Return a vector of all tracepoints currently defined. The vector
is newly allocated; the caller should free when done with it. */