From 65b07ddca8832033e0e102c3a2a0d9f9f5922a9d Mon Sep 17 00:00:00 2001 From: David Taylor Date: Thu, 31 Dec 1998 21:58:30 +0000 Subject: all remaining *.c *.h files from hp merge. --- gdb/breakpoint.h | 189 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 184 insertions(+), 5 deletions(-) (limited to 'gdb/breakpoint.h') diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index 0aa42f5..0b6fff5 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -1,5 +1,5 @@ /* Data structures associated with breakpoints in GDB. - Copyright (C) 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc. + Copyright (C) 1992, 93, 94, 95, 96, 1998 Free Software Foundation, Inc. This file is part of GDB. @@ -38,6 +38,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ possible like a single-step to wait_for_inferior). */ enum bptype { + bp_none = 0, /* Eventpoint has been deleted. */ bp_breakpoint, /* Normal breakpoint */ bp_hardware_breakpoint, /* Hardware assisted breakpoint */ bp_until, /* used by until command */ @@ -87,12 +88,50 @@ enum bptype { when these significant events occur. GDB can then re-examine the dynamic linker's data structures to discover any newly loaded dynamic libraries. */ - bp_shlib_event + bp_shlib_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, + + /* 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. */ -enum enable { disabled, enabled, shlib_disabled}; +enum enable { + disabled, /* The eventpoint is inactive, and cannot trigger. */ + enabled, /* The eventpoint is active, and can trigger. */ + shlib_disabled, /* The eventpoint's address is within an unloaded solib. + The eventpoint will be automatically enabled & reset + when that solib is loaded. */ + call_disabled /* The eventpoint has been disabled while a call into + the inferior is "in flight", because some eventpoints + interfere with the implementation of a call on some + targets. The eventpoint will be automatically enabled + & reset when the call "lands" (either completes, or + stops at another eventpoint). */ +}; + /* Disposition of breakpoint. Ie: what to do after hitting it. */ @@ -205,6 +244,24 @@ struct breakpoint 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 vaid 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 vaid immediately after this catchpoint has triggered. */ + int forked_inferior_pid; + + /* Filename of a program whose exec triggered this catchpoint. This + field is only vaid immediately after this catchpoint has triggered. */ + char * exec_pathname; + + asection *section; }; /* The following stuff is an abstract data type "bpstat" ("breakpoint status"). @@ -275,6 +332,10 @@ enum bpstat_what_main_action { 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, + /* This is just used to keep track of how many enums there are. */ BPSTAT_WHAT_LAST }; @@ -295,6 +356,18 @@ struct bpstat_what bpstat_what PARAMS ((bpstat)); /* Find the bpstat associated with a breakpoint. NULL otherwise. */ bpstat bpstat_find_breakpoint PARAMS ((bpstat, struct breakpoint *)); +/* Find a step_resume breakpoint associated with this bpstat. + (If there are multiple step_resume bp's on the list, this function + will arbitrarily pick one.) + + It is an error to use this function if BPSTAT doesn't contain a + step_resume breakpoint. + + See wait_for_inferior's use of this function. + */ +extern struct breakpoint * +bpstat_find_step_resume_breakpoint PARAMS ((bpstat)); + /* Nonzero if a signal that we got in wait() was due to circumstances explained by the BS. */ /* Currently that is true if we have hit a breakpoint, or if there is @@ -306,6 +379,9 @@ bpstat bpstat_find_breakpoint PARAMS ((bpstat, struct breakpoint *)); just to things like whether watchpoints are set. */ extern int bpstat_should_step PARAMS ((void)); +/* Nonzero if there are enabled hardware watchpoints. */ +extern int bpstat_have_active_hw_watchpoints PARAMS ((void)); + /* 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). */ @@ -326,6 +402,12 @@ extern void bpstat_do_actions PARAMS ((bpstat *)); /* Modify BS so that the actions will not be performed. */ extern void bpstat_clear_actions PARAMS ((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 PARAMS ((bpstat, bpstat *)); + /* Implementation: */ struct bpstats { @@ -350,6 +432,14 @@ struct bpstats bpstat_print, or -1 if it can't deal with it. */ int (*print_it) PARAMS((bpstat bs)); }; + +enum inf_context +{ + inf_starting, + inf_running, + inf_exited +}; + /* Prototypes for breakpoint-related functions. */ @@ -359,6 +449,8 @@ struct frame_info; extern int breakpoint_here_p PARAMS ((CORE_ADDR)); +extern int breakpoint_inserted_here_p PARAMS ((CORE_ADDR)); + extern int frame_in_dummy PARAMS ((struct frame_info *)); extern int breakpoint_thread_match PARAMS ((CORE_ADDR, int)); @@ -367,7 +459,8 @@ extern void until_break_command PARAMS ((char *, int)); extern void breakpoint_re_set PARAMS ((void)); -extern void clear_momentary_breakpoints PARAMS ((void)); +extern void breakpoint_re_set_thread PARAMS ((struct breakpoint *)); + extern struct breakpoint *set_momentary_breakpoint PARAMS ((struct symtab_and_line, struct frame_info *, enum bptype)); @@ -378,7 +471,7 @@ extern void set_default_breakpoint PARAMS ((int, CORE_ADDR, struct symtab *, int extern void mark_breakpoints_out PARAMS ((void)); -extern void breakpoint_init_inferior PARAMS ((void)); +extern void breakpoint_init_inferior PARAMS ((enum inf_context)); extern void delete_breakpoint PARAMS ((struct breakpoint *)); @@ -388,16 +481,80 @@ extern void breakpoint_clear_ignore_counts PARAMS ((void)); extern void break_command PARAMS ((char *, int)); +extern void tbreak_command PARAMS ((char *, int)); + extern int insert_breakpoints PARAMS ((void)); extern int remove_breakpoints PARAMS ((void)); +/* 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 PARAMS ((int)); + +/* This function can be used to update the breakpoint package's state + after an exec() system call has been executed. + + This function causes the following: + + - All eventpoints are marked "not inserted". + - All eventpoints with a symbolic address are reset such that + the symbolic address must be reevaluated before the eventpoints + can be reinserted. + - The solib breakpoints are explicitly removed from the breakpoint + list. + - A step-resume breakpoint, if any, is explicitly removed from the + breakpoint list. + - All eventpoints without a symbolic address are removed from the + breakpoint list. */ +extern void update_breakpoints_after_exec PARAMS ((void)); + +/* This function can be used to physically remove hardware breakpoints + and watchpoints 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 one of the resulting two processes is to + be detached and allowed to run free. + + It is an error to use this function on the process whose id is + inferior_pid. */ +extern int detach_breakpoints PARAMS ((int)); + extern void enable_longjmp_breakpoint PARAMS ((void)); extern void disable_longjmp_breakpoint PARAMS ((void)); extern void set_longjmp_resume_breakpoint PARAMS ((CORE_ADDR, struct frame_info *)); +/* These functions respectively disable or reenable all currently + enabled watchpoints. When disabled, the watchpoints are marked + call_disabled. When reenabled, they are marked enabled. + + The intended client of these functions is infcmd.c\run_stack_dummy. + + The inferior must be stopped, and all breakpoints removed, when + these functions are used. + + The need for these functions is that on some targets (e.g., HP-UX), + gdb is unable to unwind through the dummy frame that is pushed as + part of the implementation of a call command. Watchpoints can + cause the inferior to stop in places where this frame is visible, + and that can cause execution control to become very confused. + + Note that if a user sets breakpoints in an interactively call + function, the call_disabled watchpoints will have been reenabled + when the first such breakpoint is reached. However, on targets + that are unable to unwind through the call dummy frame, watches + of stack-based storage may then be deleted, because gdb will + believe that their watched storage is out of scope. (Sigh.) */ +extern void +disable_watchpoints_before_interactive_call_start PARAMS ((void)); + +extern void +enable_watchpoints_after_interactive_call_stop PARAMS ((void)); + extern void clear_breakpoint_hit_counts PARAMS ((void)); @@ -420,6 +577,28 @@ extern void create_solib_event_breakpoint PARAMS ((CORE_ADDR)); extern void remove_solib_event_breakpoints PARAMS ((void)); +extern void disable_breakpoints_in_shlibs PARAMS ((void)); + extern void re_enable_breakpoints_in_shlibs PARAMS ((void)); +extern void create_solib_load_event_breakpoint PARAMS ((char *, int, char *, char *)); + +extern void create_solib_unload_event_breakpoint PARAMS ((char *, int, char *, char *)); + +extern void create_fork_event_catchpoint PARAMS ((int, char *)); + +extern void create_vfork_event_catchpoint PARAMS ((int, char *)); + +extern void create_exec_event_catchpoint PARAMS ((int, char *)); + +/* This function returns TRUE if ep is a catchpoint. */ +extern int ep_is_catchpoint PARAMS ((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 PARAMS ((struct breakpoint *)); + +extern struct breakpoint *set_breakpoint_sal PARAMS ((struct symtab_and_line)); + #endif /* !defined (BREAKPOINT_H) */ -- cgit v1.1