#include "frame.h"
#include "value.h"
-#include "gdbsupport/vec.h"
#include "ax.h"
#include "command.h"
#include "gdbsupport/break-common.h"
#include "location.h"
#include <vector>
#include "gdbsupport/array-view.h"
+#include "gdbsupport/function-view.h"
#include "cli/cli-script.h"
struct block;
public:
bp_location () = default;
- bp_location (breakpoint *owner);
+ /* 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 ();
/* Is this particular location enabled. */
bool enabled = false;
- /* Nonzero if this breakpoint is now inserted. */
+ /* 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
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;
+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
event_location_up location;
/* 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. */
we do not know the value yet or the value was not readable. VAL
is never lazy. */
value_ref_ptr val;
- /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL,
+
+ /* 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. */
/* 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);
+
+/* Return true if BPT is of any watchpoint kind, hardware or
+ software. */
-/* Returns true if BPT is really a watchpoint. */
+extern bool is_watchpoint (const struct breakpoint *bpt);
-extern int 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. */
/* 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. */
/* Find the bpstat associated with a breakpoint. NULL otherwise. */
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
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. */
/* Return a vector of all tracepoints currently defined. */
extern std::vector<breakpoint *> all_tracepoints (void);
-extern int is_tracepoint (const struct breakpoint *b);
+/* 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);
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 *);
+extern struct breakpoint *iterate_over_breakpoints
+ (gdb::function_view<bool (breakpoint *)>);
/* Nonzero if the specified PC cannot be a location where functions
have been inlined. */