gdb/breakpoint.h

   1 /* Data structures associated with breakpoints in GDB.
   2    Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #if !defined (BREAKPOINT_H)
  23 #define BREAKPOINT_H 1
  24
  25 #include "frame.h"
  26 #include "value.h"
  27
  28 #include "gdb-events.h"
  29
  30 struct value;
  31
  32 /* This is the maximum number of bytes a breakpoint instruction can take.
  33    Feel free to increase it.  It's just used in a few places to size
  34    arrays that should be independent of the target architecture.  */
  35
  36 #define BREAKPOINT_MAX  16
  37 \f
  38 /* Type of breakpoint. */
  39 /* FIXME In the future, we should fold all other breakpoint-like things into
  40    here.  This includes:
  41
  42    * single-step (for machines where we have to simulate single stepping)
  43    (probably, though perhaps it is better for it to look as much as
  44    possible like a single-step to wait_for_inferior).  */
  45
  46 enum bptype
  47   {
  48     bp_none = 0,                /* Eventpoint has been deleted. */
  49     bp_breakpoint,              /* Normal breakpoint */
  50     bp_hardware_breakpoint,     /* Hardware assisted breakpoint */
  51     bp_until,                   /* used by until command */
  52     bp_finish,                  /* used by finish command */
  53     bp_watchpoint,              /* Watchpoint */
  54     bp_hardware_watchpoint,     /* Hardware assisted watchpoint */
  55     bp_read_watchpoint,         /* read watchpoint, (hardware assisted) */
  56     bp_access_watchpoint,       /* access watchpoint, (hardware assisted) */
  57     bp_longjmp,                 /* secret breakpoint to find longjmp() */
  58     bp_longjmp_resume,          /* secret breakpoint to escape longjmp() */
  59
  60     /* Used by wait_for_inferior for stepping over subroutine calls, for
  61        stepping over signal handlers, and for skipping prologues.  */
  62     bp_step_resume,
  63
  64     /* Used by wait_for_inferior for stepping over signal handlers.  */
  65     bp_through_sigtramp,
  66
  67     /* Used to detect when a watchpoint expression has gone out of
  68        scope.  These breakpoints are usually not visible to the user.
  69
  70        This breakpoint has some interesting properties:
  71
  72        1) There's always a 1:1 mapping between watchpoints
  73        on local variables and watchpoint_scope breakpoints.
  74
  75        2) It automatically deletes itself and the watchpoint it's
  76        associated with when hit.
  77
  78        3) It can never be disabled.  */
  79     bp_watchpoint_scope,
  80
  81     /* The breakpoint at the end of a call dummy.  */
  82     /* FIXME: What if the function we are calling longjmp()s out of the
  83        call, or the user gets out with the "return" command?  We currently
  84        have no way of cleaning up the breakpoint in these (obscure) situations.
  85        (Probably can solve this by noticing longjmp, "return", etc., it's
  86        similar to noticing when a watchpoint on a local variable goes out
  87        of scope (with hardware support for watchpoints)).  */
  88     bp_call_dummy,
  89
  90     /* Some dynamic linkers (HP, maybe Solaris) can arrange for special
  91        code in the inferior to run when significant events occur in the
  92        dynamic linker (for example a library is loaded or unloaded).
  93
  94        By placing a breakpoint in this magic code GDB will get control
  95        when these significant events occur.  GDB can then re-examine
  96        the dynamic linker's data structures to discover any newly loaded
  97        dynamic libraries.  */
  98     bp_shlib_event,
  99
 100     /* Some multi-threaded systems can arrange for a location in the
 101        inferior to be executed when certain thread-related events occur
 102        (such as thread creation or thread death).
 103
 104        By placing a breakpoint at one of these locations, GDB will get
 105        control when these events occur.  GDB can then update its thread
 106        lists etc.  */
 107
 108     bp_thread_event,
 109
 110     /* These breakpoints are used to implement the "catch load" command
 111        on platforms whose dynamic linkers support such functionality.  */
 112     bp_catch_load,
 113
 114     /* These breakpoints are used to implement the "catch unload" command
 115        on platforms whose dynamic linkers support such functionality.  */
 116     bp_catch_unload,
 117
 118     /* These are not really breakpoints, but are catchpoints that
 119        implement the "catch fork", "catch vfork" and "catch exec" commands
 120        on platforms whose kernel support such functionality.  (I.e.,
 121        kernels which can raise an event when a fork or exec occurs, as
 122        opposed to the debugger setting breakpoints on functions named
 123        "fork" or "exec".) */
 124     bp_catch_fork,
 125     bp_catch_vfork,
 126     bp_catch_exec,
 127
 128     /* These are catchpoints to implement "catch catch" and "catch throw"
 129        commands for C++ exception handling. */
 130     bp_catch_catch,
 131     bp_catch_throw
 132
 133
 134   };
 135
 136 /* States of enablement of breakpoint. */
 137
 138 enum enable_state
 139   {
 140     bp_disabled,        /* The eventpoint is inactive, and cannot trigger. */
 141     bp_enabled,         /* The eventpoint is active, and can trigger. */
 142     bp_shlib_disabled,  /* The eventpoint's address is in an unloaded solib.
 143                            The eventpoint will be automatically enabled
 144                            and reset when that solib is loaded. */
 145     bp_call_disabled,   /* The eventpoint has been disabled while a call
 146                            into the inferior is "in flight", because some
 147                            eventpoints interfere with the implementation of
 148                            a call on some targets.  The eventpoint will be
 149                            automatically enabled and reset when the call
 150                            "lands" (either completes, or stops at another
 151                            eventpoint). */
 152     bp_permanent        /* There is a breakpoint instruction hard-wired into
 153                            the target's code.  Don't try to write another
 154                            breakpoint instruction on top of it, or restore
 155                            its value.  Step over it using the architecture's
 156                            SKIP_INSN macro.  */
 157   };
 158
 159
 160 /* Disposition of breakpoint.  Ie: what to do after hitting it. */
 161
 162 enum bpdisp
 163   {
 164     disp_del,                   /* Delete it */
 165     disp_del_at_next_stop,      /* Delete at next stop, whether hit or not */
 166     disp_disable,               /* Disable it */
 167     disp_donttouch              /* Leave it alone */
 168   };
 169
 170 enum target_hw_bp_type
 171   {
 172     hw_write   = 0,             /* Common  HW watchpoint */
 173     hw_read    = 1,             /* Read    HW watchpoint */
 174     hw_access  = 2,             /* Access  HW watchpoint */
 175     hw_execute = 3              /* Execute HW breakpoint */
 176   };
 177
 178 /* Note that the ->silent field is not currently used by any commands
 179    (though the code is in there if it was to be, and set_raw_breakpoint
 180    does set it to 0).  I implemented it because I thought it would be
 181    useful for a hack I had to put in; I'm going to leave it in because
 182    I can see how there might be times when it would indeed be useful */
 183
 184 /* This is for a breakpoint or a watchpoint.  */
 185
 186 struct breakpoint
 187   {
 188     struct breakpoint *next;
 189     /* Type of breakpoint. */
 190     enum bptype type;
 191     /* Zero means disabled; remember the info but don't break here.  */
 192     enum enable_state enable_state;
 193     /* What to do with this breakpoint after we hit it. */
 194     enum bpdisp disposition;
 195     /* Number assigned to distinguish breakpoints.  */
 196     int number;
 197
 198     /* Address to break at.
 199        Note that zero is a perfectly valid code address on some
 200        platforms (for example, the mn10200 and mn10300 simulators).
 201        NULL is not a special value for this field.  */
 202     CORE_ADDR address;
 203
 204     /* Line number of this address.  */
 205
 206     int line_number;
 207
 208     /* Source file name of this address.  */
 209
 210     char *source_file;
 211
 212     /* Non-zero means a silent breakpoint (don't print frame info
 213        if we stop here). */
 214     unsigned char silent;
 215     /* Number of stops at this breakpoint that should
 216        be continued automatically before really stopping.  */
 217     int ignore_count;
 218     /* "Real" contents of byte where breakpoint has been inserted.
 219        Valid only when breakpoints are in the program.  Under the complete
 220        control of the target insert_breakpoint and remove_breakpoint routines.
 221        No other code should assume anything about the value(s) here.  */
 222     char shadow_contents[BREAKPOINT_MAX];
 223     /* Nonzero if this breakpoint is now inserted.  */
 224     char inserted;
 225     /* Nonzero if this is not the first breakpoint in the list
 226        for the given address.  */
 227     char duplicate;
 228     /* Chain of command lines to execute when this breakpoint is hit.  */
 229     struct command_line *commands;
 230     /* Stack depth (address of frame).  If nonzero, break only if fp
 231        equals this.  */
 232     CORE_ADDR frame;
 233     /* Conditional.  Break only if this expression's value is nonzero.  */
 234     struct expression *cond;
 235
 236     /* String we used to set the breakpoint (malloc'd).  */
 237     char *addr_string;
 238     /* Language we used to set the breakpoint.  */
 239     enum language language;
 240     /* Input radix we used to set the breakpoint.  */
 241     int input_radix;
 242     /* String form of the breakpoint condition (malloc'd), or NULL if there
 243        is no condition.  */
 244     char *cond_string;
 245     /* String form of exp (malloc'd), or NULL if none.  */
 246     char *exp_string;
 247
 248     /* The expression we are watching, or NULL if not a watchpoint.  */
 249     struct expression *exp;
 250     /* The largest block within which it is valid, or NULL if it is
 251        valid anywhere (e.g. consists just of global symbols).  */
 252     struct block *exp_valid_block;
 253     /* Value of the watchpoint the last time we checked it.  */
 254     struct value *val;
 255
 256     /* Holds the value chain for a hardware watchpoint expression.  */
 257     struct value *val_chain;
 258
 259     /* Holds the address of the related watchpoint_scope breakpoint
 260        when using watchpoints on local variables (might the concept
 261        of a related breakpoint be useful elsewhere, if not just call
 262        it the watchpoint_scope breakpoint or something like that. FIXME).  */
 263     struct breakpoint *related_breakpoint;
 264
 265     /* Holds the frame address which identifies the frame this watchpoint
 266        should be evaluated in, or NULL if the watchpoint should be evaluated
 267        on the outermost frame.  */
 268     CORE_ADDR watchpoint_frame;
 269
 270     /* Thread number for thread-specific breakpoint, or -1 if don't care */
 271     int thread;
 272
 273     /* Count of the number of times this breakpoint was taken, dumped
 274        with the info, but not used for anything else.  Useful for
 275        seeing how many times you hit a break prior to the program
 276        aborting, so you can back up to just before the abort.  */
 277     int hit_count;
 278
 279     /* Filename of a dynamically-linked library (dll), used for
 280        bp_catch_load and bp_catch_unload (malloc'd), or NULL if any
 281        library is significant.  */
 282     char *dll_pathname;
 283
 284     /* Filename of a dll whose state change (e.g., load or unload)
 285        triggered this catchpoint.  This field is only valid immediately
 286        after this catchpoint has triggered.  */
 287     char *triggered_dll_pathname;
 288
 289     /* Process id of a child process whose forking triggered this
 290        catchpoint.  This field is only valid immediately after this
 291        catchpoint has triggered.  */
 292     int forked_inferior_pid;
 293
 294     /* Filename of a program whose exec triggered this catchpoint.
 295        This field is only valid immediately after this catchpoint has
 296        triggered.  */
 297     char *exec_pathname;
 298
 299     asection *section;
 300   };
 301 \f
 302 /* The following stuff is an abstract data type "bpstat" ("breakpoint
 303    status").  This provides the ability to determine whether we have
 304    stopped at a breakpoint, and what we should do about it.  */
 305
 306 typedef struct bpstats *bpstat;
 307
 308 /* Interface:  */
 309 /* Clear a bpstat so that it says we are not at any breakpoint.
 310    Also free any storage that is part of a bpstat.  */
 311 extern void bpstat_clear (bpstat *);
 312
 313 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
 314    is part of the bpstat is copied as well.  */
 315 extern bpstat bpstat_copy (bpstat);
 316
 317 extern bpstat bpstat_stop_status (CORE_ADDR *, int);
 318 \f
 319 /* This bpstat_what stuff tells wait_for_inferior what to do with a
 320    breakpoint (a challenging task).  */
 321
 322 enum bpstat_what_main_action
 323   {
 324     /* Perform various other tests; that is, this bpstat does not
 325        say to perform any action (e.g. failed watchpoint and nothing
 326        else).  */
 327     BPSTAT_WHAT_KEEP_CHECKING,
 328
 329     /* Rather than distinguish between noisy and silent stops here, it
 330        might be cleaner to have bpstat_print make that decision (also
 331        taking into account stop_print_frame and source_only).  But the
 332        implications are a bit scary (interaction with auto-displays, etc.),
 333        so I won't try it.  */
 334
 335     /* Stop silently.  */
 336     BPSTAT_WHAT_STOP_SILENT,
 337
 338     /* Stop and print.  */
 339     BPSTAT_WHAT_STOP_NOISY,
 340
 341     /* Remove breakpoints, single step once, then put them back in and
 342        go back to what we were doing.  It's possible that this should be
 343        removed from the main_action and put into a separate field, to more
 344        cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE.  */
 345     BPSTAT_WHAT_SINGLE,
 346
 347     /* Set longjmp_resume breakpoint, remove all other breakpoints,
 348        and continue.  The "remove all other breakpoints" part is required
 349        if we are also stepping over another breakpoint as well as doing
 350        the longjmp handling.  */
 351     BPSTAT_WHAT_SET_LONGJMP_RESUME,
 352
 353     /* Clear longjmp_resume breakpoint, then handle as
 354        BPSTAT_WHAT_KEEP_CHECKING.  */
 355     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME,
 356
 357     /* Clear longjmp_resume breakpoint, then handle as BPSTAT_WHAT_SINGLE.  */
 358     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE,
 359
 360     /* Clear step resume breakpoint, and keep checking.  */
 361     BPSTAT_WHAT_STEP_RESUME,
 362
 363     /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep
 364        checking.  */
 365     BPSTAT_WHAT_THROUGH_SIGTRAMP,
 366
 367     /* Check the dynamic linker's data structures for new libraries, then
 368        keep checking.  */
 369     BPSTAT_WHAT_CHECK_SHLIBS,
 370
 371     /* Check the dynamic linker's data structures for new libraries, then
 372        resume out of the dynamic linker's callback, stop and print.  */
 373     BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK,
 374
 375     /* This is just used to keep track of how many enums there are.  */
 376     BPSTAT_WHAT_LAST
 377   };
 378
 379 struct bpstat_what
 380   {
 381     enum bpstat_what_main_action main_action;
 382
 383     /* Did we hit a call dummy breakpoint?  This only goes with a main_action
 384        of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
 385        continuing from a call dummy without popping the frame is not a
 386        useful one).  */
 387     int call_dummy;
 388   };
 389
 390 /* The possible return values for print_bpstat, print_it_normal,
 391    print_it_done, print_it_noop. */
 392 enum print_stop_action
 393   {
 394     PRINT_UNKNOWN = -1,
 395     PRINT_SRC_AND_LOC,
 396     PRINT_SRC_ONLY,
 397     PRINT_NOTHING
 398   };
 399
 400 /* Tell what to do about this bpstat.  */
 401 struct bpstat_what bpstat_what (bpstat);
 402 \f
 403 /* Find the bpstat associated with a breakpoint.  NULL otherwise. */
 404 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
 405
 406 /* Find a step_resume breakpoint associated with this bpstat.
 407    (If there are multiple step_resume bp's on the list, this function
 408    will arbitrarily pick one.)
 409
 410    It is an error to use this function if BPSTAT doesn't contain a
 411    step_resume breakpoint.
 412
 413    See wait_for_inferior's use of this function.
 414  */
 415 extern struct breakpoint *bpstat_find_step_resume_breakpoint (bpstat);
 416
 417 /* Nonzero if a signal that we got in wait() was due to circumstances
 418    explained by the BS.  */
 419 /* Currently that is true if we have hit a breakpoint, or if there is
 420    a watchpoint enabled.  */
 421 #define bpstat_explains_signal(bs) ((bs) != NULL)
 422
 423 /* Nonzero if we should step constantly (e.g. watchpoints on machines
 424    without hardware support).  This isn't related to a specific bpstat,
 425    just to things like whether watchpoints are set.  */
 426 extern int bpstat_should_step (void);
 427
 428 /* Nonzero if there are enabled hardware watchpoints. */
 429 extern int bpstat_have_active_hw_watchpoints (void);
 430
 431 /* Print a message indicating what happened.  Returns nonzero to
 432    say that only the source line should be printed after this (zero
 433    return means print the frame as well as the source line).  */
 434 extern enum print_stop_action bpstat_print (bpstat);
 435
 436 /* Return the breakpoint number of the first breakpoint we are stopped
 437    at.  *BSP upon return is a bpstat which points to the remaining
 438    breakpoints stopped at (but which is not guaranteed to be good for
 439    anything but further calls to bpstat_num).
 440    Return 0 if passed a bpstat which does not indicate any breakpoints.  */
 441 extern int bpstat_num (bpstat *);
 442
 443 /* Perform actions associated with having stopped at *BSP.  Actually, we just
 444    use this for breakpoint commands.  Perhaps other actions will go here
 445    later, but this is executed at a late time (from the command loop).  */
 446 extern void bpstat_do_actions (bpstat *);
 447
 448 /* Modify BS so that the actions will not be performed.  */
 449 extern void bpstat_clear_actions (bpstat);
 450
 451 /* Given a bpstat that records zero or more triggered eventpoints, this
 452    function returns another bpstat which contains only the catchpoints
 453    on that first list, if any.
 454  */
 455 extern void bpstat_get_triggered_catchpoints (bpstat, bpstat *);
 456
 457 /* Implementation:  */
 458
 459 /* Values used to tell the printing routine how to behave for this bpstat. */
 460 enum bp_print_how
 461   {
 462     /* This is used when we want to do a normal printing of the reason
 463        for stopping. The output will depend on the type of eventpoint
 464        we are dealing with. This is the default value, most commonly
 465        used. */
 466     print_it_normal,
 467     /* This is used when nothing should be printed for this bpstat entry.  */
 468     print_it_noop,
 469     /* This is used when everything which needs to be printed has
 470        already been printed.  But we still want to print the frame.  */
 471     print_it_done
 472   };
 473
 474 struct bpstats
 475   {
 476     /* Linked list because there can be two breakpoints at the same
 477        place, and a bpstat reflects the fact that both have been hit.  */
 478     bpstat next;
 479     /* Breakpoint that we are at.  */
 480     struct breakpoint *breakpoint_at;
 481     /* Commands left to be done.  */
 482     struct command_line *commands;
 483     /* Old value associated with a watchpoint.  */
 484     struct value *old_val;
 485
 486     /* Nonzero if this breakpoint tells us to print the frame.  */
 487     char print;
 488
 489     /* Nonzero if this breakpoint tells us to stop.  */
 490     char stop;
 491
 492     /* Tell bpstat_print and print_bp_stop_message how to print stuff
 493        associated with this element of the bpstat chain.  */
 494     enum bp_print_how print_it;
 495   };
 496
 497 enum inf_context
 498   {
 499     inf_starting,
 500     inf_running,
 501     inf_exited
 502   };
 503
 504 /* The possible return values for breakpoint_here_p.
 505    We guarantee that zero always means "no breakpoint here".  */
 506 enum breakpoint_here
 507   {
 508     no_breakpoint_here = 0,
 509     ordinary_breakpoint_here,
 510     permanent_breakpoint_here
 511   };
 512 \f
 513
 514 /* Prototypes for breakpoint-related functions.  */
 515
 516 /* Forward declarations for prototypes */
 517 struct frame_info;
 518
 519 extern enum breakpoint_here breakpoint_here_p (CORE_ADDR);
 520
 521 extern int breakpoint_inserted_here_p (CORE_ADDR);
 522
 523 extern int frame_in_dummy (struct frame_info *);
 524
 525 extern int breakpoint_thread_match (CORE_ADDR, ptid_t);
 526
 527 extern void until_break_command (char *, int);
 528
 529 extern void breakpoint_re_set (void);
 530
 531 extern void breakpoint_re_set_thread (struct breakpoint *);
 532
 533 extern int ep_is_exception_catchpoint (struct breakpoint *);
 534
 535 extern struct breakpoint *set_momentary_breakpoint
 536   (struct symtab_and_line, struct frame_info *, enum bptype);
 537
 538 extern void set_ignore_count (int, int, int);
 539
 540 extern void set_default_breakpoint (int, CORE_ADDR, struct symtab *, int);
 541
 542 extern void mark_breakpoints_out (void);
 543
 544 extern void breakpoint_init_inferior (enum inf_context);
 545
 546 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
 547
 548 extern struct cleanup *make_exec_cleanup_delete_breakpoint (struct breakpoint *);
 549
 550 extern void delete_breakpoint (struct breakpoint *);
 551
 552 extern void breakpoint_auto_delete (bpstat);
 553
 554 extern void breakpoint_clear_ignore_counts (void);
 555
 556 extern void break_command (char *, int);
 557
 558 extern void hbreak_command_wrapper (char *, int);
 559 extern void thbreak_command_wrapper (char *, int);
 560 extern void rbreak_command_wrapper (char *, int);
 561 extern void watch_command_wrapper (char *, int);
 562 extern void awatch_command_wrapper (char *, int);
 563 extern void rwatch_command_wrapper (char *, int);
 564 extern void tbreak_command (char *, int);
 565
 566 extern int insert_breakpoints (void);
 567
 568 extern int remove_breakpoints (void);
 569
 570 /* This function can be used to physically insert eventpoints from the
 571    specified traced inferior process, without modifying the breakpoint
 572    package's state.  This can be useful for those targets which support
 573    following the processes of a fork() or vfork() system call, when both
 574    of the resulting two processes are to be followed.  */
 575 extern int reattach_breakpoints (int);
 576
 577 /* This function can be used to update the breakpoint package's state
 578    after an exec() system call has been executed.
 579
 580    This function causes the following:
 581
 582    - All eventpoints are marked "not inserted".
 583    - All eventpoints with a symbolic address are reset such that
 584    the symbolic address must be reevaluated before the eventpoints
 585    can be reinserted.
 586    - The solib breakpoints are explicitly removed from the breakpoint
 587    list.
 588    - A step-resume breakpoint, if any, is explicitly removed from the
 589    breakpoint list.
 590    - All eventpoints without a symbolic address are removed from the
 591    breakpoint list. */
 592 extern void update_breakpoints_after_exec (void);
 593
 594 /* This function can be used to physically remove hardware breakpoints
 595    and watchpoints from the specified traced inferior process, without
 596    modifying the breakpoint package's state.  This can be useful for
 597    those targets which support following the processes of a fork() or
 598    vfork() system call, when one of the resulting two processes is to
 599    be detached and allowed to run free.
 600
 601    It is an error to use this function on the process whose id is
 602    inferior_ptid.  */
 603 extern int detach_breakpoints (int);
 604
 605 extern void enable_longjmp_breakpoint (void);
 606
 607 extern void disable_longjmp_breakpoint (void);
 608
 609 extern void set_longjmp_resume_breakpoint (CORE_ADDR, struct frame_info *);
 610 /* These functions respectively disable or reenable all currently
 611    enabled watchpoints.  When disabled, the watchpoints are marked
 612    call_disabled.  When reenabled, they are marked enabled.
 613
 614    The intended client of these functions is infcmd.c\run_stack_dummy.
 615
 616    The inferior must be stopped, and all breakpoints removed, when
 617    these functions are used.
 618
 619    The need for these functions is that on some targets (e.g., HP-UX),
 620    gdb is unable to unwind through the dummy frame that is pushed as
 621    part of the implementation of a call command.  Watchpoints can
 622    cause the inferior to stop in places where this frame is visible,
 623    and that can cause execution control to become very confused.
 624
 625    Note that if a user sets breakpoints in an interactively called
 626    function, the call_disabled watchpoints will have been reenabled
 627    when the first such breakpoint is reached.  However, on targets
 628    that are unable to unwind through the call dummy frame, watches
 629    of stack-based storage may then be deleted, because gdb will
 630    believe that their watched storage is out of scope.  (Sigh.) */
 631 extern void disable_watchpoints_before_interactive_call_start (void);
 632
 633 extern void enable_watchpoints_after_interactive_call_stop (void);
 634
 635
 636 extern void clear_breakpoint_hit_counts (void);
 637
 638 extern int get_number (char **);
 639
 640 extern int get_number_or_range (char **);
 641
 642 /* The following are for displays, which aren't really breakpoints, but
 643    here is as good a place as any for them.  */
 644
 645 extern void disable_current_display (void);
 646
 647 extern void do_displays (void);
 648
 649 extern void disable_display (int);
 650
 651 extern void clear_displays (void);
 652
 653 extern void disable_breakpoint (struct breakpoint *);
 654
 655 extern void enable_breakpoint (struct breakpoint *);
 656
 657 extern void make_breakpoint_permanent (struct breakpoint *);
 658
 659 extern struct breakpoint *create_solib_event_breakpoint (CORE_ADDR);
 660
 661 extern struct breakpoint *create_thread_event_breakpoint (CORE_ADDR);
 662
 663 extern void remove_solib_event_breakpoints (void);
 664
 665 extern void remove_thread_event_breakpoints (void);
 666
 667 extern void disable_breakpoints_in_shlibs (int silent);
 668
 669 extern void re_enable_breakpoints_in_shlibs (void);
 670
 671 extern void create_solib_load_event_breakpoint (char *, int, char *, char *);
 672
 673 extern void create_solib_unload_event_breakpoint (char *, int,
 674                                                   char *, char *);
 675
 676 extern void create_fork_event_catchpoint (int, char *);
 677
 678 extern void create_vfork_event_catchpoint (int, char *);
 679
 680 extern void create_exec_event_catchpoint (int, char *);
 681
 682 /* This function returns TRUE if ep is a catchpoint. */
 683 extern int ep_is_catchpoint (struct breakpoint *);
 684
 685 /* This function returns TRUE if ep is a catchpoint of a
 686    shared library (aka dynamically-linked library) event,
 687    such as a library load or unload. */
 688 extern int ep_is_shlib_catchpoint (struct breakpoint *);
 689
 690 extern struct breakpoint *set_breakpoint_sal (struct symtab_and_line);
 691
 692 /* Enable breakpoints and delete when hit.  Called with ARG == NULL
 693    deletes all breakpoints. */
 694 extern void delete_command (char *arg, int from_tty);
 695
 696 /* Pull all H/W watchpoints from the target. Return non-zero if the
 697    remove fails. */
 698 extern int remove_hw_watchpoints (void);
 699
 700 #endif /* !defined (BREAKPOINT_H) */