This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#if !defined (BREAKPOINT_H)
#define BREAKPOINT_H 1
#include "frame.h"
#include "value.h"
+#include "vec.h"
#include "gdb-events.h"
stepping over signal handlers, and for skipping prologues. */
bp_step_resume,
- /* Used by wait_for_inferior for stepping over signal handlers. */
- bp_through_sigtramp,
-
/* Used to detect when a watchpoint expression has gone out of
scope. These breakpoints are usually not visible to the user.
bp_catch_fork,
bp_catch_vfork,
bp_catch_exec,
-
- /* These are catchpoints to implement "catch catch" and "catch throw"
- commands for C++ exception handling. */
- bp_catch_catch,
- bp_catch_throw
-
-
};
/* States of enablement of breakpoint. */
{
bp_disabled, /* The eventpoint is inactive, and cannot trigger. */
bp_enabled, /* The eventpoint is active, and can trigger. */
- bp_shlib_disabled, /* The eventpoint's address is in an unloaded solib.
- The eventpoint will be automatically enabled
- and reset when that solib is loaded. */
bp_call_disabled, /* The eventpoint has been disabled while a call
into the inferior is "in flight", because some
eventpoints interfere with the implementation of
{
/* Address at which the breakpoint was placed. This is normally the
same as ADDRESS from the bp_location, except when adjustment
- happens in BREAKPOINT_FROM_PC. The most common form of
+ happens in gdbarch_breakpoint_from_pc. The most common form of
adjustment is stripping an alternate ISA marker from the PC which
is used to determine the type of breakpoint to insert. */
CORE_ADDR placed_address;
int shadow_len;
/* The size of the placed breakpoint, according to
- BREAKPOINT_FROM_PC, when the breakpoint was inserted. This is
+ gdbarch_breakpoint_from_pc, when the breakpoint was inserted. This is
generally the same as SHADOW_LEN, unless we did not need
to read from the target to implement the memory breakpoint
(e.g. if a remote stub handled the details). We may still
struct bp_location
{
- /* Chain pointer to the next breakpoint location. */
+ /* Chain pointer to the next breakpoint location for
+ the same parent breakpoint. */
struct bp_location *next;
+ /* Pointer to the next breakpoint location, in a global
+ list of all breakpoint locations. */
+ struct bp_location *global_next;
+
/* Type of this breakpoint location. */
enum bp_loc_type loc_type;
than reference counting. */
struct breakpoint *owner;
+ /* Conditional. Break only if this expression's value is nonzero.
+ Unlike string form of condition, which is associated with breakpoint,
+ this is associated with location, since if breakpoint has several
+ locations, the evaluation of expression can be different for
+ different locations. */
+ struct expression *cond;
+
+ /* This location's address is in an unloaded solib, and so this
+ location should not be inserted. It will be automatically
+ enabled when that solib is loaded. */
+ char shlib_disabled;
+
+ /* Is this particular location enabled. */
+ char enabled;
+
/* Nonzero if this breakpoint is now inserted. */
char inserted;
processor's architectual constraints. */
CORE_ADDR requested_address;
+ char *function_name;
+
/* Details of the placed breakpoint, when inserted. */
struct bp_target_info target_info;
void (*print_mention) (struct breakpoint *);
};
+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
+};
+
/* 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
/* Stack depth (address of frame). If nonzero, break only if fp
equals this. */
struct frame_id frame_id;
- /* Conditional. Break only if this expression's value is nonzero. */
- struct expression *cond;
/* String we used to set the breakpoint (malloc'd). */
char *addr_string;
should be evaluated on the outermost frame. */
struct frame_id watchpoint_frame;
+ /* For hardware watchpoints, the triggered status according to the
+ hardware. */
+ enum watchpoint_triggered watchpoint_triggered;
+
/* Thread number for thread-specific breakpoint, or -1 if don't care */
int thread;
/* Methods associated with this breakpoint. */
struct breakpoint_ops *ops;
- /* Was breakpoint issued from a tty? Saved for the use of pending breakpoints. */
- int from_tty;
-
- /* Flag value for pending breakpoint.
- first bit : 0 non-temporary, 1 temporary.
- second bit : 0 normal breakpoint, 1 hardware breakpoint. */
- int flag;
-
- /* Is breakpoint pending on shlib loads? */
- int pending;
+ /* Is breakpoint's condition not yet parsed because we found
+ no location initially so had no context to parse
+ the condition in. */
+ int condition_not_parsed;
};
+
+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
typedef struct bpstats *bpstat;
-/* Interface: */
-/* Clear a bpstat so that it says we are not at any breakpoint.
- Also free any storage that is part of a bpstat. */
+/* Frees any storage that is part of a bpstat.
+ Does not walk the 'next' chain. */
+extern void bpstat_free (bpstat);
+
+/* Clears a chain of bpstat, freeing storage
+ of each. */
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_stop_status (CORE_ADDR pc, ptid_t ptid,
- int stopped_by_watchpoint);
+extern bpstat bpstat_stop_status (CORE_ADDR pc, ptid_t ptid);
\f
/* This bpstat_what stuff tells wait_for_inferior what to do with a
breakpoint (a challenging task). */
/* Clear step resume breakpoint, and keep checking. */
BPSTAT_WHAT_STEP_RESUME,
- /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep
- checking. */
- BPSTAT_WHAT_THROUGH_SIGTRAMP,
-
/* Check the dynamic linker's data structures for new libraries, then
keep checking. */
BPSTAT_WHAT_CHECK_SHLIBS,
place, and a bpstat reflects the fact that both have been hit. */
bpstat next;
/* Breakpoint that we are at. */
- struct breakpoint *breakpoint_at;
+ const struct bp_location *breakpoint_at;
/* Commands left to be done. */
struct command_line *commands;
/* Old value associated with a watchpoint. */
extern int breakpoint_inserted_here_p (CORE_ADDR);
+extern int regular_breakpoint_inserted_here_p (CORE_ADDR);
+
extern int software_breakpoint_inserted_here_p (CORE_ADDR);
extern int breakpoint_thread_match (CORE_ADDR, ptid_t);
extern void set_default_breakpoint (int, CORE_ADDR, struct symtab *, int);
-extern void mark_breakpoints_out (void);
-
extern void breakpoint_init_inferior (enum inf_context);
extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
extern void rwatch_command_wrapper (char *, int);
extern void tbreak_command (char *, int);
-extern int insert_breakpoints (void);
+extern void insert_breakpoints (void);
extern int remove_breakpoints (void);
extern void remove_thread_event_breakpoints (void);
-extern void disable_breakpoints_in_shlibs (int silent);
-
-extern void re_enable_breakpoints_in_shlibs (void);
-
-extern void create_solib_load_event_breakpoint (char *, int, char *, char *);
-
-extern void create_solib_unload_event_breakpoint (char *, int,
- char *, char *);
-
-extern void create_fork_event_catchpoint (int, char *);
-
-extern void create_vfork_event_catchpoint (int, char *);
-
-extern void create_exec_event_catchpoint (int, char *);
+extern void disable_breakpoints_in_shlibs (void);
/* This function returns TRUE if ep is a catchpoint. */
extern int ep_is_catchpoint (struct breakpoint *);
such as a library load or unload. */
extern int ep_is_shlib_catchpoint (struct breakpoint *);
-extern struct breakpoint *set_breakpoint_sal (struct symtab_and_line);
-
/* Enable breakpoints and delete when hit. Called with ARG == NULL
deletes all breakpoints. */
extern void delete_command (char *arg, int from_tty);
extern void *deprecated_insert_raw_breakpoint (CORE_ADDR);
extern int deprecated_remove_raw_breakpoint (void *);
-/* Indicator of whether exception catchpoints should be nuked between
- runs of a program. */
-extern int deprecated_exception_catchpoints_are_fragile;
-
-/* Indicator of when exception catchpoints set-up should be
- reinitialized -- e.g. when program is re-run. */
-extern int deprecated_exception_support_initialized;
+/* Check if any hardware watchpoints have triggered, according to the
+ target. */
+int watchpoints_triggered (struct target_waitstatus *);
#endif /* !defined (BREAKPOINT_H) */
projects / deliverable / binutils-gdb.git / blobdiff