/* Data structures associated with breakpoints in GDB.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GDB.
bp_overlay_event,
- /* These breakpoints are used to implement the "catch load" command
- on platforms whose dynamic linkers support such functionality. */
- bp_catch_load,
-
- /* These breakpoints are used to implement the "catch unload" command
- on platforms whose dynamic linkers support such functionality. */
- bp_catch_unload,
-
- /* These are not really breakpoints, but are catchpoints that
- implement the "catch fork", "catch vfork" and "catch exec" commands
- on platforms whose kernel support such functionality. (I.e.,
- kernels which can raise an event when a fork or exec occurs, as
- opposed to the debugger setting breakpoints on functions named
- "fork" or "exec".) */
- bp_catch_fork,
- bp_catch_vfork,
- bp_catch_exec,
+ /* Master copies of longjmp breakpoints. These are always installed
+ as soon as an objfile containing longjmp is loaded, but they are
+ always disabled. While necessary, temporary clones of bp_longjmp
+ type will be created and enabled. */
+
+ bp_longjmp_master,
+
+ bp_catchpoint,
+
+ bp_tracepoint,
+
+ /* Event for JIT compiled code generation or deletion. */
+ bp_jit_event,
};
/* States of enablement of breakpoint. */
automatically enabled and reset when the call
"lands" (either completes, or stops at another
eventpoint). */
+ bp_startup_disabled,/* The eventpoint has been disabled during inferior
+ startup. This is necessary on some targets where
+ the main executable will get relocated during
+ startup, making breakpoint addresses invalid.
+ The eventpoint will be automatically enabled and
+ reset once inferior startup is complete. */
bp_permanent /* 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
/* Data for specific breakpoint types. These could be a union, but
simplicity is more important than memory usage for breakpoints. */
+ /* Architecture associated with this location's address. May be
+ different from the breakpoint architecture. */
+ struct gdbarch *gdbarch;
+
/* Note that zero is a perfectly valid code address on some platforms
(for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL
is not a special value for this field. Valid for all types except
struct breakpoint_ops
{
+ /* Insert the breakpoint or activate the catchpoint. Should raise
+ an exception if the operation failed. */
+ void (*insert) (struct breakpoint *);
+
+ /* Remove the breakpoint/catchpoint that was previously inserted
+ with the "insert" method above. Return non-zero if the operation
+ succeeded. */
+ int (*remove) (struct breakpoint *);
+
+ /* Return non-zero if the debugger should tell the user that this
+ breakpoint was hit. */
+ int (*breakpoint_hit) (struct breakpoint *);
+
/* The normal print routine for this breakpoint, called when we
hit it. */
enum print_stop_action (*print_it) (struct breakpoint *);
/* Display information about this breakpoint, for "info breakpoints". */
- void (*print_one) (struct breakpoint *, CORE_ADDR *);
+ void (*print_one) (struct breakpoint *, struct bp_location **);
/* Display information about this breakpoint after setting it (roughly
speaking; this is called from "mention"). */
/* String we used to set the breakpoint (malloc'd). */
char *addr_string;
+ /* Architecture we used to set the breakpoint. */
+ struct gdbarch *gdbarch;
/* Language we used to set the breakpoint. */
enum language language;
/* Input radix we used to set the breakpoint. */
hardware. */
enum watchpoint_triggered watchpoint_triggered;
- /* Thread number for thread-specific breakpoint, or -1 if don't care */
+ /* Thread number for thread-specific breakpoint, or -1 if don't care. */
int thread;
+ /* Ada task number for task-specific breakpoint, or 0 if don't care. */
+ int task;
+
/* Count of the number of times this breakpoint was taken, dumped
with the info, but not used for anything else. Useful for
seeing how many times you hit a break prior to the program
aborting, so you can back up to just before the abort. */
int hit_count;
- /* Filename of a dynamically-linked library (dll), used for
- bp_catch_load and bp_catch_unload (malloc'd), or NULL if any
- library is significant. */
- char *dll_pathname;
-
- /* Filename of a dll whose state change (e.g., load or unload)
- triggered this catchpoint. This field is only valid immediately
- after this catchpoint has triggered. */
- char *triggered_dll_pathname;
-
/* Process id of a child process whose forking triggered this
catchpoint. This field is only valid immediately after this
catchpoint has triggered. */
no location initially so had no context to parse
the condition in. */
int condition_not_parsed;
+
+ /* Number of times this tracepoint should single-step
+ and collect additional data. */
+ long step_count;
+
+ /* Number of times this tracepoint should be hit before
+ disabling/ending. */
+ int pass_count;
+
+ /* Chain of action lines to execute when this tracepoint is hit. */
+ struct action_line *actions;
};
typedef struct breakpoint *breakpoint_p;
keep checking. */
BPSTAT_WHAT_CHECK_SHLIBS,
- /* Check the dynamic linker's data structures for new libraries, then
- resume out of the dynamic linker's callback, stop and print. */
- BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK,
+ /* Check for new JITed code. */
+ BPSTAT_WHAT_CHECK_JIT,
/* This is just used to keep track of how many enums there are. */
BPSTAT_WHAT_LAST
/* Modify BS so that the actions will not be performed. */
extern void bpstat_clear_actions (bpstat);
-/* Given a bpstat that records zero or more triggered eventpoints, this
- function returns another bpstat which contains only the catchpoints
- on that first list, if any.
- */
-extern void bpstat_get_triggered_catchpoints (bpstat, bpstat *);
-
/* Implementation: */
/* Values used to tell the printing routine how to behave for this bpstat. */
extern enum breakpoint_here breakpoint_here_p (CORE_ADDR);
+extern int moribund_breakpoint_here_p (CORE_ADDR);
+
extern int breakpoint_inserted_here_p (CORE_ADDR);
extern int regular_breakpoint_inserted_here_p (CORE_ADDR);
extern void breakpoint_re_set_thread (struct breakpoint *);
extern struct breakpoint *set_momentary_breakpoint
- (struct symtab_and_line, struct frame_id, enum bptype);
+ (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
extern struct breakpoint *set_momentary_breakpoint_at_pc
- (CORE_ADDR pc, enum bptype type);
+ (struct gdbarch *, CORE_ADDR pc, enum bptype type);
+
+extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
extern void set_ignore_count (int, int, int);
extern void breakpoint_auto_delete (bpstat);
-extern void breakpoint_clear_ignore_counts (void);
-
extern void break_command (char *, int);
extern void hbreak_command_wrapper (char *, int);
extern void rwatch_command_wrapper (char *, int);
extern void tbreak_command (char *, int);
-extern void set_breakpoint (char *address, char *condition,
+extern void set_breakpoint (struct gdbarch *gdbarch,
+ char *address, char *condition,
int hardwareflag, int tempflag,
int thread, int ignore_count,
- int pending);
+ int pending,
+ int enabled);
extern void insert_breakpoints (void);
inferior_ptid. */
extern int detach_breakpoints (int);
-extern void set_longjmp_breakpoint (void);
+extern void set_longjmp_breakpoint (int thread);
extern void delete_longjmp_breakpoint (int thread);
extern void enable_overlay_breakpoints (void);
extern void enable_watchpoints_after_interactive_call_stop (void);
+/* These functions disable and re-enable all breakpoints during
+ inferior startup. They are intended to be called from solib
+ code where necessary. This is needed on platforms where the
+ main executable is relocated at some point during startup
+ processing, making breakpoint addresses invalid.
+
+ If additional breakpoints are created after the routine
+ disable_breakpoints_before_startup but before the routine
+ enable_breakpoints_after_startup was called, they will also
+ be marked as disabled. */
+extern void disable_breakpoints_before_startup (void);
+extern void enable_breakpoints_after_startup (void);
+
/* For script interpreters that need to define breakpoint commands
after they've already read the commands into a struct command_line. */
extern enum command_control_type commands_from_control_command
extern int get_number_or_range (char **);
+extern struct breakpoint *get_breakpoint (int num);
+
/* The following are for displays, which aren't really breakpoints, but
here is as good a place as any for them. */
extern void enable_breakpoint (struct breakpoint *);
+extern void breakpoint_set_commands (struct breakpoint *b,
+ struct command_line *commands);
+
/* Clear the "inserted" flag in all breakpoints. */
extern void mark_breakpoints_out (void);
extern void make_breakpoint_permanent (struct breakpoint *);
-extern struct breakpoint *create_solib_event_breakpoint (CORE_ADDR);
+extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
+ CORE_ADDR);
+
+extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
+ CORE_ADDR);
-extern struct breakpoint *create_thread_event_breakpoint (CORE_ADDR);
+extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
+ CORE_ADDR);
extern void remove_solib_event_breakpoints (void);
/* This function returns TRUE if ep is a catchpoint. */
extern int ep_is_catchpoint (struct breakpoint *);
-/* This function returns TRUE if ep is a catchpoint of a
- shared library (aka dynamically-linked library) event,
- such as a library load or unload. */
-extern int ep_is_shlib_catchpoint (struct breakpoint *);
-
/* Enable breakpoints and delete when hit. Called with ARG == NULL
deletes all breakpoints. */
extern void delete_command (char *arg, int from_tty);
/* Manage a software single step breakpoint (or two). Insert may be called
twice before remove is called. */
-extern void insert_single_step_breakpoint (CORE_ADDR);
+extern void insert_single_step_breakpoint (struct gdbarch *, CORE_ADDR);
extern void remove_single_step_breakpoints (void);
/* Manage manual breakpoints, separate from the normal chain of
breakpoints. These functions are used in murky target-specific
ways. Please do not add more uses! */
-extern void *deprecated_insert_raw_breakpoint (CORE_ADDR);
-extern int deprecated_remove_raw_breakpoint (void *);
+extern void *deprecated_insert_raw_breakpoint (struct gdbarch *, CORE_ADDR);
+extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *);
/* Check if any hardware watchpoints have triggered, according to the
target. */
in our opinion won't ever trigger. */
extern void breakpoint_retire_moribund (void);
+/* Tell a breakpoint to be quiet. */
+extern void make_breakpoint_silent (struct breakpoint *);
+
+/* Return a tracepoint with the given number if found. */
+extern struct breakpoint *get_tracepoint (int num);
+
+/* Find a tracepoint by parsing a number in the supplied string. */
+extern struct breakpoint *get_tracepoint_by_number (char **arg, int multi_p,
+ int optional_p);
+
+/* 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);
+
#endif /* !defined (BREAKPOINT_H) */
projects / deliverable / binutils-gdb.git / blobdiff