1 /* Data structures associated with breakpoints in GDB.
2 Copyright (C) 1992, 93, 94, 95, 96, 98, 1999 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 #if !defined (BREAKPOINT_H)
22 #define BREAKPOINT_H 1
27 #include "gdb-events.h"
29 /* This is the maximum number of bytes a breakpoint instruction can take.
30 Feel free to increase it. It's just used in a few places to size
31 arrays that should be independent of the target architecture. */
33 #define BREAKPOINT_MAX 16
35 /* Type of breakpoint. */
36 /* FIXME In the future, we should fold all other breakpoint-like things into
39 * single-step (for machines where we have to simulate single stepping)
40 (probably, though perhaps it is better for it to look as much as
41 possible like a single-step to wait_for_inferior). */
45 bp_none
= 0, /* Eventpoint has been deleted. */
46 bp_breakpoint
, /* Normal breakpoint */
47 bp_hardware_breakpoint
, /* Hardware assisted breakpoint */
48 bp_until
, /* used by until command */
49 bp_finish
, /* used by finish command */
50 bp_watchpoint
, /* Watchpoint */
51 bp_hardware_watchpoint
, /* Hardware assisted watchpoint */
52 bp_read_watchpoint
, /* read watchpoint, (hardware assisted) */
53 bp_access_watchpoint
, /* access watchpoint, (hardware assisted) */
54 bp_longjmp
, /* secret breakpoint to find longjmp() */
55 bp_longjmp_resume
, /* secret breakpoint to escape longjmp() */
57 /* Used by wait_for_inferior for stepping over subroutine calls, for
58 stepping over signal handlers, and for skipping prologues. */
61 /* Used by wait_for_inferior for stepping over signal handlers. */
64 /* Used to detect when a watchpoint expression has gone out of
65 scope. These breakpoints are usually not visible to the user.
67 This breakpoint has some interesting properties:
69 1) There's always a 1:1 mapping between watchpoints
70 on local variables and watchpoint_scope breakpoints.
72 2) It automatically deletes itself and the watchpoint it's
73 associated with when hit.
75 3) It can never be disabled. */
78 /* The breakpoint at the end of a call dummy. */
79 /* FIXME: What if the function we are calling longjmp()s out of the
80 call, or the user gets out with the "return" command? We currently
81 have no way of cleaning up the breakpoint in these (obscure) situations.
82 (Probably can solve this by noticing longjmp, "return", etc., it's
83 similar to noticing when a watchpoint on a local variable goes out
84 of scope (with hardware support for watchpoints)). */
87 /* Some dynamic linkers (HP, maybe Solaris) can arrange for special
88 code in the inferior to run when significant events occur in the
89 dynamic linker (for example a library is loaded or unloaded).
91 By placing a breakpoint in this magic code GDB will get control
92 when these significant events occur. GDB can then re-examine
93 the dynamic linker's data structures to discover any newly loaded
97 /* These breakpoints are used to implement the "catch load" command
98 on platforms whose dynamic linkers support such functionality. */
101 /* These breakpoints are used to implement the "catch unload" command
102 on platforms whose dynamic linkers support such functionality. */
105 /* These are not really breakpoints, but are catchpoints that
106 implement the "catch fork", "catch vfork" and "catch exec" commands
107 on platforms whose kernel support such functionality. (I.e.,
108 kernels which can raise an event when a fork or exec occurs, as
109 opposed to the debugger setting breakpoints on functions named
110 "fork" or "exec".) */
115 /* These are catchpoints to implement "catch catch" and "catch throw"
116 commands for C++ exception handling. */
123 /* States of enablement of breakpoint. */
127 disabled
, /* The eventpoint is inactive, and cannot trigger. */
128 enabled
, /* The eventpoint is active, and can trigger. */
129 shlib_disabled
, /* The eventpoint's address is in an unloaded solib.
130 The eventpoint will be automatically enabled
131 and reset when that solib is loaded. */
132 call_disabled
, /* The eventpoint has been disabled while a call
133 into the inferior is "in flight", because some
134 eventpoints interfere with the implementation of
135 a call on some targets. The eventpoint will be
136 automatically enabled and reset when the call
137 "lands" (either completes, or stops at another
139 permanent
/* There is a breakpoint instruction hard-wired into
140 the target's code. Don't try to write another
141 breakpoint instruction on top of it, or restore
142 its value. Step over it using the architecture's
147 /* Disposition of breakpoint. Ie: what to do after hitting it. */
152 del_at_next_stop
, /* Delete at next stop, whether hit or not */
153 disable
, /* Disable it */
154 donttouch
/* Leave it alone */
157 enum target_hw_bp_type
159 hw_write
= 0, /* Common HW watchpoint */
160 hw_read
= 1, /* Read HW watchpoint */
161 hw_access
= 2, /* Access HW watchpoint */
162 hw_execute
= 3 /* Execute HW breakpoint */
165 /* Note that the ->silent field is not currently used by any commands
166 (though the code is in there if it was to be, and set_raw_breakpoint
167 does set it to 0). I implemented it because I thought it would be
168 useful for a hack I had to put in; I'm going to leave it in because
169 I can see how there might be times when it would indeed be useful */
171 /* This is for a breakpoint or a watchpoint. */
175 struct breakpoint
*next
;
176 /* Type of breakpoint. */
178 /* Zero means disabled; remember the info but don't break here. */
180 /* What to do with this breakpoint after we hit it. */
181 enum bpdisp disposition
;
182 /* Number assigned to distinguish breakpoints. */
185 /* Address to break at, or NULL if not a breakpoint. */
188 /* Line number of this address. Only matters if address is
193 /* Source file name of this address. Only matters if address is
198 /* Non-zero means a silent breakpoint (don't print frame info
200 unsigned char silent
;
201 /* Number of stops at this breakpoint that should
202 be continued automatically before really stopping. */
204 /* "Real" contents of byte where breakpoint has been inserted.
205 Valid only when breakpoints are in the program. Under the complete
206 control of the target insert_breakpoint and remove_breakpoint routines.
207 No other code should assume anything about the value(s) here. */
208 char shadow_contents
[BREAKPOINT_MAX
];
209 /* Nonzero if this breakpoint is now inserted. Only matters if address
212 /* Nonzero if this is not the first breakpoint in the list
213 for the given address. Only matters if address is non-NULL. */
215 /* Chain of command lines to execute when this breakpoint is hit. */
216 struct command_line
*commands
;
217 /* Stack depth (address of frame). If nonzero, break only if fp
220 /* Conditional. Break only if this expression's value is nonzero. */
221 struct expression
*cond
;
223 /* String we used to set the breakpoint (malloc'd). Only matters if
224 address is non-NULL. */
226 /* Language we used to set the breakpoint. */
227 enum language language
;
228 /* Input radix we used to set the breakpoint. */
230 /* String form of the breakpoint condition (malloc'd), or NULL if there
233 /* String form of exp (malloc'd), or NULL if none. */
236 /* The expression we are watching, or NULL if not a watchpoint. */
237 struct expression
*exp
;
238 /* The largest block within which it is valid, or NULL if it is
239 valid anywhere (e.g. consists just of global symbols). */
240 struct block
*exp_valid_block
;
241 /* Value of the watchpoint the last time we checked it. */
244 /* Holds the value chain for a hardware watchpoint expression. */
247 /* Holds the address of the related watchpoint_scope breakpoint
248 when using watchpoints on local variables (might the concept
249 of a related breakpoint be useful elsewhere, if not just call
250 it the watchpoint_scope breakpoint or something like that. FIXME). */
251 struct breakpoint
*related_breakpoint
;
253 /* Holds the frame address which identifies the frame this watchpoint
254 should be evaluated in, or NULL if the watchpoint should be evaluated
255 on the outermost frame. */
256 CORE_ADDR watchpoint_frame
;
258 /* Thread number for thread-specific breakpoint, or -1 if don't care */
261 /* Count of the number of times this breakpoint was taken, dumped
262 with the info, but not used for anything else. Useful for
263 seeing how many times you hit a break prior to the program
264 aborting, so you can back up to just before the abort. */
267 /* Filename of a dynamically-linked library (dll), used for
268 bp_catch_load and bp_catch_unload (malloc'd), or NULL if any
269 library is significant. */
272 /* Filename of a dll whose state change (e.g., load or unload)
273 triggered this catchpoint. This field is only vaid immediately
274 after this catchpoint has triggered. */
275 char *triggered_dll_pathname
;
277 /* Process id of a child process whose forking triggered this
278 catchpoint. This field is only vaid immediately after this
279 catchpoint has triggered. */
280 int forked_inferior_pid
;
282 /* Filename of a program whose exec triggered this catchpoint.
283 This field is only vaid immediately after this catchpoint has
290 /* The following stuff is an abstract data type "bpstat" ("breakpoint
291 status"). This provides the ability to determine whether we have
292 stopped at a breakpoint, and what we should do about it. */
294 typedef struct bpstats
*bpstat
;
297 /* Clear a bpstat so that it says we are not at any breakpoint.
298 Also free any storage that is part of a bpstat. */
299 extern void bpstat_clear
PARAMS ((bpstat
*));
301 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
302 is part of the bpstat is copied as well. */
303 extern bpstat bpstat_copy
PARAMS ((bpstat
));
305 extern bpstat bpstat_stop_status
PARAMS ((CORE_ADDR
*, int));
307 /* This bpstat_what stuff tells wait_for_inferior what to do with a
308 breakpoint (a challenging task). */
310 enum bpstat_what_main_action
312 /* Perform various other tests; that is, this bpstat does not
313 say to perform any action (e.g. failed watchpoint and nothing
315 BPSTAT_WHAT_KEEP_CHECKING
,
317 /* Rather than distinguish between noisy and silent stops here, it
318 might be cleaner to have bpstat_print make that decision (also
319 taking into account stop_print_frame and source_only). But the
320 implications are a bit scary (interaction with auto-displays, etc.),
321 so I won't try it. */
324 BPSTAT_WHAT_STOP_SILENT
,
326 /* Stop and print. */
327 BPSTAT_WHAT_STOP_NOISY
,
329 /* Remove breakpoints, single step once, then put them back in and
330 go back to what we were doing. It's possible that this should be
331 removed from the main_action and put into a separate field, to more
332 cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */
335 /* Set longjmp_resume breakpoint, remove all other breakpoints,
336 and continue. The "remove all other breakpoints" part is required
337 if we are also stepping over another breakpoint as well as doing
338 the longjmp handling. */
339 BPSTAT_WHAT_SET_LONGJMP_RESUME
,
341 /* Clear longjmp_resume breakpoint, then handle as
342 BPSTAT_WHAT_KEEP_CHECKING. */
343 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
,
345 /* Clear longjmp_resume breakpoint, then handle as BPSTAT_WHAT_SINGLE. */
346 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
,
348 /* Clear step resume breakpoint, and keep checking. */
349 BPSTAT_WHAT_STEP_RESUME
,
351 /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep
353 BPSTAT_WHAT_THROUGH_SIGTRAMP
,
355 /* Check the dynamic linker's data structures for new libraries, then
357 BPSTAT_WHAT_CHECK_SHLIBS
,
359 /* Check the dynamic linker's data structures for new libraries, then
360 resume out of the dynamic linker's callback, stop and print. */
361 BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
,
363 /* This is just used to keep track of how many enums there are. */
369 enum bpstat_what_main_action main_action
;
371 /* Did we hit a call dummy breakpoint? This only goes with a main_action
372 of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
373 continuing from a call dummy without popping the frame is not a
378 /* The possible return values for print_bpstat, print_it_normal,
379 print_it_done, print_it_noop. */
380 enum print_stop_action
388 /* Tell what to do about this bpstat. */
389 struct bpstat_what bpstat_what
PARAMS ((bpstat
));
391 /* Find the bpstat associated with a breakpoint. NULL otherwise. */
392 bpstat bpstat_find_breakpoint
PARAMS ((bpstat
, struct breakpoint
*));
394 /* Find a step_resume breakpoint associated with this bpstat.
395 (If there are multiple step_resume bp's on the list, this function
396 will arbitrarily pick one.)
398 It is an error to use this function if BPSTAT doesn't contain a
399 step_resume breakpoint.
401 See wait_for_inferior's use of this function.
403 extern struct breakpoint
*
404 bpstat_find_step_resume_breakpoint
PARAMS ((bpstat
));
406 /* Nonzero if a signal that we got in wait() was due to circumstances
407 explained by the BS. */
408 /* Currently that is true if we have hit a breakpoint, or if there is
409 a watchpoint enabled. */
410 #define bpstat_explains_signal(bs) ((bs) != NULL)
412 /* Nonzero if we should step constantly (e.g. watchpoints on machines
413 without hardware support). This isn't related to a specific bpstat,
414 just to things like whether watchpoints are set. */
415 extern int bpstat_should_step
PARAMS ((void));
417 /* Nonzero if there are enabled hardware watchpoints. */
418 extern int bpstat_have_active_hw_watchpoints
PARAMS ((void));
420 /* Print a message indicating what happened. Returns nonzero to
421 say that only the source line should be printed after this (zero
422 return means print the frame as well as the source line). */
423 extern enum print_stop_action bpstat_print
PARAMS ((bpstat
));
425 /* Return the breakpoint number of the first breakpoint we are stopped
426 at. *BSP upon return is a bpstat which points to the remaining
427 breakpoints stopped at (but which is not guaranteed to be good for
428 anything but further calls to bpstat_num).
429 Return 0 if passed a bpstat which does not indicate any breakpoints. */
430 extern int bpstat_num
PARAMS ((bpstat
*));
432 /* Perform actions associated with having stopped at *BSP. Actually, we just
433 use this for breakpoint commands. Perhaps other actions will go here
434 later, but this is executed at a late time (from the command loop). */
435 extern void bpstat_do_actions
PARAMS ((bpstat
*));
437 /* Modify BS so that the actions will not be performed. */
438 extern void bpstat_clear_actions
PARAMS ((bpstat
));
440 /* Given a bpstat that records zero or more triggered eventpoints, this
441 function returns another bpstat which contains only the catchpoints
442 on that first list, if any.
444 extern void bpstat_get_triggered_catchpoints
PARAMS ((bpstat
, bpstat
*));
446 /* Implementation: */
448 /* Values used to tell the printing routine how to behave for this bpstat. */
451 /* This is used when we want to do a normal printing of the reason
452 for stopping. The output will depend on the type of eventpoint
453 we are dealing with. This is the default value, most commonly
456 /* This is used when nothing should be printed for this bpstat entry. */
458 /* This is used when everything which needs to be printed has
459 already been printed. But we still want to print the frame. */
465 /* Linked list because there can be two breakpoints at the same
466 place, and a bpstat reflects the fact that both have been hit. */
468 /* Breakpoint that we are at. */
469 struct breakpoint
*breakpoint_at
;
470 /* Commands left to be done. */
471 struct command_line
*commands
;
472 /* Old value associated with a watchpoint. */
475 /* Nonzero if this breakpoint tells us to print the frame. */
478 /* Nonzero if this breakpoint tells us to stop. */
481 /* Tell bpstat_print and print_bp_stop_message how to print stuff
482 associated with this element of the bpstat chain. */
483 enum bp_print_how print_it
;
493 /* The possible return values for breakpoint_here_p.
494 We guarantee that zero always means "no breakpoint here". */
497 no_breakpoint_here
= 0,
498 ordinary_breakpoint_here
,
499 permanent_breakpoint_here
503 /* Prototypes for breakpoint-related functions. */
505 /* Forward declarations for prototypes */
508 extern enum breakpoint_here breakpoint_here_p
PARAMS ((CORE_ADDR
));
510 extern int breakpoint_inserted_here_p
PARAMS ((CORE_ADDR
));
512 extern int frame_in_dummy
PARAMS ((struct frame_info
*));
514 extern int breakpoint_thread_match
PARAMS ((CORE_ADDR
, int));
516 extern void until_break_command
PARAMS ((char *, int));
518 extern void breakpoint_re_set
PARAMS ((void));
520 extern void breakpoint_re_set_thread
PARAMS ((struct breakpoint
*));
522 extern int ep_is_exception_catchpoint
PARAMS ((struct breakpoint
*));
524 extern struct breakpoint
*set_momentary_breakpoint
525 PARAMS ((struct symtab_and_line
, struct frame_info
*, enum bptype
));
527 extern void set_ignore_count
PARAMS ((int, int, int));
529 extern void set_default_breakpoint
PARAMS ((int, CORE_ADDR
,
530 struct symtab
*, int));
532 extern void mark_breakpoints_out
PARAMS ((void));
534 extern void breakpoint_init_inferior
PARAMS ((enum inf_context
));
536 extern void delete_breakpoint
PARAMS ((struct breakpoint
*));
538 extern void breakpoint_auto_delete
PARAMS ((bpstat
));
540 extern void breakpoint_clear_ignore_counts
PARAMS ((void));
542 extern void break_command
PARAMS ((char *, int));
544 extern void tbreak_command
PARAMS ((char *, int));
546 extern int insert_breakpoints
PARAMS ((void));
548 extern int remove_breakpoints
PARAMS ((void));
550 /* This function can be used to physically insert eventpoints from the
551 specified traced inferior process, without modifying the breakpoint
552 package's state. This can be useful for those targets which support
553 following the processes of a fork() or vfork() system call, when both
554 of the resulting two processes are to be followed. */
555 extern int reattach_breakpoints
PARAMS ((int));
557 /* This function can be used to update the breakpoint package's state
558 after an exec() system call has been executed.
560 This function causes the following:
562 - All eventpoints are marked "not inserted".
563 - All eventpoints with a symbolic address are reset such that
564 the symbolic address must be reevaluated before the eventpoints
566 - The solib breakpoints are explicitly removed from the breakpoint
568 - A step-resume breakpoint, if any, is explicitly removed from the
570 - All eventpoints without a symbolic address are removed from the
572 extern void update_breakpoints_after_exec
PARAMS ((void));
574 /* This function can be used to physically remove hardware breakpoints
575 and watchpoints from the specified traced inferior process, without
576 modifying the breakpoint package's state. This can be useful for
577 those targets which support following the processes of a fork() or
578 vfork() system call, when one of the resulting two processes is to
579 be detached and allowed to run free.
581 It is an error to use this function on the process whose id is
583 extern int detach_breakpoints
PARAMS ((int));
585 extern void enable_longjmp_breakpoint
PARAMS ((void));
587 extern void disable_longjmp_breakpoint
PARAMS ((void));
589 extern void set_longjmp_resume_breakpoint
PARAMS ((CORE_ADDR
,
590 struct frame_info
*));
591 /* These functions respectively disable or reenable all currently
592 enabled watchpoints. When disabled, the watchpoints are marked
593 call_disabled. When reenabled, they are marked enabled.
595 The intended client of these functions is infcmd.c\run_stack_dummy.
597 The inferior must be stopped, and all breakpoints removed, when
598 these functions are used.
600 The need for these functions is that on some targets (e.g., HP-UX),
601 gdb is unable to unwind through the dummy frame that is pushed as
602 part of the implementation of a call command. Watchpoints can
603 cause the inferior to stop in places where this frame is visible,
604 and that can cause execution control to become very confused.
606 Note that if a user sets breakpoints in an interactively call
607 function, the call_disabled watchpoints will have been reenabled
608 when the first such breakpoint is reached. However, on targets
609 that are unable to unwind through the call dummy frame, watches
610 of stack-based storage may then be deleted, because gdb will
611 believe that their watched storage is out of scope. (Sigh.) */
613 disable_watchpoints_before_interactive_call_start
PARAMS ((void));
616 enable_watchpoints_after_interactive_call_stop
PARAMS ((void));
619 extern void clear_breakpoint_hit_counts
PARAMS ((void));
621 extern int get_number
PARAMS ((char **));
623 extern int get_number_or_range
PARAMS ((char **));
625 /* The following are for displays, which aren't really breakpoints, but
626 here is as good a place as any for them. */
628 extern void disable_current_display
PARAMS ((void));
630 extern void do_displays
PARAMS ((void));
632 extern void disable_display
PARAMS ((int));
634 extern void clear_displays
PARAMS ((void));
636 extern void disable_breakpoint
PARAMS ((struct breakpoint
*));
638 extern void enable_breakpoint
PARAMS ((struct breakpoint
*));
640 extern void make_breakpoint_permanent
PARAMS ((struct breakpoint
*));
642 extern struct breakpoint
*create_solib_event_breakpoint
PARAMS ((CORE_ADDR
));
644 extern void remove_solib_event_breakpoints
PARAMS ((void));
646 extern void disable_breakpoints_in_shlibs
PARAMS ((int silent
));
648 extern void re_enable_breakpoints_in_shlibs
PARAMS ((void));
650 extern void create_solib_load_event_breakpoint
PARAMS ((char *, int,
653 extern void create_solib_unload_event_breakpoint
PARAMS ((char *, int,
656 extern void create_fork_event_catchpoint
PARAMS ((int, char *));
658 extern void create_vfork_event_catchpoint
PARAMS ((int, char *));
660 extern void create_exec_event_catchpoint
PARAMS ((int, char *));
662 /* This function returns TRUE if ep is a catchpoint. */
663 extern int ep_is_catchpoint
PARAMS ((struct breakpoint
*));
665 /* This function returns TRUE if ep is a catchpoint of a
666 shared library (aka dynamically-linked library) event,
667 such as a library load or unload. */
668 extern int ep_is_shlib_catchpoint
PARAMS ((struct breakpoint
*));
670 extern struct breakpoint
*set_breakpoint_sal
PARAMS ((struct symtab_and_line
));
672 /* Enable breakpoints and delete when hit. Called with ARG == NULL
673 deletes all breakpoints. */
674 extern void delete_command (char *arg
, int from_tty
);
676 #endif /* !defined (BREAKPOINT_H) */