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