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