| /* 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. |
| |
| This file is part of GDB. |
| |
| 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 3 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 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, see <http://www.gnu.org/licenses/>. */ |
| |
| #if !defined (BREAKPOINT_H) |
| #define BREAKPOINT_H 1 |
| |
| #include "frame.h" |
| #include "value.h" |
| #include "vec.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 |
| arrays that should be independent of the target architecture. */ |
| |
| #define BREAKPOINT_MAX 16 |
| |
| /* Type of breakpoint. */ |
| /* FIXME In the future, we should fold all other breakpoint-like things into |
| here. This includes: |
| |
| * single-step (for machines where we have to simulate single stepping) |
| (probably, though perhaps it is better for it to look as much as |
| 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 */ |
| bp_finish, /* used by finish command */ |
| bp_watchpoint, /* Watchpoint */ |
| bp_hardware_watchpoint, /* Hardware assisted watchpoint */ |
| bp_read_watchpoint, /* read watchpoint, (hardware assisted) */ |
| bp_access_watchpoint, /* access watchpoint, (hardware assisted) */ |
| bp_longjmp, /* secret breakpoint to find longjmp() */ |
| bp_longjmp_resume, /* secret breakpoint to escape longjmp() */ |
| |
| /* Used by wait_for_inferior for stepping over subroutine calls, for |
| stepping over signal handlers, and for skipping prologues. */ |
| bp_step_resume, |
| |
| /* Used to detect when a watchpoint expression has gone out of |
| scope. These breakpoints are usually not visible to the user. |
| |
| This breakpoint has some interesting properties: |
| |
| 1) There's always a 1:1 mapping between watchpoints |
| on local variables and watchpoint_scope breakpoints. |
| |
| 2) It automatically deletes itself and the watchpoint it's |
| associated with when hit. |
| |
| 3) It can never be disabled. */ |
| bp_watchpoint_scope, |
| |
| /* The breakpoint at the end of a call dummy. */ |
| /* FIXME: What if the function we are calling longjmp()s out of the |
| call, or the user gets out with the "return" command? We currently |
| have no way of cleaning up the breakpoint in these (obscure) situations. |
| (Probably can solve this by noticing longjmp, "return", etc., it's |
| similar to noticing when a watchpoint on a local variable goes out |
| of scope (with hardware support for watchpoints)). */ |
| bp_call_dummy, |
| |
| /* Some dynamic linkers (HP, maybe Solaris) can arrange for special |
| code in the inferior to run when significant events occur in the |
| dynamic linker (for example a library is loaded or unloaded). |
| |
| By placing a breakpoint in this magic code GDB will get control |
| 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, |
| |
| /* Some multi-threaded systems can arrange for a location in the |
| inferior to be executed when certain thread-related events occur |
| (such as thread creation or thread death). |
| |
| By placing a breakpoint at one of these locations, GDB will get |
| control when these events occur. GDB can then update its thread |
| lists etc. */ |
| |
| bp_thread_event, |
| |
| /* On the same principal, an overlay manager can arrange to call a |
| magic location in the inferior whenever there is an interesting |
| change in overlay status. GDB can update its overlay tables |
| and fiddle with breakpoints in overlays when this breakpoint |
| is hit. */ |
| |
| bp_overlay_event, |
| |
| bp_catchpoint, |
| }; |
| |
| /* States of enablement of breakpoint. */ |
| |
| enum enable_state |
| { |
| bp_disabled, /* The eventpoint is inactive, and cannot trigger. */ |
| bp_enabled, /* The eventpoint is active, and can trigger. */ |
| 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 |
| a call on some targets. The eventpoint will be |
| automatically enabled and reset when the call |
| "lands" (either completes, or stops at another |
| eventpoint). */ |
| 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 |
| its value. Step over it using the architecture's |
| SKIP_INSN macro. */ |
| }; |
| |
| |
| /* Disposition of breakpoint. Ie: what to do after hitting it. */ |
| |
| enum bpdisp |
| { |
| disp_del, /* Delete it */ |
| disp_del_at_next_stop, /* Delete at next stop, whether hit or not */ |
| disp_disable, /* Disable it */ |
| disp_donttouch /* Leave it alone */ |
| }; |
| |
| enum target_hw_bp_type |
| { |
| hw_write = 0, /* Common HW watchpoint */ |
| hw_read = 1, /* Read HW watchpoint */ |
| hw_access = 2, /* Access HW watchpoint */ |
| 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 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; |
| |
| /* 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 |
| 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 |
| 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 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; |
| |
| /* 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; |
| |
| /* 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; |
| |
| /* 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 hardware watchpoints, the size of data ad ADDRESS being watches. */ |
| int length; |
| |
| /* Type of hardware watchpoint. */ |
| enum target_hw_bp_type watchpoint_type; |
| |
| /* For any breakpoint type with an address, this is the section |
| associated with the address. Used primarily for overlay debugging. */ |
| struct obj_section *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; |
| |
| char *function_name; |
| |
| /* 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; |
| |
| /* In a non-stop mode, it's possible that we delete a breakpoint, |
| but as we do that, some still running thread hits that breakpoint. |
| For that reason, we need to keep locations belonging to deleted |
| breakpoints for a bit, so that don't report unexpected SIGTRAP. |
| We can't keep such locations forever, so we use a heuristic -- |
| after we process certain number of inferior events since |
| breakpoint was deleted, we retire all locations of that breakpoint. |
| This variable keeps a number of events still to go, when |
| it becomes 0 this location is retired. */ |
| int events_till_retirement; |
| }; |
| |
| /* 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 |
| { |
| /* 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 *); |
| |
| /* Display information about this breakpoint after setting it (roughly |
| speaking; this is called from "mention"). */ |
| 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 |
| }; |
| |
| typedef struct bp_location *bp_location_p; |
| DEF_VEC_P(bp_location_p); |
| |
| /* 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 |
| useful for a hack I had to put in; I'm going to leave it in because |
| I can see how there might be times when it would indeed be useful */ |
| |
| /* This is for a breakpoint or a watchpoint. */ |
| |
| struct breakpoint |
| { |
| struct breakpoint *next; |
| /* Type of breakpoint. */ |
| enum bptype type; |
| /* Zero means disabled; remember the info but don't break here. */ |
| enum enable_state enable_state; |
| /* What to do with this breakpoint after we hit it. */ |
| enum bpdisp disposition; |
| /* Number assigned to distinguish breakpoints. */ |
| int number; |
| |
| /* Location(s) associated with this high-level breakpoint. */ |
| struct bp_location *loc; |
| |
| /* Line number of this address. */ |
| |
| int line_number; |
| |
| /* Source file name of this address. */ |
| |
| char *source_file; |
| |
| /* Non-zero means a silent breakpoint (don't print frame info |
| if we stop here). */ |
| unsigned char silent; |
| /* Number of stops at this breakpoint that should |
| be continued automatically before really stopping. */ |
| int ignore_count; |
| /* 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. */ |
| struct frame_id frame_id; |
| |
| /* String we used to set the breakpoint (malloc'd). */ |
| char *addr_string; |
| /* Language we used to set the breakpoint. */ |
| enum language language; |
| /* Input radix we used to set the breakpoint. */ |
| int input_radix; |
| /* String form of the breakpoint condition (malloc'd), or NULL if there |
| is no condition. */ |
| char *cond_string; |
| /* String form of exp (malloc'd), or NULL if none. */ |
| char *exp_string; |
| |
| /* The expression we are watching, or NULL if not a watchpoint. */ |
| struct expression *exp; |
| /* The largest block within which it is valid, or NULL if it is |
| valid anywhere (e.g. consists just of global symbols). */ |
| struct block *exp_valid_block; |
| /* Value of the watchpoint the last time we checked it, or NULL |
| when we do not know the value yet or the value was not |
| readable. VAL is never lazy. */ |
| struct value *val; |
| /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL, |
| then an error occurred reading the value. */ |
| int val_valid; |
| |
| /* Holds the address of the related watchpoint_scope breakpoint |
| when using watchpoints on local variables (might the concept |
| of a related breakpoint be useful elsewhere, if not just call |
| it the watchpoint_scope breakpoint or something like that. FIXME). */ |
| struct breakpoint *related_breakpoint; |
| |
| /* Holds the frame address which identifies the frame this |
| watchpoint should be evaluated in, or `null' if the watchpoint |
| 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; |
| |
| /* 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; |
| |
| /* Process id of a child process whose forking triggered this |
| catchpoint. This field is only valid immediately after this |
| catchpoint has triggered. */ |
| ptid_t forked_inferior_pid; |
| |
| /* Filename of a program whose exec triggered this catchpoint. |
| This field is only valid immediately after this catchpoint has |
| triggered. */ |
| char *exec_pathname; |
| |
| /* Methods associated with this breakpoint. */ |
| struct breakpoint_ops *ops; |
| |
| /* 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); |
| |
| /* The following stuff is an abstract data type "bpstat" ("breakpoint |
| status"). This provides the ability to determine whether we have |
| stopped at a breakpoint, and what we should do about it. */ |
| |
| typedef struct bpstats *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); |
| |
| /* This bpstat_what stuff tells wait_for_inferior what to do with a |
| breakpoint (a challenging task). */ |
| |
| enum bpstat_what_main_action |
| { |
| /* Perform various other tests; that is, this bpstat does not |
| say to perform any action (e.g. failed watchpoint and nothing |
| else). */ |
| BPSTAT_WHAT_KEEP_CHECKING, |
| |
| /* Rather than distinguish between noisy and silent stops here, it |
| might be cleaner to have bpstat_print make that decision (also |
| taking into account stop_print_frame and source_only). But the |
| implications are a bit scary (interaction with auto-displays, etc.), |
| so I won't try it. */ |
| |
| /* Stop silently. */ |
| BPSTAT_WHAT_STOP_SILENT, |
| |
| /* Stop and print. */ |
| BPSTAT_WHAT_STOP_NOISY, |
| |
| /* Remove breakpoints, single step once, then put them back in and |
| go back to what we were doing. It's possible that this should be |
| removed from the main_action and put into a separate field, to more |
| cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */ |
| BPSTAT_WHAT_SINGLE, |
| |
| /* Set longjmp_resume breakpoint, remove all other breakpoints, |
| and continue. The "remove all other breakpoints" part is required |
| if we are also stepping over another breakpoint as well as doing |
| the longjmp handling. */ |
| BPSTAT_WHAT_SET_LONGJMP_RESUME, |
| |
| /* Clear longjmp_resume breakpoint, then handle as |
| BPSTAT_WHAT_KEEP_CHECKING. */ |
| BPSTAT_WHAT_CLEAR_LONGJMP_RESUME, |
| |
| /* Clear step resume breakpoint, and keep checking. */ |
| BPSTAT_WHAT_STEP_RESUME, |
| |
| /* Check the dynamic linker's data structures for new libraries, then |
| keep checking. */ |
| BPSTAT_WHAT_CHECK_SHLIBS, |
| |
| /* This is just used to keep track of how many enums there are. */ |
| BPSTAT_WHAT_LAST |
| }; |
| |
| struct bpstat_what |
| { |
| enum bpstat_what_main_action main_action; |
| |
| /* Did we hit a call dummy breakpoint? This only goes with a main_action |
| of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of |
| continuing from a call dummy without popping the frame is not a |
| useful one). */ |
| int call_dummy; |
| }; |
| |
| /* The possible return values for print_bpstat, print_it_normal, |
| print_it_done, print_it_noop. */ |
| enum print_stop_action |
| { |
| PRINT_UNKNOWN = -1, |
| PRINT_SRC_AND_LOC, |
| PRINT_SRC_ONLY, |
| PRINT_NOTHING |
| }; |
| |
| /* Tell what to do about this bpstat. */ |
| struct bpstat_what bpstat_what (bpstat); |
| |
| /* Find the bpstat associated with a breakpoint. NULL otherwise. */ |
| bpstat bpstat_find_breakpoint (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 (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 |
| a watchpoint enabled. */ |
| #define bpstat_explains_signal(bs) ((bs) != NULL) |
| |
| /* Nonzero 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); |
| |
| /* 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). */ |
| extern enum print_stop_action bpstat_print (bpstat); |
| |
| /* Put in *NUM the breakpoint number of the first breakpoint we are stopped |
| at. *BSP upon return is a bpstat which points to the remaining |
| breakpoints stopped at (but which is not guaranteed to be good for |
| anything but further calls to bpstat_num). |
| Return 0 if passed a bpstat which does not indicate any breakpoints. |
| Return -1 if stopped at a breakpoint that has been deleted since |
| we set it. |
| Return 1 otherwise. */ |
| extern int bpstat_num (bpstat *, int *); |
| |
| /* Perform actions associated with the stopped inferior. Actually, we |
| just use this for breakpoint commands. Perhaps other actions will |
| go here later, but this is executed at a late time (from the |
| command loop). */ |
| extern void bpstat_do_actions (void); |
| |
| /* Modify BS so that the actions will not be performed. */ |
| extern void bpstat_clear_actions (bpstat); |
| |
| /* Implementation: */ |
| |
| /* Values used to tell the printing routine how to behave for this bpstat. */ |
| enum bp_print_how |
| { |
| /* This is used when we want to do a normal printing of the reason |
| for stopping. The output will depend on the type of eventpoint |
| we are dealing with. This is the default value, most commonly |
| used. */ |
| print_it_normal, |
| /* This is used when nothing should be printed for this bpstat entry. */ |
| print_it_noop, |
| /* This is used when everything which needs to be printed has |
| already been printed. But we still want to print the frame. */ |
| print_it_done |
| }; |
| |
| struct bpstats |
| { |
| /* Linked list because there can be two breakpoints at the same |
| place, and a bpstat reflects the fact that both have been hit. */ |
| bpstat next; |
| /* Breakpoint that we are at. */ |
| const struct bp_location *breakpoint_at; |
| /* Commands left to be done. */ |
| struct command_line *commands; |
| /* Old value associated with a watchpoint. */ |
| struct value *old_val; |
| |
| /* Nonzero if this breakpoint tells us to print the frame. */ |
| char print; |
| |
| /* Nonzero if this breakpoint tells us to stop. */ |
| char stop; |
| |
| /* Tell bpstat_print and print_bp_stop_message how to print stuff |
| associated with this element of the bpstat chain. */ |
| enum bp_print_how print_it; |
| }; |
| |
| enum inf_context |
| { |
| inf_starting, |
| inf_running, |
| inf_exited, |
| inf_execd |
| }; |
| |
| /* The possible return values for breakpoint_here_p. |
| We guarantee that zero always means "no breakpoint here". */ |
| enum breakpoint_here |
| { |
| no_breakpoint_here = 0, |
| ordinary_breakpoint_here, |
| permanent_breakpoint_here |
| }; |
| |
| |
| /* Prototypes for breakpoint-related functions. */ |
| |
| 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 int software_breakpoint_inserted_here_p (CORE_ADDR); |
| |
| extern int breakpoint_thread_match (CORE_ADDR, ptid_t); |
| |
| extern void until_break_command (char *, int, int); |
| |
| extern void breakpoint_re_set (void); |
| |
| extern void breakpoint_re_set_thread (struct breakpoint *); |
| |
| extern struct breakpoint *set_momentary_breakpoint |
| (struct symtab_and_line, struct frame_id, enum bptype); |
| |
| extern struct breakpoint *set_momentary_breakpoint_at_pc |
| (CORE_ADDR pc, enum bptype type); |
| |
| extern void set_ignore_count (int, int, int); |
| |
| extern void set_default_breakpoint (int, CORE_ADDR, struct symtab *, int); |
| |
| extern void breakpoint_init_inferior (enum inf_context); |
| |
| extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *); |
| |
| extern void delete_breakpoint (struct breakpoint *); |
| |
| extern void breakpoint_auto_delete (bpstat); |
| |
| extern void break_command (char *, int); |
| |
| extern void hbreak_command_wrapper (char *, int); |
| extern void thbreak_command_wrapper (char *, int); |
| extern void rbreak_command_wrapper (char *, int); |
| extern void watch_command_wrapper (char *, int); |
| extern void awatch_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, |
| int hardwareflag, int tempflag, |
| int thread, int ignore_count, |
| int pending); |
| |
| extern void insert_breakpoints (void); |
| |
| extern int remove_breakpoints (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 (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 (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_ptid. */ |
| extern int detach_breakpoints (int); |
| |
| extern void set_longjmp_breakpoint (void); |
| extern void delete_longjmp_breakpoint (int thread); |
| |
| extern void enable_overlay_breakpoints (void); |
| extern void disable_overlay_breakpoints (void); |
| |
| /* 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 call_function_by_hand. |
| |
| 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 called |
| 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 (void); |
| |
| extern void enable_watchpoints_after_interactive_call_stop (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 |
| (char *arg, struct command_line *cmd); |
| |
| extern void clear_breakpoint_hit_counts (void); |
| |
| extern int get_number (char **); |
| |
| extern int get_number_or_range (char **); |
| |
| /* The following are for displays, which aren't really breakpoints, but |
| here is as good a place as any for them. */ |
| |
| extern void disable_current_display (void); |
| |
| extern void do_displays (void); |
| |
| extern void disable_display (int); |
| |
| extern void clear_displays (void); |
| |
| extern void disable_breakpoint (struct breakpoint *); |
| |
| extern void enable_breakpoint (struct breakpoint *); |
| |
| /* 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_thread_event_breakpoint (CORE_ADDR); |
| |
| extern void remove_solib_event_breakpoints (void); |
| |
| extern void remove_thread_event_breakpoints (void); |
| |
| extern void disable_breakpoints_in_shlibs (void); |
| |
| /* This function returns TRUE if ep is a catchpoint. */ |
| extern int ep_is_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); |
| |
| /* Pull all H/W watchpoints from the target. Return non-zero if the |
| 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 *); |
| |
| /* Check if any hardware watchpoints have triggered, according to the |
| target. */ |
| int watchpoints_triggered (struct target_waitstatus *); |
| |
| /* Update BUF, which is LEN bytes read from the target address MEMADDR, |
| by replacing any memory breakpoints with their shadowed contents. */ |
| void breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr, |
| LONGEST len); |
| |
| extern int breakpoints_always_inserted_mode (void); |
| |
| /* Called each time new event from target is processed. |
| Retires previously deleted breakpoint locations that |
| 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 *); |
| |
| #endif /* !defined (BREAKPOINT_H) */ |