X-Git-Url: http://git.ipfire.org/?a=blobdiff_plain;f=gdb%2Fbreakpoint.h;h=79f1c1fcaf021f30c9247fd59975a8fc9b30e933;hb=6aba47ca06d9150c6196a374b745c2711b46e045;hp=0b59a0dc7724f53c7654fedd2b651540a75db6cc;hpb=5a203e440538bfe04bb982e79a45d00a88a5fec4;p=thirdparty%2Fbinutils-gdb.git diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index 0b59a0dc772..79f1c1fcaf0 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -1,6 +1,6 @@ /* Data structures associated with breakpoints in GDB. - Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000 - Free Software Foundation, Inc. + Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, + 2002, 2003, 2004, 2007 Free Software Foundation, Inc. This file is part of GDB. @@ -16,8 +16,8 @@ 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., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #if !defined (BREAKPOINT_H) #define BREAKPOINT_H 1 @@ -28,6 +28,7 @@ #include "gdb-events.h" struct value; +struct block; /* This is the maximum number of bytes a breakpoint instruction can take. Feel free to increase it. It's just used in a few places to size @@ -183,6 +184,126 @@ enum target_hw_bp_type hw_execute = 3 /* Execute HW breakpoint */ }; + +/* Information used by targets to insert and remove breakpoints. */ + +struct bp_target_info +{ + /* 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 + 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; + + /* If the breakpoint lives in memory and reading that memory would + give back the breakpoint, instead of the original contents, then + the original contents are cached here. Only SHADOW_LEN bytes of + this buffer are valid, and only when the breakpoint is inserted. */ + gdb_byte shadow_contents[BREAKPOINT_MAX]; + + /* The length of the data cached in SHADOW_CONTENTS. */ + int shadow_len; + + /* The size of the placed breakpoint, according to + 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 + need the size to remove the breakpoint safely. */ + int placed_size; +}; + +/* GDB maintains two types of information about each breakpoint (or + watchpoint, or other related event). The first type corresponds + to struct breakpoint; this is a relatively high-level structure + which contains the source location(s), stopping conditions, user + commands to execute when the breakpoint is hit, and so forth. + + The second type of information corresponds to struct bp_location. + Each breakpoint has one or (eventually) more locations associated + with it, which represent target-specific and machine-specific + mechanisms for stopping the program. For instance, a watchpoint + expression may require multiple hardware watchpoints in order to + catch all changes in the value of the expression being watched. */ + +enum bp_loc_type +{ + bp_loc_software_breakpoint, + bp_loc_hardware_breakpoint, + bp_loc_hardware_watchpoint, + bp_loc_other /* Miscellaneous... */ +}; + +struct bp_location +{ + /* Chain pointer to the next breakpoint location. */ + struct bp_location *next; + + /* Type of this breakpoint location. */ + enum bp_loc_type loc_type; + + /* Each breakpoint location must belong to exactly one higher-level + breakpoint. This and the DUPLICATE flag are more straightforward + than reference counting. */ + struct breakpoint *owner; + + /* Nonzero if this breakpoint is now inserted. */ + char inserted; + + /* Nonzero if this is not the first breakpoint in the list + for the given address. */ + char duplicate; + + /* If we someday support real thread-specific breakpoints, then + the breakpoint location will need a thread identifier. */ + + /* Data for specific breakpoint types. These could be a union, but + simplicity is more important than memory usage for breakpoints. */ + + /* 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 + bp_loc_other. */ + CORE_ADDR address; + + /* For any breakpoint type with an address, this is the BFD section + associated with the address. Used primarily for overlay debugging. */ + asection *section; + + /* Address at which breakpoint was requested, either by the user or + by GDB for internal breakpoints. This will usually be the same + as ``address'' (above) except for cases in which + ADJUST_BREAKPOINT_ADDRESS has computed a different address at + which to place the breakpoint in order to comply with a + processor's architectual constraints. */ + CORE_ADDR requested_address; + + /* Details of the placed breakpoint, when inserted. */ + struct bp_target_info target_info; + + /* Similarly, for the breakpoint at an overlay's LMA, if necessary. */ + struct bp_target_info overlay_target_info; +}; + +/* This structure is a collection of function pointers that, if available, + will be called instead of the performing the default action for this + bptype. */ + +struct breakpoint_ops +{ + /* 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 *); + + /* Display information about this breakpoint after setting it (roughly + speaking; this is called from "mention"). */ + void (*print_mention) (struct breakpoint *); +}; + /* 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 @@ -203,11 +324,8 @@ struct breakpoint /* Number assigned to distinguish breakpoints. */ int number; - /* Address to break at. - Note that zero is a perfectly valid code address on some - platforms (for example, the mn10200 and mn10300 simulators). - NULL is not a special value for this field. */ - CORE_ADDR address; + /* Location(s) associated with this high-level breakpoint. */ + struct bp_location *loc; /* Line number of this address. */ @@ -223,21 +341,11 @@ struct breakpoint /* Number of stops at this breakpoint that should be continued automatically before really stopping. */ int ignore_count; - /* "Real" contents of byte where breakpoint has been inserted. - Valid only when breakpoints are in the program. Under the complete - control of the target insert_breakpoint and remove_breakpoint routines. - No other code should assume anything about the value(s) here. */ - char shadow_contents[BREAKPOINT_MAX]; - /* Nonzero if this breakpoint is now inserted. */ - char inserted; - /* Nonzero if this is not the first breakpoint in the list - for the given address. */ - char duplicate; /* Chain of command lines to execute when this breakpoint is hit. */ struct command_line *commands; /* Stack depth (address of frame). If nonzero, break only if fp equals this. */ - CORE_ADDR frame; + struct frame_id frame_id; /* Conditional. Break only if this expression's value is nonzero. */ struct expression *cond; @@ -304,7 +412,19 @@ struct breakpoint triggered. */ char *exec_pathname; - asection *section; + /* 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; }; /* The following stuff is an abstract data type "bpstat" ("breakpoint @@ -322,7 +442,8 @@ extern void bpstat_clear (bpstat *); is part of the bpstat is copied as well. */ extern bpstat bpstat_copy (bpstat); -extern bpstat bpstat_stop_status (CORE_ADDR *pc, int not_a_sw_breakpoint); +extern bpstat bpstat_stop_status (CORE_ADDR pc, ptid_t ptid, + int stopped_by_watchpoint); /* This bpstat_what stuff tells wait_for_inferior what to do with a breakpoint (a challenging task). */ @@ -521,22 +642,15 @@ enum breakpoint_here /* Prototypes for breakpoint-related functions. */ -/* Forward declarations for prototypes */ -struct frame_info; - extern enum breakpoint_here breakpoint_here_p (CORE_ADDR); extern int breakpoint_inserted_here_p (CORE_ADDR); -/* FIXME: cagney/2002-11-10: The current [generic] dummy-frame code - implements a functional superset of this function. The only reason - it hasn't been removed is because some architectures still don't - use the new framework. Once they have been fixed, this can go. */ -extern int deprecated_frame_in_dummy (struct frame_info *); +extern int software_breakpoint_inserted_here_p (CORE_ADDR); extern int breakpoint_thread_match (CORE_ADDR, ptid_t); -extern void until_break_command (char *, int); +extern void until_break_command (char *, int, int); extern void breakpoint_re_set (void); @@ -545,7 +659,7 @@ extern void breakpoint_re_set_thread (struct breakpoint *); extern int ep_is_exception_catchpoint (struct breakpoint *); extern struct breakpoint *set_momentary_breakpoint - (struct symtab_and_line, struct frame_info *, enum bptype); + (struct symtab_and_line, struct frame_id, enum bptype); extern void set_ignore_count (int, int, int); @@ -619,12 +733,12 @@ extern void disable_longjmp_breakpoint (void); extern void enable_overlay_breakpoints (void); extern void disable_overlay_breakpoints (void); -extern void set_longjmp_resume_breakpoint (CORE_ADDR, struct frame_info *); +extern void set_longjmp_resume_breakpoint (CORE_ADDR, struct frame_id); /* 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 intended client of these functions is call_function_by_hand. The inferior must be stopped, and all breakpoints removed, when these functions are used. @@ -710,4 +824,23 @@ extern void delete_command (char *arg, int from_tty); remove fails. */ extern int remove_hw_watchpoints (void); +/* 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 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 *); + +/* 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; + #endif /* !defined (BREAKPOINT_H) */