/* Data structures associated with breakpoints in GDB.
- Copyright (C) 1992-2017 Free Software Foundation, Inc.
+ Copyright (C) 1992-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "frame.h"
#include "value.h"
-#include "vec.h"
#include "ax.h"
#include "command.h"
-#include "break-common.h"
+#include "gdbsupport/break-common.h"
#include "probe.h"
#include "location.h"
#include <vector>
+#include "gdbsupport/array-view.h"
+#include "gdbsupport/filtered-iterator.h"
+#include "gdbsupport/function-view.h"
+#include "gdbsupport/next-iterator.h"
+#include "gdbsupport/iterator-range.h"
+#include "gdbsupport/refcounted-object.h"
+#include "gdbsupport/safe-iterator.h"
+#include "cli/cli-script.h"
+#include "target/waitstatus.h"
-struct value;
struct block;
struct gdbpy_breakpoint_object;
struct gdbscm_breakpoint_object;
struct number_or_range_parser;
struct thread_info;
-struct bpstats;
+struct bpstat;
struct bp_location;
struct linespec_result;
struct linespec_sals;
+struct inferior;
+
+/* Enum for exception-handling support in 'catch throw', 'catch rethrow',
+ 'catch catch' and the MI equivalent. */
+
+enum exception_event_kind
+{
+ EX_EVENT_THROW,
+ EX_EVENT_RETHROW,
+ EX_EVENT_CATCH
+};
/* Why are we removing the breakpoint from the target? */
bp_tracepoint,
bp_fast_tracepoint,
bp_static_tracepoint,
+ /* Like bp_static_tracepoint but for static markers. */
+ bp_static_marker_tracepoint,
/* A dynamic printf stops at the given location, does a formatted
print, then automatically continues. (Although this is sort of
{
bp_loc_software_breakpoint,
bp_loc_hardware_breakpoint,
+ bp_loc_software_watchpoint,
bp_loc_hardware_watchpoint,
+ bp_loc_tracepoint,
bp_loc_other /* Miscellaneous... */
};
-/* This structure is a collection of function pointers that, if
- available, will be called instead of performing the default action
- for this bp_loc_type. */
-
-struct bp_location_ops
-{
- /* Destructor. Releases everything from SELF (but not SELF
- itself). */
- void (*dtor) (struct bp_location *self);
-};
-
-class bp_location
+class bp_location : public refcounted_object, public intrusive_list_node<bp_location>
{
public:
- bp_location () = default;
-
- bp_location (const bp_location_ops *ops, breakpoint *owner);
+ /* Construct a bp_location with the type inferred from OWNER's
+ type. */
+ explicit bp_location (breakpoint *owner);
- /* Chain pointer to the next breakpoint location for
- the same parent breakpoint. */
- bp_location *next = NULL;
+ /* Construct a bp_location with type TYPE. */
+ bp_location (breakpoint *owner, bp_loc_type type);
- /* Methods associated with this location. */
- const bp_location_ops *ops = NULL;
-
- /* The reference count. */
- int refc = 0;
+ virtual ~bp_location () = default;
/* Type of this breakpoint location. */
bp_loc_type loc_type {};
agent_expr_up cmd_bytecode;
/* Signals that breakpoint conditions and/or commands need to be
- re-synched with the target. This has no use other than
+ re-synced with the target. This has no use other than
target-side breakpoints. */
bool needs_update = false;
/* Is this particular location enabled. */
bool enabled = false;
- /* Nonzero if this breakpoint is now inserted. */
+ /* Is this particular location disabled because the condition
+ expression is invalid at this location. For a location to be
+ reported as enabled, the ENABLED field above has to be true *and*
+ the DISABLED_BY_COND field has to be false. */
+ bool disabled_by_cond = false;
+
+ /* True if this breakpoint is now inserted. */
bool inserted = false;
- /* Nonzero if this is a permanent breakpoint. There is a breakpoint
+ /* True if this is a permanent breakpoint. 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 its
value. Step over it using the architecture's
gdbarch_skip_permanent_breakpoint method. */
bool permanent = false;
- /* Nonzero if this is not the first breakpoint in the list
+ /* True if this is not the first breakpoint in the list
for the given address. location of tracepoint can _never_
be duplicated with other locations of tracepoints and other
kinds of breakpoints, because two locations at the same
with it. */
bound_probe probe {};
- char *function_name = NULL;
+ gdb::unique_xmalloc_ptr<char> function_name;
/* Details of the placed breakpoint, when inserted. */
bp_target_info target_info {};
to find the corresponding source file name. */
struct symtab *symtab = NULL;
+
+ /* The symbol found by the location parser, if any. This may be used to
+ ascertain when a location spec was set at a different location than
+ the one originally selected by parsing, e.g., inlined symbols. */
+ const struct symbol *symbol = NULL;
+
+ /* Similarly, the minimal symbol found by the location parser, if
+ any. This may be used to ascertain if the location was
+ originally set on a GNU ifunc symbol. */
+ const minimal_symbol *msymbol = NULL;
+
+ /* The objfile the symbol or minimal symbol were found in. */
+ const struct objfile *objfile = NULL;
+
+ /* Return a string representation of the bp_location.
+ This is only meant to be used in debug messages. */
+ std::string to_string () const;
};
+/* A policy class for bp_location reference counting. */
+struct bp_location_ref_policy
+{
+ static void incref (bp_location *loc)
+ {
+ loc->incref ();
+ }
+
+ static void decref (bp_location *loc)
+ {
+ gdb_assert (loc->refcount () > 0);
+ loc->decref ();
+ if (loc->refcount () == 0)
+ delete loc;
+ }
+};
+
+/* A gdb::ref_ptr that has been specialized for bp_location. */
+typedef gdb::ref_ptr<bp_location, bp_location_ref_policy>
+ bp_location_ref_ptr;
+
/* The possible return values for print_bpstat, print_it_normal,
print_it_done, print_it_noop. */
enum print_stop_action
struct breakpoint_ops
{
+ /* Create SALs from location spec, storing the result in
+ linespec_result.
+
+ For an explanation about the arguments, see the function
+ `create_sals_from_location_spec_default'.
+
+ This function is called inside `create_breakpoint'. */
+ void (*create_sals_from_location_spec) (location_spec *locspec,
+ struct linespec_result *canonical);
+
+ /* This method will be responsible for creating a breakpoint given its SALs.
+ Usually, it just calls `create_breakpoints_sal' (for ordinary
+ breakpoints). However, there may be some special cases where we might
+ need to do some tweaks, e.g., see
+ `strace_marker_create_breakpoints_sal'.
+
+ This function is called inside `create_breakpoint'. */
+ void (*create_breakpoints_sal) (struct gdbarch *,
+ struct linespec_result *,
+ gdb::unique_xmalloc_ptr<char>,
+ gdb::unique_xmalloc_ptr<char>,
+ enum bptype, enum bpdisp, int, int, int,
+ int, int, int, int, unsigned);
+};
+
+enum watchpoint_triggered
+{
+ /* This watchpoint definitely did not trigger. */
+ watch_triggered_no = 0,
+
+ /* Some hardware watchpoint triggered, and it might have been this
+ one, but we do not know which it was. */
+ watch_triggered_unknown,
+
+ /* This hardware watchpoint definitely did trigger. */
+ watch_triggered_yes
+};
+
+/* Some targets (e.g., embedded PowerPC) need two debug registers to set
+ a watchpoint over a memory region. If this flag is true, GDB will use
+ only one register per watchpoint, thus assuming that all accesses that
+ modify a memory location happen at its starting address. */
+
+extern bool target_exact_watchpoints;
+
+using bp_location_list = intrusive_list<bp_location>;
+using bp_location_iterator = bp_location_list::iterator;
+using bp_location_range = iterator_range<bp_location_iterator>;
+
+/* 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
+ useful for a hack I had to put in; I'm going to leave it in because
+ I can see how there might be times when it would indeed be useful */
+
+/* Abstract base class representing all kinds of breakpoints. */
+
+struct breakpoint : public intrusive_list_node<breakpoint>
+{
+ breakpoint (struct gdbarch *gdbarch_, enum bptype bptype,
+ bool temp = true, const char *cond_string = nullptr);
+
+ DISABLE_COPY_AND_ASSIGN (breakpoint);
+
+ virtual ~breakpoint () = 0;
+
/* Allocate a location for this breakpoint. */
- struct bp_location * (*allocate_location) (struct breakpoint *);
+ virtual struct bp_location *allocate_location ();
+
+ /* Return a range of this breakpoint's locations. */
+ bp_location_range locations () const;
+
+ /* Add LOC to the location list of this breakpoint, sorted by address
+ (using LOC.ADDRESS).
+
+ LOC must have this breakpoint as its owner. LOC must not already be linked
+ in a location list. */
+ void add_location (bp_location &loc);
+
+ /* Remove LOC from this breakpoint's location list. The name is a bit funny
+ because remove_location is already taken, and means something else.
+
+ LOC must be have this breakpoints as its owner. LOC must be linked in this
+ breakpoint's location list. */
+ void unadd_location (bp_location &loc);
+
+ /* Clear the location list of this breakpoint. */
+ void clear_locations ()
+ { m_locations.clear (); }
+
+ /* Split all locations of this breakpoint that are bound to PSPACE out of its
+ location list to a separate list and return that list. If
+ PSPACE is nullptr, hoist out all locations. */
+ bp_location_list steal_locations (program_space *pspace);
+
+ /* Return true if this breakpoint has a least one location. */
+ bool has_locations () const
+ { return !m_locations.empty (); }
+
+ /* Return true if this breakpoint has a single location. */
+ bool has_single_location () const
+ {
+ if (!this->has_locations ())
+ return false;
+
+ return std::next (m_locations.begin ()) == m_locations.end ();
+ }
+
+ /* Return true if this breakpoint has multiple locations. */
+ bool has_multiple_locations () const
+ {
+ if (!this->has_locations ())
+ return false;
+
+ return std::next (m_locations.begin ()) != m_locations.end ();
+ }
+
+ /* Return a reference to the first location of this breakpoint. */
+ bp_location &first_loc ()
+ {
+ gdb_assert (this->has_locations ());
+ return m_locations.front ();
+ }
+
+ /* Return a reference to the first location of this breakpoint. */
+ const bp_location &first_loc () const
+ {
+ gdb_assert (this->has_locations ());
+ return m_locations.front ();
+ }
+
+ /* Return a reference to the last location of this breakpoint. */
+ const bp_location &last_loc () const
+ {
+ gdb_assert (this->has_locations ());
+ return m_locations.back ();
+ }
/* Reevaluate a breakpoint. This is necessary after symbols change
(e.g., an executable or DSO was loaded, or the inferior just
started). */
- void (*re_set) (struct breakpoint *self);
+ virtual void re_set ()
+ {
+ /* Nothing to re-set. */
+ }
/* Insert the breakpoint or watchpoint or activate the catchpoint.
Return 0 for success, 1 if the breakpoint, watchpoint or
catchpoint type is not supported, -1 for failure. */
- int (*insert_location) (struct bp_location *);
+ virtual int insert_location (struct bp_location *);
/* Remove the breakpoint/catchpoint that was previously inserted
with the "insert" method above. Return 0 for success, 1 if the
breakpoint, watchpoint or catchpoint type is not supported,
-1 for failure. */
- int (*remove_location) (struct bp_location *, enum remove_bp_reason reason);
+ virtual int remove_location (struct bp_location *,
+ enum remove_bp_reason reason);
/* Return true if it the target has stopped due to hitting
breakpoint location BL. This function does not check if we
space in which the event occurred, BP_ADDR is the address at
which the inferior stopped, and WS is the target_waitstatus
describing the event. */
- int (*breakpoint_hit) (const struct bp_location *bl,
- struct address_space *aspace,
- CORE_ADDR bp_addr,
- const struct target_waitstatus *ws);
+ virtual int breakpoint_hit (const struct bp_location *bl,
+ const address_space *aspace,
+ CORE_ADDR bp_addr,
+ const target_waitstatus &ws);
/* Check internal conditions of the breakpoint referred to by BS.
- If we should not stop for this breakpoint, set BS->stop to 0. */
- void (*check_status) (struct bpstats *bs);
+ If we should not stop for this breakpoint, set BS->stop to
+ false. */
+ virtual void check_status (struct bpstat *bs)
+ {
+ /* Always stop. */
+ }
/* Tell how many hardware resources (debug registers) are needed
for this breakpoint. If this function is not provided, then
the breakpoint or watchpoint needs one debug register. */
- int (*resources_needed) (const struct bp_location *);
-
- /* Tell whether we can downgrade from a hardware watchpoint to a software
- one. If not, the user will not be able to enable the watchpoint when
- there are not enough hardware resources available. */
- int (*works_in_software_mode) (const struct breakpoint *);
+ virtual int resources_needed (const struct bp_location *);
/* The normal print routine for this breakpoint, called when we
hit it. */
- enum print_stop_action (*print_it) (struct bpstats *bs);
+ virtual enum print_stop_action print_it (const bpstat *bs) const;
/* Display information about this breakpoint, for "info
- breakpoints". */
- void (*print_one) (struct breakpoint *, struct bp_location **);
+ breakpoints". Returns false if this method should use the
+ default behavior. */
+ virtual bool print_one (const bp_location **) const
+ {
+ return false;
+ }
/* Display extra information about this breakpoint, below the normal
breakpoint description in "info breakpoints".
In the example below, the "address range" line was printed
- by print_one_detail_ranged_breakpoint.
+ by ranged_breakpoint::print_one_detail.
(gdb) info breakpoints
Num Type Disp Enb Address What
address range: [0x10000458, 0x100004c7]
*/
- void (*print_one_detail) (const struct breakpoint *, struct ui_out *);
+ virtual void print_one_detail (struct ui_out *) const
+ {
+ /* Nothing. */
+ }
/* Display information about this breakpoint after setting it
(roughly speaking; this is called from "mention"). */
- void (*print_mention) (struct breakpoint *);
+ virtual void print_mention () const;
/* Print to FP the CLI command that recreates this breakpoint. */
- void (*print_recreate) (struct breakpoint *, struct ui_file *fp);
-
- /* Create SALs from location, storing the result in linespec_result.
-
- For an explanation about the arguments, see the function
- `create_sals_from_location_default'.
-
- This function is called inside `create_breakpoint'. */
- void (*create_sals_from_location) (const struct event_location *location,
- struct linespec_result *canonical,
- enum bptype type_wanted);
-
- /* This method will be responsible for creating a breakpoint given its SALs.
- Usually, it just calls `create_breakpoints_sal' (for ordinary
- breakpoints). However, there may be some special cases where we might
- need to do some tweaks, e.g., see
- `strace_marker_create_breakpoints_sal'.
-
- This function is called inside `create_breakpoint'. */
- void (*create_breakpoints_sal) (struct gdbarch *,
- struct linespec_result *,
- gdb::unique_xmalloc_ptr<char>,
- gdb::unique_xmalloc_ptr<char>,
- enum bptype, enum bpdisp, int, int,
- int, const struct breakpoint_ops *,
- int, int, int, unsigned);
-
- /* Given the location (second parameter), this method decodes it and
- provides the SAL locations related to it. For ordinary
- breakpoints, it calls `decode_line_full'. If SEARCH_PSPACE is
- not NULL, symbol search is restricted to just that program space.
-
- This function is called inside `location_to_sals'. */
- void (*decode_location) (struct breakpoint *b,
- const struct event_location *location,
- struct program_space *search_pspace,
- struct symtabs_and_lines *sals);
+ virtual void print_recreate (struct ui_file *fp) const;
/* Return true if this breakpoint explains a signal. See
bpstat_explains_signal. */
- int (*explains_signal) (struct breakpoint *, enum gdb_signal);
+ virtual bool explains_signal (enum gdb_signal)
+ {
+ return true;
+ }
/* Called after evaluating the breakpoint's condition,
and only if it evaluated true. */
- void (*after_condition_true) (struct bpstats *bs);
-};
-
-/* Helper for breakpoint_ops->print_recreate implementations. Prints
- the "thread" or "task" condition of B, and then a newline.
-
- Necessary because most breakpoint implementations accept
- thread/task conditions at the end of the spec line, like "break foo
- thread 1", which needs outputting before any breakpoint-type
- specific extra command necessary for B's recreation. */
-extern void print_recreate_thread (struct breakpoint *b, struct ui_file *fp);
-
-enum watchpoint_triggered
-{
- /* This watchpoint definitely did not trigger. */
- watch_triggered_no = 0,
-
- /* Some hardware watchpoint triggered, and it might have been this
- one, but we do not know which it was. */
- watch_triggered_unknown,
-
- /* This hardware watchpoint definitely did trigger. */
- watch_triggered_yes
-};
-
-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;
-
-/* Some targets (e.g., embedded PowerPC) need two debug registers to set
- a watchpoint over a memory region. If this flag is true, GDB will use
- only one register per watchpoint, thus assuming that all acesses that
- modify a memory location happen at its starting address. */
-
-extern int target_exact_watchpoints;
-
-/* 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
- useful for a hack I had to put in; I'm going to leave it in because
- I can see how there might be times when it would indeed be useful */
-
-/* This is for all kinds of breakpoints. */
-
-struct breakpoint
-{
- virtual ~breakpoint ();
-
- /* Methods associated with this breakpoint. */
- const breakpoint_ops *ops = NULL;
+ virtual void after_condition_true (struct bpstat *bs)
+ {
+ /* Nothing to do. */
+ }
- breakpoint *next = NULL;
/* Type of breakpoint. */
bptype type = bp_none;
/* Zero means disabled; remember the info but don't break here. */
/* Number assigned to distinguish breakpoints. */
int number = 0;
- /* Location(s) associated with this high-level breakpoint. */
- bp_location *loc = NULL;
-
/* True means a silent breakpoint (don't print frame info if we stop
here). */
bool silent = false;
/* Chain of command lines to execute when this breakpoint is
hit. */
- counted_command_line *commands = NULL;
+ counted_command_line commands;
/* Stack depth (address of frame). If nonzero, break only if fp
equals this. */
struct frame_id frame_id = null_frame_id;
non-thread-specific ordinary breakpoints this is NULL. */
program_space *pspace = NULL;
- /* Location we used to set the breakpoint. */
- event_location_up location;
+ /* The location specification we used to set the breakpoint. */
+ location_spec_up locspec;
/* The filter that should be passed to decode_line_full when
- re-setting this breakpoint. This may be NULL, but otherwise is
- allocated with xmalloc. */
- char *filter = NULL;
+ re-setting this breakpoint. This may be NULL. */
+ gdb::unique_xmalloc_ptr<char> filter;
- /* For a ranged breakpoint, the location we used to find the end of
- the range. */
- event_location_up location_range_end;
+ /* For a ranged breakpoint, the location specification we used to
+ find the end of the range. */
+ location_spec_up locspec_range_end;
/* Architecture we used to set the breakpoint. */
- struct gdbarch *gdbarch = NULL;
+ struct gdbarch *gdbarch;
/* Language we used to set the breakpoint. */
- enum language language = language_unknown;
+ enum language language;
/* Input radix we used to set the breakpoint. */
- int input_radix = 0;
+ int input_radix;
/* String form of the breakpoint condition (malloc'd), or NULL if
there is no condition. */
- char *cond_string = NULL;
+ gdb::unique_xmalloc_ptr<char> cond_string;
/* String form of extra parameters, or NULL if there are none.
Malloc'd. */
- char *extra_string = NULL;
+ gdb::unique_xmalloc_ptr<char> extra_string;
/* Holds the address of the related watchpoint_scope breakpoint when
using watchpoints on local variables (might the concept of a
related breakpoint be useful elsewhere, if not just call it the
watchpoint_scope breakpoint or something like that. FIXME). */
- breakpoint *related_breakpoint = NULL;
+ breakpoint *related_breakpoint;
/* Thread number for thread-specific breakpoint, or -1 if don't
care. */
int thread = -1;
- /* Ada task number for task-specific breakpoint, or 0 if don't
+ /* Inferior number for inferior-specific breakpoint, or -1 if this
+ breakpoint is for all inferiors. */
+ int inferior = -1;
+
+ /* Ada task number for task-specific breakpoint, or -1 if don't
care. */
- int task = 0;
+ int task = -1;
/* Count of the number of times this breakpoint was taken, dumped
with the info, but not used for anything else. Useful for seeing
/* Same as py_bp_object, but for Scheme. */
gdbscm_breakpoint_object *scm_bp_object = NULL;
+
+protected:
+
+ /* Helper for breakpoint_ops->print_recreate implementations. Prints
+ the "thread" or "task" condition of B, and then a newline.
+
+ Necessary because most breakpoint implementations accept
+ thread/task conditions at the end of the spec line, like "break foo
+ thread 1", which needs outputting before any breakpoint-type
+ specific extra command necessary for B's recreation. */
+ void print_recreate_thread (struct ui_file *fp) const;
+
+ /* Location(s) associated with this high-level breakpoint. */
+ bp_location_list m_locations;
};
-/* An instance of this type is used to represent a watchpoint. */
+/* Abstract base class representing code breakpoints. User "break"
+ breakpoints, internal and momentary breakpoints, etc. IOW, any
+ kind of breakpoint whose locations are created from SALs. */
+struct code_breakpoint : public breakpoint
+{
+ using breakpoint::breakpoint;
+
+ /* Create a breakpoint with SALS as locations. Use LOCATION as a
+ description of the location, and COND_STRING as condition
+ expression. If LOCATION is NULL then create an "address
+ location" from the address in the SAL. */
+ code_breakpoint (struct gdbarch *gdbarch, bptype type,
+ gdb::array_view<const symtab_and_line> sals,
+ location_spec_up &&locspec,
+ gdb::unique_xmalloc_ptr<char> filter,
+ gdb::unique_xmalloc_ptr<char> cond_string,
+ gdb::unique_xmalloc_ptr<char> extra_string,
+ enum bpdisp disposition,
+ int thread, int task, int inferior, int ignore_count,
+ int from_tty,
+ int enabled, unsigned flags,
+ int display_canonical);
+
+ ~code_breakpoint () override = 0;
+
+ /* Add a location for SAL to this breakpoint. */
+ bp_location *add_location (const symtab_and_line &sal);
+
+ void re_set () override;
+ int insert_location (struct bp_location *) override;
+ int remove_location (struct bp_location *,
+ enum remove_bp_reason reason) override;
+ int breakpoint_hit (const struct bp_location *bl,
+ const address_space *aspace,
+ CORE_ADDR bp_addr,
+ const target_waitstatus &ws) override;
+
+protected:
+
+ /* Given the location spec, this method decodes it and returns the
+ SAL locations related to it. For ordinary breakpoints, it calls
+ `decode_line_full'. If SEARCH_PSPACE is not NULL, symbol search
+ is restricted to just that program space.
+
+ This function is called inside `location_spec_to_sals'. */
+ virtual std::vector<symtab_and_line> decode_location_spec
+ (location_spec *locspec,
+ struct program_space *search_pspace);
+
+ /* Helper method that does the basic work of re_set. */
+ void re_set_default ();
+
+ /* Find the SaL locations corresponding to the given LOCATION.
+ On return, FOUND will be 1 if any SaL was found, zero otherwise. */
+
+ std::vector<symtab_and_line> location_spec_to_sals
+ (location_spec *locspec,
+ struct program_space *search_pspace,
+ int *found);
+
+ /* Helper for breakpoint and tracepoint breakpoint->mention
+ callbacks. */
+ void say_where () const;
+};
+
+/* An instance of this type is used to represent a watchpoint,
+ a.k.a. a data breakpoint. */
struct watchpoint : public breakpoint
{
- ~watchpoint () override;
+ using breakpoint::breakpoint;
+
+ void re_set () override;
+ int insert_location (struct bp_location *) override;
+ int remove_location (struct bp_location *,
+ enum remove_bp_reason reason) override;
+ int breakpoint_hit (const struct bp_location *bl,
+ const address_space *aspace,
+ CORE_ADDR bp_addr,
+ const target_waitstatus &ws) override;
+ void check_status (struct bpstat *bs) override;
+ int resources_needed (const struct bp_location *) override;
+
+ /* Tell whether we can downgrade from a hardware watchpoint to a software
+ one. If not, the user will not be able to enable the watchpoint when
+ there are not enough hardware resources available. */
+ virtual bool works_in_software_mode () const;
+
+ enum print_stop_action print_it (const bpstat *bs) const override;
+ void print_mention () const override;
+ void print_recreate (struct ui_file *fp) const override;
+ bool explains_signal (enum gdb_signal) override;
/* String form of exp to use for displaying to the user (malloc'd),
or NULL if none. */
- char *exp_string;
+ gdb::unique_xmalloc_ptr<char> exp_string;
/* String form to use for reparsing of EXP (malloc'd) or NULL. */
- char *exp_string_reparse;
+ gdb::unique_xmalloc_ptr<char> exp_string_reparse;
/* The expression we are watching, or NULL if not a watchpoint. */
expression_up exp;
/* 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. */
- struct value *val;
- /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL,
+ value_ref_ptr val;
+
+ /* True if VAL is valid. If VAL_VALID is set but VAL is NULL,
then an error occurred reading the value. */
- int val_valid;
+ bool val_valid;
/* When watching the location of a bitfield, contains the offset and size of
the bitfield. Otherwise contains 0. */
CORE_ADDR hw_wp_mask;
};
-/* Given a function FUNC (struct breakpoint *B, void *DATA) and
- USER_DATA, call FUNC for every known breakpoint passing USER_DATA
- as argument.
-
- If FUNC returns 1, the loop stops and the current
- 'struct breakpoint' being processed is returned. If FUNC returns
- zero, the loop continues.
-
- This function returns either a 'struct breakpoint' pointer or NULL.
- It was based on BFD's bfd_sections_find_if function. */
-
-extern struct breakpoint *breakpoint_find_if
- (int (*func) (struct breakpoint *b, void *d), void *user_data);
-
/* Return true if BPT is either a software breakpoint or a hardware
breakpoint. */
-extern int is_breakpoint (const struct breakpoint *bpt);
+extern bool is_breakpoint (const struct breakpoint *bpt);
-/* Returns true if BPT is really a watchpoint. */
+/* Return true if BPT is of any watchpoint kind, hardware or
+ software. */
-extern int is_watchpoint (const struct breakpoint *bpt);
+extern bool is_watchpoint (const struct breakpoint *bpt);
+
+/* Return true if BPT is a C++ exception catchpoint (catch
+ catch/throw/rethrow). */
+
+extern bool is_exception_catchpoint (breakpoint *bp);
/* An instance of this type is used to represent all kinds of
tracepoints. */
-struct tracepoint : public breakpoint
+struct tracepoint : public code_breakpoint
{
+ using code_breakpoint::code_breakpoint;
+
+ int breakpoint_hit (const struct bp_location *bl,
+ const address_space *aspace, CORE_ADDR bp_addr,
+ const target_waitstatus &ws) override;
+ void print_one_detail (struct ui_out *uiout) const override;
+ void print_mention () const override;
+ void print_recreate (struct ui_file *fp) const override;
+
/* Number of times this tracepoint should single-step and collect
additional data. */
- long step_count;
+ long step_count = 0;
/* Number of times this tracepoint should be hit before
disabling/ending. */
- int pass_count;
+ int pass_count = 0;
/* The number of the tracepoint on the target. */
- int number_on_target;
+ int number_on_target = 0;
/* The total space taken by all the trace frames for this
tracepoint. */
- ULONGEST traceframe_usage;
+ ULONGEST traceframe_usage = 0;
/* The static tracepoint marker id, if known. */
- char *static_trace_marker_id;
+ std::string static_trace_marker_id;
/* LTTng/UST allow more than one marker with the same ID string,
although it unadvised because it confuses tools. When setting
the array of markers we found for the given marker ID for which
this static tracepoint corresponds. When resetting breakpoints,
we will use this index to try to find the same marker again. */
- int static_trace_marker_id_idx;
+ int static_trace_marker_id_idx = 0;
+};
+
+/* The abstract base class for catchpoints. */
+
+struct catchpoint : public breakpoint
+{
+ /* If TEMP is true, then make the breakpoint temporary. If
+ COND_STRING is not NULL, then store it in the breakpoint. */
+ catchpoint (struct gdbarch *gdbarch, bool temp, const char *cond_string);
+
+ ~catchpoint () override = 0;
};
-typedef struct breakpoint *breakpoint_p;
-DEF_VEC_P(breakpoint_p);
\f
/* The following stuff is an abstract data type "bpstat" ("breakpoint
status"). This provides the ability to determine whether we have
stopped at a breakpoint, and what we should do about it. */
-typedef struct bpstats *bpstat;
-
/* Clears a chain of bpstat, freeing storage
of each. */
-extern void bpstat_clear (bpstat *);
+extern void bpstat_clear (bpstat **);
/* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
is part of the bpstat is copied as well. */
-extern bpstat bpstat_copy (bpstat);
+extern bpstat *bpstat_copy (bpstat *);
+
+/* Build the (raw) bpstat chain for the stop information given by ASPACE,
+ BP_ADDR, and WS. Returns the head of the bpstat chain. */
+
+extern bpstat *build_bpstat_chain (const address_space *aspace,
+ CORE_ADDR bp_addr,
+ const target_waitstatus &ws);
+
+/* Get a bpstat associated with having just stopped at address
+ BP_ADDR in thread PTID. STOP_CHAIN may be supplied as a previously
+ computed stop chain or NULL, in which case the stop chain will be
+ computed using build_bpstat_chain.
+
+ Determine whether we stopped at a breakpoint, etc, or whether we
+ don't understand this stop. Result is a chain of bpstat's such
+ that:
+
+ if we don't understand the stop, the result is a null pointer.
+
+ if we understand why we stopped, the result is not null.
+
+ Each element of the chain refers to a particular breakpoint or
+ watchpoint at which we have stopped. (We may have stopped for
+ several reasons concurrently.)
+
+ Each element of the chain has valid next, breakpoint_at,
+ commands, FIXME??? fields.
-extern bpstat bpstat_stop_status (struct address_space *aspace,
- CORE_ADDR pc, ptid_t ptid,
- const struct target_waitstatus *ws);
+ watchpoints_triggered must be called beforehand to set up each
+ watchpoint's watchpoint_triggered value.
+
+*/
+
+extern bpstat *bpstat_stop_status (const address_space *aspace,
+ CORE_ADDR pc, thread_info *thread,
+ const target_waitstatus &ws,
+ bpstat *stop_chain = nullptr);
+
+/* Like bpstat_stop_status, but clears all watchpoints'
+ watchpoint_triggered flag. Unlike with bpstat_stop_status, there's
+ no need to call watchpoint_triggered beforehand. You'll typically
+ use this variant when handling a known-non-watchpoint event, like a
+ fork or exec event. */
+
+extern bpstat *bpstat_stop_status_nowatch (const address_space *aspace,
+ CORE_ADDR bp_addr,
+ thread_info *thread,
+ const target_waitstatus &ws);
\f
+
+
/* This bpstat_what stuff tells wait_for_inferior what to do with a
breakpoint (a challenging task).
/* Used for BPSTAT_WHAT_SET_LONGJMP_RESUME and
BPSTAT_WHAT_CLEAR_LONGJMP_RESUME. True if we are handling a
longjmp, false if we are handling an exception. */
- int is_longjmp;
+ bool is_longjmp;
};
/* Tell what to do about this bpstat. */
-struct bpstat_what bpstat_what (bpstat);
+struct bpstat_what bpstat_what (bpstat *);
/* Run breakpoint event callbacks associated with the breakpoints that
triggered. */
-extern void bpstat_run_callbacks (bpstat bs_head);
+extern void bpstat_run_callbacks (bpstat *bs_head);
/* Find the bpstat associated with a breakpoint. NULL otherwise. */
-bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
+bpstat *bpstat_find_breakpoint (bpstat *, struct breakpoint *);
-/* Nonzero if a signal that we got in target_wait() was due to
+/* True if a signal that we got in target_wait() was due to
circumstances explained by the bpstat; the signal is therefore not
random. */
-extern int bpstat_explains_signal (bpstat, enum gdb_signal);
+extern bool bpstat_explains_signal (bpstat *, enum gdb_signal);
-/* Nonzero is this bpstat causes a stop. */
-extern int bpstat_causes_stop (bpstat);
+/* True if this bpstat causes a stop. */
+extern bool bpstat_causes_stop (bpstat *);
-/* Nonzero if we should step constantly (e.g. watchpoints on machines
+/* True 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. */
-extern int bpstat_should_step (void);
+extern bool bpstat_should_step ();
-/* Print a message indicating what happened. Returns nonzero to
- say that only the source line should be printed after this (zero
- return means print the frame as well as the source line). */
-extern enum print_stop_action bpstat_print (bpstat, int);
+/* Print a message indicating what happened. */
+extern enum print_stop_action bpstat_print (bpstat *bs, target_waitkind kind);
/* Put in *NUM the breakpoint number of the first breakpoint we are
stopped at. *BSP upon return is a bpstat which points to the
Return -1 if stopped at a breakpoint that has been deleted since
we set it.
Return 1 otherwise. */
-extern int bpstat_num (bpstat *, int *);
+extern int bpstat_num (bpstat **, int *);
+
+/* If BS indicates a breakpoint and this breakpoint has several code locations,
+ return the location number of BS, otherwise return 0. */
+
+extern int bpstat_locno (const bpstat *bs);
+
+/* Print BS breakpoint number optionally followed by a . and breakpoint locno.
+
+ For a breakpoint with only one code location, outputs the signed field
+ "bkptno" breakpoint number of BS (as returned by bpstat_num).
+ If BS has several code locations, outputs a '.' character followed by
+ the signed field "locno" (as returned by bpstat_locno). */
+
+extern void print_num_locno (const bpstat *bs, struct ui_out *);
/* Perform actions associated with the stopped inferior. Actually, we
just use this for breakpoint commands. Perhaps other actions will
print_it_done
};
-struct bpstats
+struct bpstat
{
+ bpstat ();
+ bpstat (struct bp_location *bl, bpstat ***bs_link_pointer);
+
+ bpstat (const bpstat &);
+ bpstat &operator= (const bpstat &) = delete;
+
/* Linked list because there can be more than one breakpoint at
the same place, and a bpstat reflects the fact that all have
been hit. */
- bpstat next;
+ bpstat *next;
/* Location that caused the stop. Locations are refcounted, so
this will never be NULL. Note that this location may end up
What this means is that we should not (in most cases) follow
the `bpstat->bp_location->owner' link, but instead use the
`breakpoint_at' field below. */
- struct bp_location *bp_location_at;
+ bp_location_ref_ptr bp_location_at;
/* Breakpoint that caused the stop. This is nullified if the
breakpoint ends up being deleted. See comments on
struct breakpoint *breakpoint_at;
/* The associated command list. */
- struct counted_command_line *commands;
+ counted_command_line commands;
/* Old value associated with a watchpoint. */
- struct value *old_val;
+ value_ref_ptr old_val;
- /* Nonzero if this breakpoint tells us to print the frame. */
- char print;
+ /* True if this breakpoint tells us to print the frame. */
+ bool print;
- /* Nonzero if this breakpoint tells us to stop. */
- char stop;
+ /* True if this breakpoint tells us to stop. */
+ bool stop;
/* Tell bpstat_print and print_bp_stop_message how to print stuff
associated with this element of the bpstat chain. */
/* Prototypes for breakpoint-related functions. */
-/* Return 1 if there's a program/permanent breakpoint planted in
- memory at ADDRESS, return 0 otherwise. */
-
-extern int program_breakpoint_here_p (struct gdbarch *gdbarch, CORE_ADDR address);
-
-extern enum breakpoint_here breakpoint_here_p (struct address_space *,
+extern enum breakpoint_here breakpoint_here_p (const address_space *,
CORE_ADDR);
/* Return true if an enabled breakpoint exists in the range defined by
ADDR and LEN, in ASPACE. */
-extern int breakpoint_in_range_p (struct address_space *aspace,
+extern int breakpoint_in_range_p (const address_space *aspace,
CORE_ADDR addr, ULONGEST len);
-extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
-
-extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
+extern int moribund_breakpoint_here_p (const address_space *, CORE_ADDR);
-extern int regular_breakpoint_inserted_here_p (struct address_space *,
- CORE_ADDR);
+extern int breakpoint_inserted_here_p (const address_space *,
+ CORE_ADDR);
-extern int software_breakpoint_inserted_here_p (struct address_space *,
+extern int software_breakpoint_inserted_here_p (const address_space *,
CORE_ADDR);
/* Return non-zero iff there is a hardware breakpoint inserted at
PC. */
-extern int hardware_breakpoint_inserted_here_p (struct address_space *,
+extern int hardware_breakpoint_inserted_here_p (const address_space *,
CORE_ADDR);
/* Check whether any location of BP is inserted at PC. */
extern int breakpoint_has_location_inserted_here (struct breakpoint *bp,
- struct address_space *aspace,
+ const address_space *aspace,
CORE_ADDR pc);
-extern int single_step_breakpoint_inserted_here_p (struct address_space *,
+extern int single_step_breakpoint_inserted_here_p (const 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 hardware_watchpoint_inserted_in_range (const address_space *,
CORE_ADDR addr,
ULONGEST len);
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,
+extern int breakpoint_address_match (const address_space *aspace1,
CORE_ADDR addr1,
- struct address_space *aspace2,
+ const address_space *aspace2,
CORE_ADDR addr2);
-extern void until_break_command (char *, int, int);
+extern void until_break_command (const char *, int, int);
/* Initialize a struct bp_location. */
-extern void update_breakpoint_locations (struct breakpoint *b,
- struct program_space *filter_pspace,
- struct symtabs_and_lines sals,
- struct symtabs_and_lines sals_end);
+extern void update_breakpoint_locations
+ (code_breakpoint *b,
+ struct program_space *filter_pspace,
+ gdb::array_view<const symtab_and_line> sals,
+ gdb::array_view<const symtab_and_line> sals_end);
extern void breakpoint_re_set (void);
extern void breakpoint_re_set_thread (struct breakpoint *);
-extern struct breakpoint *set_momentary_breakpoint
+extern void delete_breakpoint (struct breakpoint *);
+
+struct breakpoint_deleter
+{
+ void operator() (struct breakpoint *b) const
+ {
+ delete_breakpoint (b);
+ }
+};
+
+typedef std::unique_ptr<struct breakpoint, breakpoint_deleter> breakpoint_up;
+
+extern breakpoint_up set_momentary_breakpoint
(struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
-extern struct breakpoint *set_momentary_breakpoint_at_pc
+extern breakpoint_up set_momentary_breakpoint_at_pc
(struct gdbarch *, CORE_ADDR pc, enum bptype type);
extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
extern void breakpoint_init_inferior (enum inf_context);
-extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
-
-extern void delete_breakpoint (struct breakpoint *);
-
-extern void breakpoint_auto_delete (bpstat);
-
-typedef void (*walk_bp_location_callback) (struct bp_location *, void *);
-
-extern void iterate_over_bp_locations (walk_bp_location_callback);
+extern void breakpoint_auto_delete (bpstat *);
/* Return the chain of command lines to execute when this breakpoint
is hit. */
NOT be deallocated after use. */
const char *bpdisp_text (enum bpdisp disp);
-extern void break_command (char *, int);
-
-extern void hbreak_command_wrapper (char *, int);
-extern void thbreak_command_wrapper (char *, int);
-extern void rbreak_command_wrapper (char *, int);
-extern void watch_command_wrapper (char *, int, int);
-extern void awatch_command_wrapper (char *, int, int);
-extern void rwatch_command_wrapper (char *, int, int);
-extern void tbreak_command (char *, int);
+extern void break_command (const char *, int);
-extern struct breakpoint_ops base_breakpoint_ops;
-extern struct breakpoint_ops bkpt_breakpoint_ops;
-extern struct breakpoint_ops tracepoint_breakpoint_ops;
-extern struct breakpoint_ops dprintf_breakpoint_ops;
+extern void watch_command_wrapper (const char *, int, bool);
+extern void awatch_command_wrapper (const char *, int, bool);
+extern void rwatch_command_wrapper (const char *, int, bool);
+extern void tbreak_command (const char *, int);
-extern void initialize_breakpoint_ops (void);
+extern const struct breakpoint_ops code_breakpoint_ops;
/* Arguments to pass as context to some catch command handlers. */
#define CATCH_PERMANENT ((void *) (uintptr_t) 0)
extern void
add_catch_command (const char *name, const char *docstring,
- cmd_sfunc_ftype *sfunc,
+ cmd_func_ftype *func,
completer_ftype *completer,
void *user_data_catch,
void *user_data_tcatch);
-/* Initialize a breakpoint struct for Ada exception catchpoints. */
-
-extern void
- init_ada_exception_breakpoint (struct breakpoint *b,
- struct gdbarch *gdbarch,
- struct symtab_and_line sal,
- char *addr_string,
- const struct breakpoint_ops *ops,
- int tempflag,
- int enabled,
- int from_tty);
-
-extern void init_catchpoint (struct breakpoint *b,
- struct gdbarch *gdbarch, int tempflag,
- const char *cond_string,
- const struct breakpoint_ops *ops);
-
/* Add breakpoint B on the breakpoint list, and notify the user, the
target and breakpoint_created observers of its existence. If
INTERNAL is non-zero, the breakpoint number will be allocated from
the internal breakpoint count. If UPDATE_GLL is non-zero,
- update_global_location_list will be called. */
+ update_global_location_list will be called.
+
+ Takes ownership of B, and returns a non-owning reference to it. */
+
+extern breakpoint *install_breakpoint
+ (int internal, std::unique_ptr<breakpoint> &&b, int update_gll);
+
+/* Returns the breakpoint ops appropriate for use with with LOCSPEC
+ and according to IS_TRACEPOINT. Use this to ensure, for example,
+ that you pass the correct ops to create_breakpoint for probe
+ location specs. If LOCSPEC is NULL, returns
+ code_breakpoint_ops. */
-extern void install_breakpoint (int internal, std::unique_ptr<breakpoint> &&b,
- int update_gll);
+extern const struct breakpoint_ops *breakpoint_ops_for_location_spec
+ (const location_spec *locspec, bool is_tracepoint);
/* Flags that can be passed down to create_breakpoint, etc., to affect
breakpoint creation in several ways. */
CREATE_BREAKPOINT_FLAGS_INSERTED = 1 << 0
};
-/* Set a breakpoint. This function is shared between CLI and MI functions
- for setting a breakpoint at LOCATION.
+/* Set a breakpoint. This function is shared between CLI and MI
+ functions for setting a breakpoint at LOCSPEC.
This function has two major modes of operations, selected by the
PARSE_EXTRA parameter.
- If PARSE_EXTRA is zero, LOCATION is just the breakpoint's location,
- with condition, thread, and extra string specified by the COND_STRING,
- THREAD, and EXTRA_STRING parameters.
+ If PARSE_EXTRA is zero, LOCSPEC is just the breakpoint's location
+ spec, with condition, thread, and extra string specified by the
+ COND_STRING, THREAD, and EXTRA_STRING parameters.
If PARSE_EXTRA is non-zero, this function will attempt to extract
the condition, thread, and extra string from EXTRA_STRING, ignoring
the similarly named parameters.
+ If FORCE_CONDITION is true, the condition is accepted even when it is
+ invalid at all of the locations. However, if PARSE_EXTRA is non-zero,
+ the FORCE_CONDITION parameter is ignored and the corresponding argument
+ is parsed from EXTRA_STRING.
+
If INTERNAL is non-zero, the breakpoint number will be allocated
from the internal breakpoint count.
Returns true if any breakpoint was created; false otherwise. */
extern int create_breakpoint (struct gdbarch *gdbarch,
- const struct event_location *location,
+ struct location_spec *locspec,
const char *cond_string, int thread,
+ int inferior,
const char *extra_string,
+ bool force_condition,
int parse_extra,
int tempflag, enum bptype wanted_type,
int ignore_count,
extern int remove_breakpoints (void);
-extern int remove_breakpoints_pid (int pid);
+/* Remove breakpoints of inferior INF. */
-/* 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 following the processes of a fork() or vfork() system call,
- when both of the resulting two processes are to be followed. */
-extern int reattach_breakpoints (int);
+extern void remove_breakpoints_inf (inferior *inf);
/* This function can be used to update the breakpoint package's state
after an exec() system call has been executed.
extern void enable_breakpoint (struct breakpoint *);
extern void breakpoint_set_commands (struct breakpoint *b,
- command_line_up &&commands);
+ counted_command_line &&commands);
extern void breakpoint_set_silent (struct breakpoint *b, int silent);
+/* Set the thread for this breakpoint. If THREAD is -1, make the
+ breakpoint work for any thread. Passing a value other than -1 for
+ THREAD should only be done if b->task is 0; it is not valid to try and
+ set both a thread and task restriction on a breakpoint. */
+
extern void breakpoint_set_thread (struct breakpoint *b, int thread);
+/* Set the inferior for breakpoint B to INFERIOR. If INFERIOR is -1, make
+ the breakpoint work for any inferior. */
+
+extern void breakpoint_set_inferior (struct breakpoint *b, int inferior);
+
+/* Set the task for this breakpoint. If TASK is -1, make the breakpoint
+ work for any task. Passing a value other than -1 for TASK should only
+ be done if b->thread is -1; it is not valid to try and set both a thread
+ and task restriction on a breakpoint. */
+
extern void breakpoint_set_task (struct breakpoint *b, int task);
/* Clear the "inserted" flag in all breakpoints. */
extern void mark_breakpoints_out (void);
extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
- CORE_ADDR);
+ CORE_ADDR);
extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
CORE_ADDR);
extern void disable_breakpoints_in_shlibs (void);
-/* This function returns TRUE if ep is a catchpoint. */
-extern int is_catchpoint (struct breakpoint *);
+/* This function returns true if B is a catchpoint. */
+
+extern bool is_catchpoint (struct breakpoint *b);
/* Shared helper function (MI and CLI) for creating and installing
- a shared object event catchpoint. */
-extern void add_solib_catchpoint (const char *arg, int is_load, int is_temp,
- int enabled);
+ a shared object event catchpoint. If IS_LOAD is true then
+ the events to be caught are load events, otherwise they are
+ unload events. If IS_TEMP is true the catchpoint is a
+ temporary one. If ENABLED is true the catchpoint is
+ created in an enabled state. */
-/* Enable breakpoints and delete when hit. Called with ARG == NULL
- deletes all breakpoints. */
-extern void delete_command (char *arg, int from_tty);
+extern void add_solib_catchpoint (const char *arg, bool is_load, bool is_temp,
+ bool enabled);
/* Create and insert a new software single step breakpoint for the
current thread. May be called multiple times; each time will add a
new location to the set of potential addresses the next instruction
is at. */
extern void insert_single_step_breakpoint (struct gdbarch *,
- struct address_space *,
+ const address_space *,
CORE_ADDR);
/* Insert all software single step breakpoints for the current frame.
otherwise, return false. */
extern int insert_single_step_breakpoints (struct gdbarch *);
-/* Check if any hardware watchpoints have triggered, according to the
- target. */
-int watchpoints_triggered (struct target_waitstatus *);
+/* Check whether any hardware watchpoints have triggered or not,
+ according to the target, and record it in each watchpoint's
+ 'watchpoint_triggered' field. */
+int watchpoints_triggered (const target_waitstatus &);
/* Helper for transparent breakpoint hiding for memory read and write
routines.
in our opinion won't ever trigger. */
extern void breakpoint_retire_moribund (void);
-/* Set break condition of breakpoint B to EXP. */
+/* Set break condition of breakpoint B to EXP.
+ If FORCE, define the condition even if it is invalid in
+ all of the breakpoint locations. */
extern void set_breakpoint_condition (struct breakpoint *b, const char *exp,
- int from_tty);
+ int from_tty, bool force);
+
+/* Set break condition for the breakpoint with number BPNUM to EXP.
+ Raise an error if no breakpoint with the given number is found.
+ Also raise an error if the breakpoint already has stop conditions.
+ If FORCE, define the condition even if it is invalid in
+ all of the breakpoint locations. */
+extern void set_breakpoint_condition (int bpnum, const char *exp,
+ int from_tty, bool force);
/* Checks if we are catching syscalls or not.
Returns 0 if not, greater than 0 if we are. */
/* 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);
+ Returns false if not, true if we are. */
+extern bool catching_syscall_number (int syscall_number);
/* Return a tracepoint with the given number if found. */
extern struct tracepoint *get_tracepoint (int num);
/* Find a tracepoint by parsing a number in the supplied string. */
extern struct tracepoint *
- get_tracepoint_by_number (char **arg,
+ get_tracepoint_by_number (const char **arg,
number_or_range_parser *parser);
-/* 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);
+/* Return true if B is of tracepoint kind. */
+
+extern bool is_tracepoint (const struct breakpoint *b);
+
+/* Return a vector of all static tracepoints defined at ADDR. */
+extern std::vector<breakpoint *> static_tracepoints_here (CORE_ADDR addr);
+
+/* Create an instance of this to start registering breakpoint numbers
+ for a later "commands" command. */
+
+class scoped_rbreak_breakpoints
+{
+public:
+
+ scoped_rbreak_breakpoints ();
+ ~scoped_rbreak_breakpoints ();
+
+ DISABLE_COPY_AND_ASSIGN (scoped_rbreak_breakpoints);
+};
-extern int is_tracepoint (const struct breakpoint *b);
+/* Breakpoint linked list iterator. */
-/* Return a vector of all static tracepoints defined at ADDR. The
- vector is newly allocated; the caller should free when done with
- it. */
-extern VEC(breakpoint_p) *static_tracepoints_here (CORE_ADDR addr);
+using breakpoint_list = intrusive_list<breakpoint>;
-/* 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);
+using breakpoint_iterator = breakpoint_list::iterator;
-/* 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);
+/* Breakpoint linked list range. */
-/* Breakpoint iterator function.
+using breakpoint_range = iterator_range<breakpoint_iterator>;
- Calls a callback function once for each breakpoint, so long as the
- callback function returns false. If the callback function returns
- true, the iteration will end and the current breakpoint will be
- returned. This can be useful for implementing a search for a
- breakpoint with arbitrary attributes, or for applying an operation
- to every breakpoint. */
-extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *,
- void *), void *);
+/* Return a range to iterate over all breakpoints. */
+
+breakpoint_range all_breakpoints ();
+
+/* Breakpoint linked list range, safe against deletion of the current
+ breakpoint while iterating. */
+
+using breakpoint_safe_range = basic_safe_range<breakpoint_range>;
+
+/* Return a range to iterate over all breakpoints. This range is safe against
+ deletion of the current breakpoint while iterating. */
+
+breakpoint_safe_range all_breakpoints_safe ();
+
+/* Breakpoint filter to only keep tracepoints. */
+
+struct tracepoint_filter
+{
+ bool operator() (breakpoint &b)
+ { return is_tracepoint (&b); }
+};
+
+/* Breakpoint linked list iterator, filtering to only keep tracepoints. */
+
+using tracepoint_iterator
+ = filtered_iterator<breakpoint_iterator, tracepoint_filter>;
+
+/* Breakpoint linked list range, filtering to only keep tracepoints. */
+
+using tracepoint_range = iterator_range<tracepoint_iterator>;
+
+/* Return a range to iterate over all tracepoints. */
+
+tracepoint_range all_tracepoints ();
+
+/* Return a range to iterate over all breakpoint locations. */
+
+const std::vector<bp_location *> &all_bp_locations ();
/* Nonzero if the specified PC cannot be a location where functions
have been inlined. */
-extern int pc_at_non_inline_function (struct address_space *aspace,
+extern int pc_at_non_inline_function (const address_space *aspace,
CORE_ADDR pc,
- const struct target_waitstatus *ws);
+ const target_waitstatus &ws);
extern int user_breakpoint_p (struct breakpoint *);
UIOUT iff debugging multiple threads. */
extern void maybe_print_thread_hit_breakpoint (struct ui_out *uiout);
+/* Print the specified breakpoint. */
+extern void print_breakpoint (breakpoint *bp);
+
+/* Command element for the 'commands' command. */
+extern cmd_list_element *commands_cmd_element;
+
+/* Whether to use the fixed output when printing information about a
+ multi-location breakpoint (see PR 9659). */
+
+extern bool fix_multi_location_breakpoint_output_globally;
+
+/* Whether to use the fixed output when printing information about
+ commands attached to a breakpoint. */
+
+extern bool fix_breakpoint_script_output_globally;
+
+/* Deal with "catch catch", "catch throw", and "catch rethrow" commands and
+ the MI equivalents. Sets up to catch events of type EX_EVENT. When
+ TEMPFLAG is true only the next matching event is caught after which the
+ catch-point is deleted. If REGEX is not NULL then only exceptions whose
+ type name matches REGEX will trigger the event. */
+
+extern void catch_exception_event (enum exception_event_kind ex_event,
+ const char *regex, bool tempflag,
+ int from_tty);
+
+/* A helper function that prints a shared library stopped event.
+ IS_CATCHPOINT is true if the event is due to a "catch load"
+ catchpoint, false otherwise. */
+
+extern void print_solib_event (bool is_catchpoint);
+
+/* Print a message describing any user-breakpoints set at PC. This
+ concerns with logical breakpoints, so we match program spaces, not
+ address spaces. */
+
+extern void describe_other_breakpoints (struct gdbarch *,
+ struct program_space *, CORE_ADDR,
+ struct obj_section *, int);
+
+/* Enable or disable a breakpoint location LOC. ENABLE
+ specifies whether to enable or disable. */
+
+extern void enable_disable_bp_location (bp_location *loc, bool enable);
+
+
+/* Notify interpreters and observers that breakpoint B was modified. */
+
+extern void notify_breakpoint_modified (breakpoint *b);
+
#endif /* !defined (BREAKPOINT_H) */