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_state
 137   {
 138     bp_disabled,        /* The eventpoint is inactive, and cannot trigger. */
 139     bp_enabled,         /* The eventpoint is active, and can trigger. */
 140     bp_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     bp_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     bp_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     disp_del,                   /* Delete it */
 163     disp_del_at_next_stop,      /* Delete at next stop, whether hit or not */
 164     disp_disable,               /* Disable it */
 165     disp_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_state enable_state;
 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.
 197        Note that zero is a perfectly valid code address on some
 198        platforms (for example, the mn10200 and mn10300 simulators).
 199        NULL is not a special value for this field.  */
 200     CORE_ADDR address;
 201
 202     /* Line number of this address.  */
 203
 204     int line_number;
 205
 206     /* Source file name of this address.  */
 207
 208     char *source_file;
 209
 210     /* Non-zero means a silent breakpoint (don't print frame info
 211        if we stop here). */
 212     unsigned char silent;
 213     /* Number of stops at this breakpoint that should
 214        be continued automatically before really stopping.  */
 215     int ignore_count;
 216     /* "Real" contents of byte where breakpoint has been inserted.
 217        Valid only when breakpoints are in the program.  Under the complete
 218        control of the target insert_breakpoint and remove_breakpoint routines.
 219        No other code should assume anything about the value(s) here.  */
 220     char shadow_contents[BREAKPOINT_MAX];
 221     /* Nonzero if this breakpoint is now inserted.  */
 222     char inserted;
 223     /* Nonzero if this is not the first breakpoint in the list
 224        for the given address.  */
 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).  */
 235     char *addr_string;
 236     /* Language we used to set the breakpoint.  */
 237     enum language language;
 238     /* Input radix we used to set the breakpoint.  */
 239     int input_radix;
 240     /* String form of the breakpoint condition (malloc'd), or NULL if there
 241        is no condition.  */
 242     char *cond_string;
 243     /* String form of exp (malloc'd), or NULL if none.  */
 244     char *exp_string;
 245
 246     /* The expression we are watching, or NULL if not a watchpoint.  */
 247     struct expression *exp;
 248     /* The largest block within which it is valid, or NULL if it is
 249        valid anywhere (e.g. consists just of global symbols).  */
 250     struct block *exp_valid_block;
 251     /* Value of the watchpoint the last time we checked it.  */
 252     value_ptr val;
 253
 254     /* Holds the value chain for a hardware watchpoint expression.  */
 255     value_ptr val_chain;
 256
 257     /* Holds the address of the related watchpoint_scope breakpoint
 258        when using watchpoints on local variables (might the concept
 259        of a related breakpoint be useful elsewhere, if not just call
 260        it the watchpoint_scope breakpoint or something like that. FIXME).  */
 261     struct breakpoint *related_breakpoint;
 262
 263     /* Holds the frame address which identifies the frame this watchpoint
 264        should be evaluated in, or NULL if the watchpoint should be evaluated
 265        on the outermost frame.  */
 266     CORE_ADDR watchpoint_frame;
 267
 268     /* Thread number for thread-specific breakpoint, or -1 if don't care */
 269     int thread;
 270
 271     /* Count of the number of times this breakpoint was taken, dumped
 272        with the info, but not used for anything else.  Useful for
 273        seeing how many times you hit a break prior to the program
 274        aborting, so you can back up to just before the abort.  */
 275     int hit_count;
 276
 277     /* Filename of a dynamically-linked library (dll), used for
 278        bp_catch_load and bp_catch_unload (malloc'd), or NULL if any
 279        library is significant.  */
 280     char *dll_pathname;
 281
 282     /* Filename of a dll whose state change (e.g., load or unload)
 283        triggered this catchpoint.  This field is only valid immediately
 284        after this catchpoint has triggered.  */
 285     char *triggered_dll_pathname;
 286
 287     /* Process id of a child process whose forking triggered this
 288        catchpoint.  This field is only valid immediately after this
 289        catchpoint has triggered.  */
 290     int forked_inferior_pid;
 291
 292     /* Filename of a program whose exec triggered this catchpoint.
 293        This field is only valid immediately after this catchpoint has
 294        triggered.  */
 295     char *exec_pathname;
 296
 297     asection *section;
 298   };
 299 \f
 300 /* The following stuff is an abstract data type "bpstat" ("breakpoint
 301    status").  This provides the ability to determine whether we have
 302    stopped at a breakpoint, and what we should do about it.  */
 303
 304 typedef struct bpstats *bpstat;
 305
 306 /* Interface:  */
 307 /* Clear a bpstat so that it says we are not at any breakpoint.
 308    Also free any storage that is part of a bpstat.  */
 309 extern void bpstat_clear (bpstat *);
 310
 311 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
 312    is part of the bpstat is copied as well.  */
 313 extern bpstat bpstat_copy (bpstat);
 314
 315 extern bpstat bpstat_stop_status (CORE_ADDR *, int);
 316 \f
 317 /* This bpstat_what stuff tells wait_for_inferior what to do with a
 318    breakpoint (a challenging task).  */
 319
 320 enum bpstat_what_main_action
 321   {
 322     /* Perform various other tests; that is, this bpstat does not
 323        say to perform any action (e.g. failed watchpoint and nothing
 324        else).  */
 325     BPSTAT_WHAT_KEEP_CHECKING,
 326
 327     /* Rather than distinguish between noisy and silent stops here, it
 328        might be cleaner to have bpstat_print make that decision (also
 329        taking into account stop_print_frame and source_only).  But the
 330        implications are a bit scary (interaction with auto-displays, etc.),
 331        so I won't try it.  */
 332
 333     /* Stop silently.  */
 334     BPSTAT_WHAT_STOP_SILENT,
 335
 336     /* Stop and print.  */
 337     BPSTAT_WHAT_STOP_NOISY,
 338
 339     /* Remove breakpoints, single step once, then put them back in and
 340        go back to what we were doing.  It's possible that this should be
 341        removed from the main_action and put into a separate field, to more
 342        cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE.  */
 343     BPSTAT_WHAT_SINGLE,
 344
 345     /* Set longjmp_resume breakpoint, remove all other breakpoints,
 346        and continue.  The "remove all other breakpoints" part is required
 347        if we are also stepping over another breakpoint as well as doing
 348        the longjmp handling.  */
 349     BPSTAT_WHAT_SET_LONGJMP_RESUME,
 350
 351     /* Clear longjmp_resume breakpoint, then handle as
 352        BPSTAT_WHAT_KEEP_CHECKING.  */
 353     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME,
 354
 355     /* Clear longjmp_resume breakpoint, then handle as BPSTAT_WHAT_SINGLE.  */
 356     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE,
 357
 358     /* Clear step resume breakpoint, and keep checking.  */
 359     BPSTAT_WHAT_STEP_RESUME,
 360
 361     /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep
 362        checking.  */
 363     BPSTAT_WHAT_THROUGH_SIGTRAMP,
 364
 365     /* Check the dynamic linker's data structures for new libraries, then
 366        keep checking.  */
 367     BPSTAT_WHAT_CHECK_SHLIBS,
 368
 369     /* Check the dynamic linker's data structures for new libraries, then
 370        resume out of the dynamic linker's callback, stop and print.  */
 371     BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK,
 372
 373     /* This is just used to keep track of how many enums there are.  */
 374     BPSTAT_WHAT_LAST
 375   };
 376
 377 struct bpstat_what
 378   {
 379     enum bpstat_what_main_action main_action;
 380
 381     /* Did we hit a call dummy breakpoint?  This only goes with a main_action
 382        of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
 383        continuing from a call dummy without popping the frame is not a
 384        useful one).  */
 385     int call_dummy;
 386   };
 387
 388 /* The possible return values for print_bpstat, print_it_normal,
 389    print_it_done, print_it_noop. */
 390 enum print_stop_action
 391   {
 392     PRINT_UNKNOWN = -1,
 393     PRINT_SRC_AND_LOC,
 394     PRINT_SRC_ONLY,
 395     PRINT_NOTHING
 396   };
 397
 398 /* Tell what to do about this bpstat.  */
 399 struct bpstat_what bpstat_what (bpstat);
 400 \f
 401 /* Find the bpstat associated with a breakpoint.  NULL otherwise. */
 402 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
 403
 404 /* Find a step_resume breakpoint associated with this bpstat.
 405    (If there are multiple step_resume bp's on the list, this function
 406    will arbitrarily pick one.)
 407
 408    It is an error to use this function if BPSTAT doesn't contain a
 409    step_resume breakpoint.
 410
 411    See wait_for_inferior's use of this function.
 412  */
 413 extern struct breakpoint *bpstat_find_step_resume_breakpoint (bpstat);
 414
 415 /* Nonzero if a signal that we got in wait() was due to circumstances
 416    explained by the BS.  */
 417 /* Currently that is true if we have hit a breakpoint, or if there is
 418    a watchpoint enabled.  */
 419 #define bpstat_explains_signal(bs) ((bs) != NULL)
 420
 421 /* Nonzero if we should step constantly (e.g. watchpoints on machines
 422    without hardware support).  This isn't related to a specific bpstat,
 423    just to things like whether watchpoints are set.  */
 424 extern int bpstat_should_step (void);
 425
 426 /* Nonzero if there are enabled hardware watchpoints. */
 427 extern int bpstat_have_active_hw_watchpoints (void);
 428
 429 /* Print a message indicating what happened.  Returns nonzero to
 430    say that only the source line should be printed after this (zero
 431    return means print the frame as well as the source line).  */
 432 extern enum print_stop_action bpstat_print (bpstat);
 433
 434 /* Return the breakpoint number of the first breakpoint we are stopped
 435    at.  *BSP upon return is a bpstat which points to the remaining
 436    breakpoints stopped at (but which is not guaranteed to be good for
 437    anything but further calls to bpstat_num).
 438    Return 0 if passed a bpstat which does not indicate any breakpoints.  */
 439 extern int bpstat_num (bpstat *);
 440
 441 /* Perform actions associated with having stopped at *BSP.  Actually, we just
 442    use this for breakpoint commands.  Perhaps other actions will go here
 443    later, but this is executed at a late time (from the command loop).  */
 444 extern void bpstat_do_actions (bpstat *);
 445
 446 /* Modify BS so that the actions will not be performed.  */
 447 extern void bpstat_clear_actions (bpstat);
 448
 449 /* Given a bpstat that records zero or more triggered eventpoints, this
 450    function returns another bpstat which contains only the catchpoints
 451    on that first list, if any.
 452  */
 453 extern void bpstat_get_triggered_catchpoints (bpstat, bpstat *);
 454
 455 /* Implementation:  */
 456
 457 /* Values used to tell the printing routine how to behave for this bpstat. */
 458 enum bp_print_how
 459   {
 460     /* This is used when we want to do a normal printing of the reason
 461        for stopping. The output will depend on the type of eventpoint
 462        we are dealing with. This is the default value, most commonly
 463        used. */
 464     print_it_normal,
 465     /* This is used when nothing should be printed for this bpstat entry.  */
 466     print_it_noop,
 467     /* This is used when everything which needs to be printed has
 468        already been printed.  But we still want to print the frame.  */
 469     print_it_done
 470   };
 471
 472 struct bpstats
 473   {
 474     /* Linked list because there can be two breakpoints at the same
 475        place, and a bpstat reflects the fact that both have been hit.  */
 476     bpstat next;
 477     /* Breakpoint that we are at.  */
 478     struct breakpoint *breakpoint_at;
 479     /* Commands left to be done.  */
 480     struct command_line *commands;
 481     /* Old value associated with a watchpoint.  */
 482     value_ptr old_val;
 483
 484     /* Nonzero if this breakpoint tells us to print the frame.  */
 485     char print;
 486
 487     /* Nonzero if this breakpoint tells us to stop.  */
 488     char stop;
 489
 490     /* Tell bpstat_print and print_bp_stop_message how to print stuff
 491        associated with this element of the bpstat chain.  */
 492     enum bp_print_how print_it;
 493   };
 494
 495 enum inf_context
 496   {
 497     inf_starting,
 498     inf_running,
 499     inf_exited
 500   };
 501
 502 /* The possible return values for breakpoint_here_p.
 503    We guarantee that zero always means "no breakpoint here".  */
 504 enum breakpoint_here
 505   {
 506     no_breakpoint_here = 0,
 507     ordinary_breakpoint_here,
 508     permanent_breakpoint_here
 509   };
 510 \f
 511
 512 /* Prototypes for breakpoint-related functions.  */
 513
 514 /* Forward declarations for prototypes */
 515 struct frame_info;
 516
 517 extern enum breakpoint_here breakpoint_here_p (CORE_ADDR);
 518
 519 extern int breakpoint_inserted_here_p (CORE_ADDR);
 520
 521 extern int frame_in_dummy (struct frame_info *);
 522
 523 extern int breakpoint_thread_match (CORE_ADDR, ptid_t);
 524
 525 extern void until_break_command (char *, int);
 526
 527 extern void breakpoint_re_set (void);
 528
 529 extern void breakpoint_re_set_thread (struct breakpoint *);
 530
 531 extern int ep_is_exception_catchpoint (struct breakpoint *);
 532
 533 extern struct breakpoint *set_momentary_breakpoint
 534   (struct symtab_and_line, struct frame_info *, enum bptype);
 535
 536 extern void set_ignore_count (int, int, int);
 537
 538 extern void set_default_breakpoint (int, CORE_ADDR, struct symtab *, int);
 539
 540 extern void mark_breakpoints_out (void);
 541
 542 extern void breakpoint_init_inferior (enum inf_context);
 543
 544 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
 545
 546 extern struct cleanup *make_exec_cleanup_delete_breakpoint (struct breakpoint *);
 547
 548 extern void delete_breakpoint (struct breakpoint *);
 549
 550 extern void breakpoint_auto_delete (bpstat);
 551
 552 extern void breakpoint_clear_ignore_counts (void);
 553
 554 extern void break_command (char *, int);
 555
 556 extern void hbreak_command_wrapper (char *, int);
 557 extern void thbreak_command_wrapper (char *, int);
 558 extern void rbreak_command_wrapper (char *, int);
 559 extern void watch_command_wrapper (char *, int);
 560 extern void awatch_command_wrapper (char *, int);
 561 extern void rwatch_command_wrapper (char *, int);
 562 extern void tbreak_command (char *, int);
 563
 564 extern int insert_breakpoints (void);
 565
 566 extern int remove_breakpoints (void);
 567
 568 /* This function can be used to physically insert eventpoints from the
 569    specified traced inferior process, without modifying the breakpoint
 570    package's state.  This can be useful for those targets which support
 571    following the processes of a fork() or vfork() system call, when both
 572    of the resulting two processes are to be followed.  */
 573 extern int reattach_breakpoints (int);
 574
 575 /* This function can be used to update the breakpoint package's state
 576    after an exec() system call has been executed.
 577
 578    This function causes the following:
 579
 580    - All eventpoints are marked "not inserted".
 581    - All eventpoints with a symbolic address are reset such that
 582    the symbolic address must be reevaluated before the eventpoints
 583    can be reinserted.
 584    - The solib breakpoints are explicitly removed from the breakpoint
 585    list.
 586    - A step-resume breakpoint, if any, is explicitly removed from the
 587    breakpoint list.
 588    - All eventpoints without a symbolic address are removed from the
 589    breakpoint list. */
 590 extern void update_breakpoints_after_exec (void);
 591
 592 /* This function can be used to physically remove hardware breakpoints
 593    and watchpoints from the specified traced inferior process, without
 594    modifying the breakpoint package's state.  This can be useful for
 595    those targets which support following the processes of a fork() or
 596    vfork() system call, when one of the resulting two processes is to
 597    be detached and allowed to run free.
 598
 599    It is an error to use this function on the process whose id is
 600    inferior_ptid.  */
 601 extern int detach_breakpoints (int);
 602
 603 extern void enable_longjmp_breakpoint (void);
 604
 605 extern void disable_longjmp_breakpoint (void);
 606
 607 extern void set_longjmp_resume_breakpoint (CORE_ADDR, struct frame_info *);
 608 /* These functions respectively disable or reenable all currently
 609    enabled watchpoints.  When disabled, the watchpoints are marked
 610    call_disabled.  When reenabled, they are marked enabled.
 611
 612    The intended client of these functions is infcmd.c\run_stack_dummy.
 613
 614    The inferior must be stopped, and all breakpoints removed, when
 615    these functions are used.
 616
 617    The need for these functions is that on some targets (e.g., HP-UX),
 618    gdb is unable to unwind through the dummy frame that is pushed as
 619    part of the implementation of a call command.  Watchpoints can
 620    cause the inferior to stop in places where this frame is visible,
 621    and that can cause execution control to become very confused.
 622
 623    Note that if a user sets breakpoints in an interactively called
 624    function, the call_disabled watchpoints will have been reenabled
 625    when the first such breakpoint is reached.  However, on targets
 626    that are unable to unwind through the call dummy frame, watches
 627    of stack-based storage may then be deleted, because gdb will
 628    believe that their watched storage is out of scope.  (Sigh.) */
 629 extern void disable_watchpoints_before_interactive_call_start (void);
 630
 631 extern void enable_watchpoints_after_interactive_call_stop (void);
 632
 633
 634 extern void clear_breakpoint_hit_counts (void);
 635
 636 extern int get_number (char **);
 637
 638 extern int get_number_or_range (char **);
 639
 640 /* The following are for displays, which aren't really breakpoints, but
 641    here is as good a place as any for them.  */
 642
 643 extern void disable_current_display (void);
 644
 645 extern void do_displays (void);
 646
 647 extern void disable_display (int);
 648
 649 extern void clear_displays (void);
 650
 651 extern void disable_breakpoint (struct breakpoint *);
 652
 653 extern void enable_breakpoint (struct breakpoint *);
 654
 655 extern void make_breakpoint_permanent (struct breakpoint *);
 656
 657 extern struct breakpoint *create_solib_event_breakpoint (CORE_ADDR);
 658
 659 extern struct breakpoint *create_thread_event_breakpoint (CORE_ADDR);
 660
 661 extern void remove_solib_event_breakpoints (void);
 662
 663 extern void remove_thread_event_breakpoints (void);
 664
 665 extern void disable_breakpoints_in_shlibs (int silent);
 666
 667 extern void re_enable_breakpoints_in_shlibs (void);
 668
 669 extern void create_solib_load_event_breakpoint (char *, int, char *, char *);
 670
 671 extern void create_solib_unload_event_breakpoint (char *, int,
 672                                                   char *, char *);
 673
 674 extern void create_fork_event_catchpoint (int, char *);
 675
 676 extern void create_vfork_event_catchpoint (int, char *);
 677
 678 extern void create_exec_event_catchpoint (int, char *);
 679
 680 /* This function returns TRUE if ep is a catchpoint. */
 681 extern int ep_is_catchpoint (struct breakpoint *);
 682
 683 /* This function returns TRUE if ep is a catchpoint of a
 684    shared library (aka dynamically-linked library) event,
 685    such as a library load or unload. */
 686 extern int ep_is_shlib_catchpoint (struct breakpoint *);
 687
 688 extern struct breakpoint *set_breakpoint_sal (struct symtab_and_line);
 689
 690 /* Enable breakpoints and delete when hit.  Called with ARG == NULL
 691    deletes all breakpoints. */
 692 extern void delete_command (char *arg, int from_tty);
 693
 694 /* Pull all H/W watchpoints from the target. Return non-zero if the
 695    remove fails. */
 696 extern int remove_hw_watchpoints (void);
 697
 698 #endif /* !defined (BREAKPOINT_H) */