/* Data structures associated with breakpoints in GDB.
- Copyright (C) 1992-2020 Free Software Foundation, Inc.
+ Copyright (C) 1992-2023 Free Software Foundation, Inc.
This file is part of GDB.
#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 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;
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... */
};
-class bp_location
+class bp_location : public refcounted_object, public intrusive_list_node<bp_location>
{
public:
- bp_location () = default;
-
/* Construct a bp_location with the type inferred from OWNER's
type. */
explicit bp_location (breakpoint *owner);
/* Construct a bp_location with type TYPE. */
bp_location (breakpoint *owner, bp_loc_type type);
- virtual ~bp_location ();
-
- /* Chain pointer to the next breakpoint location for
- the same parent breakpoint. */
- bp_location *next = NULL;
-
- /* The reference count. */
- int refc = 0;
+ virtual ~bp_location () = default;
/* Type of this breakpoint location. */
bp_loc_type loc_type {};
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 {};
struct symtab *symtab = NULL;
/* The symbol found by the location parser, if any. This may be used to
- ascertain when an event location was set at a different location than
+ 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;
/* 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,
- const 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) (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
- 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_to_sals'. */
- std::vector<symtab_and_line> (*decode_location)
- (struct breakpoint *b,
- struct event_location *location,
- struct program_space *search_pspace);
+ 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
-};
-
-/* 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;
-
-/* 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;
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. */
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;
+
+ /* Destructor for WATCHPOINT. */
+ ~watchpoint ();
/* 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;
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. */
/* 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. */
std::string static_trace_marker_id;
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;
};
\f
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,
+extern bpstat *build_bpstat_chain (const address_space *aspace,
CORE_ADDR bp_addr,
- const struct target_waitstatus *ws);
+ 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
several reasons concurrently.)
Each element of the chain has valid next, breakpoint_at,
- commands, FIXME??? fields. */
+ commands, FIXME??? fields.
-extern bpstat bpstat_stop_status (const address_space *aspace,
+ 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 struct target_waitstatus *ws,
- bpstat stop_chain = NULL);
+ 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).
};
/* 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 *);
/* 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 bool bpstat_explains_signal (bpstat, enum gdb_signal);
+extern bool bpstat_explains_signal (bpstat *, enum gdb_signal);
/* True if this bpstat causes a stop. */
-extern bool bpstat_causes_stop (bpstat);
+extern bool bpstat_causes_stop (bpstat *);
/* 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 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
{
- bpstats ();
- bpstats (struct bp_location *bl, bpstat **bs_link_pointer);
- ~bpstats ();
+ bpstat ();
+ bpstat (struct bp_location *bl, bpstat ***bs_link_pointer);
- bpstats (const bpstats &);
- bpstats &operator= (const bpstats &) = delete;
+ 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
/* Old value associated with a watchpoint. */
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. */
/* Initialize a struct bp_location. */
extern void update_breakpoint_locations
- (struct breakpoint *b,
+ (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_init_inferior (enum inf_context);
-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. */
extern void break_command (const char *, int);
-extern void watch_command_wrapper (const char *, int, int);
-extern void awatch_command_wrapper (const char *, int, int);
-extern void rwatch_command_wrapper (const char *, int, int);
+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 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 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_const_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,
- const char *addr_string,
- const struct breakpoint_ops *ops,
- int tempflag,
- int enabled,
- int from_tty);
-
-/* Initialize a new breakpoint of the bp_catchpoint kind. If TEMP
- is true, then make the breakpoint temporary. If COND_STRING is
- not NULL, then store it in the breakpoint. OPS, if not NULL, is
- the breakpoint_ops structure associated to the catchpoint. */
-
-extern void init_catchpoint (struct breakpoint *b,
- struct gdbarch *gdbarch, bool temp,
- 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.
-extern void install_breakpoint (int internal, std::unique_ptr<breakpoint> &&b,
- int update_gll);
+ Takes ownership of B, and returns a non-owning reference to it. */
-/* Returns the breakpoint ops appropriate for use with with LOCATION and
- according to IS_TRACEPOINT. Use this to ensure, for example, that you pass
- the correct ops to create_breakpoint for probe locations. If LOCATION is
- NULL, returns bkpt_breakpoint_ops (or tracepoint_breakpoint_ops, if
- IS_TRACEPOINT is true). */
+extern breakpoint *install_breakpoint
+ (int internal, std::unique_ptr<breakpoint> &&b, int update_gll);
-extern const struct breakpoint_ops *breakpoint_ops_for_event_location
- (const struct event_location *location, bool is_tracepoint);
+/* 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 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,
- 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 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);
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);
get_tracepoint_by_number (const char **arg,
number_or_range_parser *parser);
-/* Return a vector of all tracepoints currently defined. */
-extern std::vector<breakpoint *> all_tracepoints (void);
-
/* Return true if B is of tracepoint kind. */
extern bool is_tracepoint (const struct breakpoint *b);
DISABLE_COPY_AND_ASSIGN (scoped_rbreak_breakpoints);
};
-/* Breakpoint iterator function.
+/* Breakpoint linked list iterator. */
+
+using breakpoint_list = intrusive_list<breakpoint>;
+
+using breakpoint_iterator = breakpoint_list::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
- (gdb::function_view<bool (breakpoint *)>);
+/* Breakpoint linked list range. */
+
+using breakpoint_range = iterator_range<breakpoint_iterator>;
+
+/* 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 (const address_space *aspace,
CORE_ADDR pc,
- const struct target_waitstatus *ws);
+ const target_waitstatus &ws);
extern int user_breakpoint_p (struct breakpoint *);
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
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) */
projects / binutils-gdb.git / blobdiff