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
142 /* Disposition of breakpoint. Ie: what to do after hitting it. */
147 del_at_next_stop
, /* Delete at next stop, whether hit or not */
148 disable
, /* Disable it */
149 donttouch
/* Leave it alone */
152 enum target_hw_bp_type
154 hw_write
= 0, /* Common HW watchpoint */
155 hw_read
= 1, /* Read HW watchpoint */
156 hw_access
= 2, /* Access HW watchpoint */
157 hw_execute
= 3 /* Execute HW breakpoint */
160 /* Note that the ->silent field is not currently used by any commands
161 (though the code is in there if it was to be, and set_raw_breakpoint
162 does set it to 0). I implemented it because I thought it would be
163 useful for a hack I had to put in; I'm going to leave it in because
164 I can see how there might be times when it would indeed be useful */
166 /* This is for a breakpoint or a watchpoint. */
170 struct breakpoint
*next
;
171 /* Type of breakpoint. */
173 /* Zero means disabled; remember the info but don't break here. */
175 /* What to do with this breakpoint after we hit it. */
176 enum bpdisp disposition
;
177 /* Number assigned to distinguish breakpoints. */
180 /* Address to break at, or NULL if not a breakpoint. */
183 /* Line number of this address. Only matters if address is
188 /* Source file name of this address. Only matters if address is
193 /* Non-zero means a silent breakpoint (don't print frame info
195 unsigned char silent
;
196 /* Number of stops at this breakpoint that should
197 be continued automatically before really stopping. */
199 /* "Real" contents of byte where breakpoint has been inserted.
200 Valid only when breakpoints are in the program. Under the complete
201 control of the target insert_breakpoint and remove_breakpoint routines.
202 No other code should assume anything about the value(s) here. */
203 char shadow_contents
[BREAKPOINT_MAX
];
204 /* Nonzero if this breakpoint is now inserted. Only matters if address
207 /* Nonzero if this is not the first breakpoint in the list
208 for the given address. Only matters if address is non-NULL. */
210 /* Chain of command lines to execute when this breakpoint is hit. */
211 struct command_line
*commands
;
212 /* Stack depth (address of frame). If nonzero, break only if fp
215 /* Conditional. Break only if this expression's value is nonzero. */
216 struct expression
*cond
;
218 /* String we used to set the breakpoint (malloc'd). Only matters if
219 address is non-NULL. */
221 /* Language we used to set the breakpoint. */
222 enum language language
;
223 /* Input radix we used to set the breakpoint. */
225 /* String form of the breakpoint condition (malloc'd), or NULL if there
228 /* String form of exp (malloc'd), or NULL if none. */
231 /* The expression we are watching, or NULL if not a watchpoint. */
232 struct expression
*exp
;
233 /* The largest block within which it is valid, or NULL if it is
234 valid anywhere (e.g. consists just of global symbols). */
235 struct block
*exp_valid_block
;
236 /* Value of the watchpoint the last time we checked it. */
239 /* Holds the value chain for a hardware watchpoint expression. */
242 /* Holds the address of the related watchpoint_scope breakpoint
243 when using watchpoints on local variables (might the concept
244 of a related breakpoint be useful elsewhere, if not just call
245 it the watchpoint_scope breakpoint or something like that. FIXME). */
246 struct breakpoint
*related_breakpoint
;
248 /* Holds the frame address which identifies the frame this watchpoint
249 should be evaluated in, or NULL if the watchpoint should be evaluated
250 on the outermost frame. */
251 CORE_ADDR watchpoint_frame
;
253 /* Thread number for thread-specific breakpoint, or -1 if don't care */
256 /* Count of the number of times this breakpoint was taken, dumped
257 with the info, but not used for anything else. Useful for
258 seeing how many times you hit a break prior to the program
259 aborting, so you can back up to just before the abort. */
262 /* Filename of a dynamically-linked library (dll), used for
263 bp_catch_load and bp_catch_unload (malloc'd), or NULL if any
264 library is significant. */
267 /* Filename of a dll whose state change (e.g., load or unload)
268 triggered this catchpoint. This field is only vaid immediately
269 after this catchpoint has triggered. */
270 char *triggered_dll_pathname
;
272 /* Process id of a child process whose forking triggered this
273 catchpoint. This field is only vaid immediately after this
274 catchpoint has triggered. */
275 int forked_inferior_pid
;
277 /* Filename of a program whose exec triggered this catchpoint.
278 This field is only vaid immediately after this catchpoint has
285 /* The following stuff is an abstract data type "bpstat" ("breakpoint
286 status"). This provides the ability to determine whether we have
287 stopped at a breakpoint, and what we should do about it. */
289 typedef struct bpstats
*bpstat
;
292 /* Clear a bpstat so that it says we are not at any breakpoint.
293 Also free any storage that is part of a bpstat. */
294 extern void bpstat_clear
PARAMS ((bpstat
*));
296 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
297 is part of the bpstat is copied as well. */
298 extern bpstat bpstat_copy
PARAMS ((bpstat
));
300 extern bpstat bpstat_stop_status
PARAMS ((CORE_ADDR
*, int));
302 /* This bpstat_what stuff tells wait_for_inferior what to do with a
303 breakpoint (a challenging task). */
305 enum bpstat_what_main_action
307 /* Perform various other tests; that is, this bpstat does not
308 say to perform any action (e.g. failed watchpoint and nothing
310 BPSTAT_WHAT_KEEP_CHECKING
,
312 /* Rather than distinguish between noisy and silent stops here, it
313 might be cleaner to have bpstat_print make that decision (also
314 taking into account stop_print_frame and source_only). But the
315 implications are a bit scary (interaction with auto-displays, etc.),
316 so I won't try it. */
319 BPSTAT_WHAT_STOP_SILENT
,
321 /* Stop and print. */
322 BPSTAT_WHAT_STOP_NOISY
,
324 /* Remove breakpoints, single step once, then put them back in and
325 go back to what we were doing. It's possible that this should be
326 removed from the main_action and put into a separate field, to more
327 cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */
330 /* Set longjmp_resume breakpoint, remove all other breakpoints,
331 and continue. The "remove all other breakpoints" part is required
332 if we are also stepping over another breakpoint as well as doing
333 the longjmp handling. */
334 BPSTAT_WHAT_SET_LONGJMP_RESUME
,
336 /* Clear longjmp_resume breakpoint, then handle as
337 BPSTAT_WHAT_KEEP_CHECKING. */
338 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
,
340 /* Clear longjmp_resume breakpoint, then handle as BPSTAT_WHAT_SINGLE. */
341 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE
,
343 /* Clear step resume breakpoint, and keep checking. */
344 BPSTAT_WHAT_STEP_RESUME
,
346 /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep
348 BPSTAT_WHAT_THROUGH_SIGTRAMP
,
350 /* Check the dynamic linker's data structures for new libraries, then
352 BPSTAT_WHAT_CHECK_SHLIBS
,
354 /* Check the dynamic linker's data structures for new libraries, then
355 resume out of the dynamic linker's callback, stop and print. */
356 BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK
,
358 /* This is just used to keep track of how many enums there are. */
364 enum bpstat_what_main_action main_action
;
366 /* Did we hit a call dummy breakpoint? This only goes with a main_action
367 of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
368 continuing from a call dummy without popping the frame is not a
373 /* Tell what to do about this bpstat. */
374 struct bpstat_what bpstat_what
PARAMS ((bpstat
));
376 /* Find the bpstat associated with a breakpoint. NULL otherwise. */
377 bpstat bpstat_find_breakpoint
PARAMS ((bpstat
, struct breakpoint
*));
379 /* Find a step_resume breakpoint associated with this bpstat.
380 (If there are multiple step_resume bp's on the list, this function
381 will arbitrarily pick one.)
383 It is an error to use this function if BPSTAT doesn't contain a
384 step_resume breakpoint.
386 See wait_for_inferior's use of this function.
388 extern struct breakpoint
*
389 bpstat_find_step_resume_breakpoint
PARAMS ((bpstat
));
391 /* Nonzero if a signal that we got in wait() was due to circumstances
392 explained by the BS. */
393 /* Currently that is true if we have hit a breakpoint, or if there is
394 a watchpoint enabled. */
395 #define bpstat_explains_signal(bs) ((bs) != NULL)
397 /* Nonzero if we should step constantly (e.g. watchpoints on machines
398 without hardware support). This isn't related to a specific bpstat,
399 just to things like whether watchpoints are set. */
400 extern int bpstat_should_step
PARAMS ((void));
402 /* Nonzero if there are enabled hardware watchpoints. */
403 extern int bpstat_have_active_hw_watchpoints
PARAMS ((void));
405 /* Print a message indicating what happened. Returns nonzero to
406 say that only the source line should be printed after this (zero
407 return means print the frame as well as the source line). */
408 extern int bpstat_print
PARAMS ((bpstat
));
410 /* Return the breakpoint number of the first breakpoint we are stopped
411 at. *BSP upon return is a bpstat which points to the remaining
412 breakpoints stopped at (but which is not guaranteed to be good for
413 anything but further calls to bpstat_num).
414 Return 0 if passed a bpstat which does not indicate any breakpoints. */
415 extern int bpstat_num
PARAMS ((bpstat
*));
417 /* Perform actions associated with having stopped at *BSP. Actually, we just
418 use this for breakpoint commands. Perhaps other actions will go here
419 later, but this is executed at a late time (from the command loop). */
420 extern void bpstat_do_actions
PARAMS ((bpstat
*));
422 /* Modify BS so that the actions will not be performed. */
423 extern void bpstat_clear_actions
PARAMS ((bpstat
));
425 /* Given a bpstat that records zero or more triggered eventpoints, this
426 function returns another bpstat which contains only the catchpoints
427 on that first list, if any.
429 extern void bpstat_get_triggered_catchpoints
PARAMS ((bpstat
, bpstat
*));
431 /* Implementation: */
434 /* Linked list because there can be two breakpoints at the same
435 place, and a bpstat reflects the fact that both have been hit. */
437 /* Breakpoint that we are at. */
438 struct breakpoint
*breakpoint_at
;
439 /* Commands left to be done. */
440 struct command_line
*commands
;
441 /* Old value associated with a watchpoint. */
444 /* Nonzero if this breakpoint tells us to print the frame. */
447 /* Nonzero if this breakpoint tells us to stop. */
450 /* Function called by bpstat_print to print stuff associated with
451 this element of the bpstat chain. Returns 0 or 1 just like
452 bpstat_print, or -1 if it can't deal with it. */
453 int (*print_it
) PARAMS ((bpstat bs
));
464 /* Prototypes for breakpoint-related functions. */
466 /* Forward declarations for prototypes */
469 extern int breakpoint_here_p
PARAMS ((CORE_ADDR
));
471 extern int breakpoint_inserted_here_p
PARAMS ((CORE_ADDR
));
473 extern int frame_in_dummy
PARAMS ((struct frame_info
*));
475 extern int breakpoint_thread_match
PARAMS ((CORE_ADDR
, int));
477 extern void until_break_command
PARAMS ((char *, int));
479 extern void breakpoint_re_set
PARAMS ((void));
481 extern void breakpoint_re_set_thread
PARAMS ((struct breakpoint
*));
483 extern int ep_is_exception_catchpoint
PARAMS ((struct breakpoint
*));
485 extern struct breakpoint
*set_momentary_breakpoint
486 PARAMS ((struct symtab_and_line
, struct frame_info
*, enum bptype
));
488 extern void set_ignore_count
PARAMS ((int, int, int));
490 extern void set_default_breakpoint
PARAMS ((int, CORE_ADDR
,
491 struct symtab
*, int));
493 extern void mark_breakpoints_out
PARAMS ((void));
495 extern void breakpoint_init_inferior
PARAMS ((enum inf_context
));
497 extern void delete_breakpoint
PARAMS ((struct breakpoint
*));
499 extern void breakpoint_auto_delete
PARAMS ((bpstat
));
501 extern void breakpoint_clear_ignore_counts
PARAMS ((void));
503 extern void break_command
PARAMS ((char *, int));
505 extern void tbreak_command
PARAMS ((char *, int));
507 extern int insert_breakpoints
PARAMS ((void));
509 extern int remove_breakpoints
PARAMS ((void));
511 /* This function can be used to physically insert eventpoints from the
512 specified traced inferior process, without modifying the breakpoint
513 package's state. This can be useful for those targets which support
514 following the processes of a fork() or vfork() system call, when both
515 of the resulting two processes are to be followed. */
516 extern int reattach_breakpoints
PARAMS ((int));
518 /* This function can be used to update the breakpoint package's state
519 after an exec() system call has been executed.
521 This function causes the following:
523 - All eventpoints are marked "not inserted".
524 - All eventpoints with a symbolic address are reset such that
525 the symbolic address must be reevaluated before the eventpoints
527 - The solib breakpoints are explicitly removed from the breakpoint
529 - A step-resume breakpoint, if any, is explicitly removed from the
531 - All eventpoints without a symbolic address are removed from the
533 extern void update_breakpoints_after_exec
PARAMS ((void));
535 /* This function can be used to physically remove hardware breakpoints
536 and watchpoints from the specified traced inferior process, without
537 modifying the breakpoint package's state. This can be useful for
538 those targets which support following the processes of a fork() or
539 vfork() system call, when one of the resulting two processes is to
540 be detached and allowed to run free.
542 It is an error to use this function on the process whose id is
544 extern int detach_breakpoints
PARAMS ((int));
546 extern void enable_longjmp_breakpoint
PARAMS ((void));
548 extern void disable_longjmp_breakpoint
PARAMS ((void));
550 extern void set_longjmp_resume_breakpoint
PARAMS ((CORE_ADDR
,
551 struct frame_info
*));
552 /* These functions respectively disable or reenable all currently
553 enabled watchpoints. When disabled, the watchpoints are marked
554 call_disabled. When reenabled, they are marked enabled.
556 The intended client of these functions is infcmd.c\run_stack_dummy.
558 The inferior must be stopped, and all breakpoints removed, when
559 these functions are used.
561 The need for these functions is that on some targets (e.g., HP-UX),
562 gdb is unable to unwind through the dummy frame that is pushed as
563 part of the implementation of a call command. Watchpoints can
564 cause the inferior to stop in places where this frame is visible,
565 and that can cause execution control to become very confused.
567 Note that if a user sets breakpoints in an interactively call
568 function, the call_disabled watchpoints will have been reenabled
569 when the first such breakpoint is reached. However, on targets
570 that are unable to unwind through the call dummy frame, watches
571 of stack-based storage may then be deleted, because gdb will
572 believe that their watched storage is out of scope. (Sigh.) */
574 disable_watchpoints_before_interactive_call_start
PARAMS ((void));
577 enable_watchpoints_after_interactive_call_stop
PARAMS ((void));
580 extern void clear_breakpoint_hit_counts
PARAMS ((void));
582 /* The following are for displays, which aren't really breakpoints, but
583 here is as good a place as any for them. */
585 extern void disable_current_display
PARAMS ((void));
587 extern void do_displays
PARAMS ((void));
589 extern void disable_display
PARAMS ((int));
591 extern void clear_displays
PARAMS ((void));
593 extern void disable_breakpoint
PARAMS ((struct breakpoint
*));
595 extern void enable_breakpoint
PARAMS ((struct breakpoint
*));
597 extern void create_solib_event_breakpoint
PARAMS ((CORE_ADDR
));
599 extern void remove_solib_event_breakpoints
PARAMS ((void));
601 extern void disable_breakpoints_in_shlibs
PARAMS ((int silent
));
603 extern void re_enable_breakpoints_in_shlibs
PARAMS ((void));
605 extern void create_solib_load_event_breakpoint
PARAMS ((char *, int,
608 extern void create_solib_unload_event_breakpoint
PARAMS ((char *, int,
611 extern void create_fork_event_catchpoint
PARAMS ((int, char *));
613 extern void create_vfork_event_catchpoint
PARAMS ((int, char *));
615 extern void create_exec_event_catchpoint
PARAMS ((int, char *));
617 /* This function returns TRUE if ep is a catchpoint. */
618 extern int ep_is_catchpoint
PARAMS ((struct breakpoint
*));
620 /* This function returns TRUE if ep is a catchpoint of a
621 shared library (aka dynamically-linked library) event,
622 such as a library load or unload. */
623 extern int ep_is_shlib_catchpoint
PARAMS ((struct breakpoint
*));
625 extern struct breakpoint
*set_breakpoint_sal
PARAMS ((struct symtab_and_line
));
627 #endif /* !defined (BREAKPOINT_H) */