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