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