gdb/breakpoint.h

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