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