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 within an unloaded solib.
 128                                    The eventpoint will be automatically enabled & reset
 129                                    when that solib is loaded. */
 130     call_disabled               /* The eventpoint has been disabled while a call into
 131                                    the inferior is "in flight", because some eventpoints
 132                                    interfere with the implementation of a call on some
 133                                    targets.  The eventpoint will be automatically enabled
 134                                    & reset when the call "lands" (either completes, or
 135                                    stops at another eventpoint). */
 136   };
 137
 138
 139 /* Disposition of breakpoint.  Ie: what to do after hitting it. */
 140
 141 enum bpdisp
 142   {
 143     del,                        /* Delete it */
 144     del_at_next_stop,           /* Delete at next stop, whether hit or not */
 145     disable,                    /* Disable it */
 146     donttouch                   /* Leave it alone */
 147   };
 148
 149 /* Note that the ->silent field is not currently used by any commands
 150    (though the code is in there if it was to be, and set_raw_breakpoint
 151    does set it to 0).  I implemented it because I thought it would be
 152    useful for a hack I had to put in; I'm going to leave it in because
 153    I can see how there might be times when it would indeed be useful */
 154
 155 /* This is for a breakpoint or a watchpoint.  */
 156
 157 struct breakpoint
 158   {
 159     struct breakpoint *next;
 160     /* Type of breakpoint. */
 161     enum bptype type;
 162     /* Zero means disabled; remember the info but don't break here.  */
 163     enum enable enable;
 164     /* What to do with this breakpoint after we hit it. */
 165     enum bpdisp disposition;
 166     /* Number assigned to distinguish breakpoints.  */
 167     int number;
 168
 169     /* Address to break at, or NULL if not a breakpoint.  */
 170     CORE_ADDR address;
 171
 172     /* Line number of this address.  Only matters if address is
 173        non-NULL.  */
 174
 175     int line_number;
 176
 177     /* Source file name of this address.  Only matters if address is
 178        non-NULL.  */
 179
 180     char *source_file;
 181
 182     /* Non-zero means a silent breakpoint (don't print frame info
 183        if we stop here). */
 184     unsigned char silent;
 185     /* Number of stops at this breakpoint that should
 186        be continued automatically before really stopping.  */
 187     int ignore_count;
 188     /* "Real" contents of byte where breakpoint has been inserted.
 189        Valid only when breakpoints are in the program.  Under the complete
 190        control of the target insert_breakpoint and remove_breakpoint routines.
 191        No other code should assume anything about the value(s) here.  */
 192     char shadow_contents[BREAKPOINT_MAX];
 193     /* Nonzero if this breakpoint is now inserted.  Only matters if address
 194        is non-NULL.  */
 195     char inserted;
 196     /* Nonzero if this is not the first breakpoint in the list
 197        for the given address.  Only matters if address is non-NULL.  */
 198     char duplicate;
 199     /* Chain of command lines to execute when this breakpoint is hit.  */
 200     struct command_line *commands;
 201     /* Stack depth (address of frame).  If nonzero, break only if fp
 202        equals this.  */
 203     CORE_ADDR frame;
 204     /* Conditional.  Break only if this expression's value is nonzero.  */
 205     struct expression *cond;
 206
 207     /* String we used to set the breakpoint (malloc'd).  Only matters if
 208        address is non-NULL.  */
 209     char *addr_string;
 210     /* Language we used to set the breakpoint.  */
 211     enum language language;
 212     /* Input radix we used to set the breakpoint.  */
 213     int input_radix;
 214     /* String form of the breakpoint condition (malloc'd), or NULL if there
 215        is no condition.  */
 216     char *cond_string;
 217     /* String form of exp (malloc'd), or NULL if none.  */
 218     char *exp_string;
 219
 220     /* The expression we are watching, or NULL if not a watchpoint.  */
 221     struct expression *exp;
 222     /* The largest block within which it is valid, or NULL if it is
 223        valid anywhere (e.g. consists just of global symbols).  */
 224     struct block *exp_valid_block;
 225     /* Value of the watchpoint the last time we checked it.  */
 226     value_ptr val;
 227
 228     /* Holds the value chain for a hardware watchpoint expression.  */
 229     value_ptr val_chain;
 230
 231     /* Holds the address of the related watchpoint_scope breakpoint
 232        when using watchpoints on local variables (might the concept
 233        of a related breakpoint be useful elsewhere, if not just call
 234        it the watchpoint_scope breakpoint or something like that. FIXME).  */
 235     struct breakpoint *related_breakpoint;
 236
 237     /* Holds the frame address which identifies the frame this watchpoint
 238        should be evaluated in, or NULL if the watchpoint should be evaluated
 239        on the outermost frame.  */
 240     CORE_ADDR watchpoint_frame;
 241
 242     /* Thread number for thread-specific breakpoint, or -1 if don't care */
 243     int thread;
 244
 245     /* Count of the number of times this breakpoint was taken, dumped
 246        with the info, but not used for anything else.  Useful for
 247        seeing how many times you hit a break prior to the program
 248        aborting, so you can back up to just before the abort.  */
 249     int hit_count;
 250
 251     /* Filename of a dynamically-linked library (dll), used for bp_catch_load
 252        and bp_catch_unload (malloc'd), or NULL if any library is significant.  */
 253     char *dll_pathname;
 254
 255     /* Filename of a dll whose state change (e.g., load or unload)
 256        triggered this catchpoint.  This field is only vaid immediately
 257        after this catchpoint has triggered.  */
 258     char *triggered_dll_pathname;
 259
 260     /* Process id of a child process whose forking triggered this catchpoint.
 261        This field is only vaid immediately after this catchpoint has triggered.  */
 262     int forked_inferior_pid;
 263
 264     /* Filename of a program whose exec triggered this catchpoint.  This
 265        field is only vaid immediately after this catchpoint has triggered.  */
 266     char *exec_pathname;
 267
 268     asection *section;
 269   };
 270 \f
 271 /* The following stuff is an abstract data type "bpstat" ("breakpoint status").
 272    This provides the ability to determine whether we have stopped at a
 273    breakpoint, and what we should do about it.  */
 274
 275 typedef struct bpstats *bpstat;
 276
 277 /* Interface:  */
 278 /* Clear a bpstat so that it says we are not at any breakpoint.
 279    Also free any storage that is part of a bpstat.  */
 280 extern void bpstat_clear PARAMS ((bpstat *));
 281
 282 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
 283    is part of the bpstat is copied as well.  */
 284 extern bpstat bpstat_copy PARAMS ((bpstat));
 285
 286 extern bpstat bpstat_stop_status PARAMS ((CORE_ADDR *, int));
 287 \f
 288 /* This bpstat_what stuff tells wait_for_inferior what to do with a
 289    breakpoint (a challenging task).  */
 290
 291 enum bpstat_what_main_action
 292   {
 293     /* Perform various other tests; that is, this bpstat does not
 294        say to perform any action (e.g. failed watchpoint and nothing
 295        else).  */
 296     BPSTAT_WHAT_KEEP_CHECKING,
 297
 298     /* Rather than distinguish between noisy and silent stops here, it
 299        might be cleaner to have bpstat_print make that decision (also
 300        taking into account stop_print_frame and source_only).  But the
 301        implications are a bit scary (interaction with auto-displays, etc.),
 302        so I won't try it.  */
 303
 304     /* Stop silently.  */
 305     BPSTAT_WHAT_STOP_SILENT,
 306
 307     /* Stop and print.  */
 308     BPSTAT_WHAT_STOP_NOISY,
 309
 310     /* Remove breakpoints, single step once, then put them back in and
 311        go back to what we were doing.  It's possible that this should be
 312        removed from the main_action and put into a separate field, to more
 313        cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE.  */
 314     BPSTAT_WHAT_SINGLE,
 315
 316     /* Set longjmp_resume breakpoint, remove all other breakpoints,
 317        and continue.  The "remove all other breakpoints" part is required
 318        if we are also stepping over another breakpoint as well as doing
 319        the longjmp handling.  */
 320     BPSTAT_WHAT_SET_LONGJMP_RESUME,
 321
 322     /* Clear longjmp_resume breakpoint, then handle as
 323        BPSTAT_WHAT_KEEP_CHECKING.  */
 324     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME,
 325
 326     /* Clear longjmp_resume breakpoint, then handle as BPSTAT_WHAT_SINGLE.  */
 327     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE,
 328
 329     /* Clear step resume breakpoint, and keep checking.  */
 330     BPSTAT_WHAT_STEP_RESUME,
 331
 332     /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep
 333        checking.  */
 334     BPSTAT_WHAT_THROUGH_SIGTRAMP,
 335
 336     /* Check the dynamic linker's data structures for new libraries, then
 337        keep checking.  */
 338     BPSTAT_WHAT_CHECK_SHLIBS,
 339
 340     /* Check the dynamic linker's data structures for new libraries, then
 341        resume out of the dynamic linker's callback, stop and print.  */
 342     BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK,
 343
 344     /* This is just used to keep track of how many enums there are.  */
 345     BPSTAT_WHAT_LAST
 346   };
 347
 348 struct bpstat_what
 349   {
 350     enum bpstat_what_main_action main_action;
 351
 352     /* Did we hit a call dummy breakpoint?  This only goes with a main_action
 353        of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
 354        continuing from a call dummy without popping the frame is not a
 355        useful one).  */
 356     int call_dummy;
 357   };
 358
 359 /* Tell what to do about this bpstat.  */
 360 struct bpstat_what bpstat_what PARAMS ((bpstat));
 361 \f
 362 /* Find the bpstat associated with a breakpoint.  NULL otherwise. */
 363 bpstat bpstat_find_breakpoint PARAMS ((bpstat, struct breakpoint *));
 364
 365 /* Find a step_resume breakpoint associated with this bpstat.
 366    (If there are multiple step_resume bp's on the list, this function
 367    will arbitrarily pick one.)
 368
 369    It is an error to use this function if BPSTAT doesn't contain a
 370    step_resume breakpoint.
 371
 372    See wait_for_inferior's use of this function.
 373  */
 374 extern struct breakpoint *
 375   bpstat_find_step_resume_breakpoint PARAMS ((bpstat));
 376
 377 /* Nonzero if a signal that we got in wait() was due to circumstances
 378    explained by the BS.  */
 379 /* Currently that is true if we have hit a breakpoint, or if there is
 380    a watchpoint enabled.  */
 381 #define bpstat_explains_signal(bs) ((bs) != NULL)
 382
 383 /* Nonzero if we should step constantly (e.g. watchpoints on machines
 384    without hardware support).  This isn't related to a specific bpstat,
 385    just to things like whether watchpoints are set.  */
 386 extern int bpstat_should_step PARAMS ((void));
 387
 388 /* Nonzero if there are enabled hardware watchpoints. */
 389 extern int bpstat_have_active_hw_watchpoints PARAMS ((void));
 390
 391 /* Print a message indicating what happened.  Returns nonzero to
 392    say that only the source line should be printed after this (zero
 393    return means print the frame as well as the source line).  */
 394 extern int bpstat_print PARAMS ((bpstat));
 395
 396 /* Return the breakpoint number of the first breakpoint we are stopped
 397    at.  *BSP upon return is a bpstat which points to the remaining
 398    breakpoints stopped at (but which is not guaranteed to be good for
 399    anything but further calls to bpstat_num).
 400    Return 0 if passed a bpstat which does not indicate any breakpoints.  */
 401 extern int bpstat_num PARAMS ((bpstat *));
 402
 403 /* Perform actions associated with having stopped at *BSP.  Actually, we just
 404    use this for breakpoint commands.  Perhaps other actions will go here
 405    later, but this is executed at a late time (from the command loop).  */
 406 extern void bpstat_do_actions PARAMS ((bpstat *));
 407
 408 /* Modify BS so that the actions will not be performed.  */
 409 extern void bpstat_clear_actions PARAMS ((bpstat));
 410
 411 /* Given a bpstat that records zero or more triggered eventpoints, this
 412    function returns another bpstat which contains only the catchpoints
 413    on that first list, if any.
 414  */
 415 extern void bpstat_get_triggered_catchpoints PARAMS ((bpstat, bpstat *));
 416
 417 /* Implementation:  */
 418 struct bpstats
 419   {
 420     /* Linked list because there can be two breakpoints at the
 421        same place, and a bpstat reflects the fact that both have been hit.  */
 422     bpstat next;
 423     /* Breakpoint that we are at.  */
 424     struct breakpoint *breakpoint_at;
 425     /* Commands left to be done.  */
 426     struct command_line *commands;
 427     /* Old value associated with a watchpoint.  */
 428     value_ptr old_val;
 429
 430     /* Nonzero if this breakpoint tells us to print the frame.  */
 431     char print;
 432
 433     /* Nonzero if this breakpoint tells us to stop.  */
 434     char stop;
 435
 436     /* Function called by bpstat_print to print stuff associated with
 437        this element of the bpstat chain.  Returns 0 or 1 just like
 438        bpstat_print, or -1 if it can't deal with it.  */
 439     int (*print_it) PARAMS ((bpstat bs));
 440   };
 441
 442 enum inf_context
 443   {
 444     inf_starting,
 445     inf_running,
 446     inf_exited
 447   };
 448 \f
 449
 450 /* Prototypes for breakpoint-related functions.  */
 451
 452 #ifdef __STDC__                 /* Forward declarations for prototypes */
 453 struct frame_info;
 454 #endif
 455
 456 extern int breakpoint_here_p PARAMS ((CORE_ADDR));
 457
 458 extern int breakpoint_inserted_here_p PARAMS ((CORE_ADDR));
 459
 460 extern int frame_in_dummy PARAMS ((struct frame_info *));
 461
 462 extern int breakpoint_thread_match PARAMS ((CORE_ADDR, int));
 463
 464 extern void until_break_command PARAMS ((char *, int));
 465
 466 extern void breakpoint_re_set PARAMS ((void));
 467
 468 extern void breakpoint_re_set_thread PARAMS ((struct breakpoint *));
 469
 470 extern int ep_is_exception_catchpoint PARAMS ((struct breakpoint *));
 471
 472 extern struct breakpoint *set_momentary_breakpoint
 473   PARAMS ((struct symtab_and_line, struct frame_info *, enum bptype));
 474
 475 extern void set_ignore_count PARAMS ((int, int, int));
 476
 477 extern void set_default_breakpoint PARAMS ((int, CORE_ADDR, struct symtab *, int));
 478
 479 extern void mark_breakpoints_out PARAMS ((void));
 480
 481 extern void breakpoint_init_inferior PARAMS ((enum inf_context));
 482
 483 extern void delete_breakpoint PARAMS ((struct breakpoint *));
 484
 485 extern void breakpoint_auto_delete PARAMS ((bpstat));
 486
 487 extern void breakpoint_clear_ignore_counts PARAMS ((void));
 488
 489 extern void break_command PARAMS ((char *, int));
 490
 491 extern void tbreak_command PARAMS ((char *, int));
 492
 493 extern int insert_breakpoints PARAMS ((void));
 494
 495 extern int remove_breakpoints PARAMS ((void));
 496
 497 /* This function can be used to physically insert eventpoints from the
 498    specified traced inferior process, without modifying the breakpoint
 499    package's state.  This can be useful for those targets which support
 500    following the processes of a fork() or vfork() system call, when both
 501    of the resulting two processes are to be followed.  */
 502 extern int reattach_breakpoints PARAMS ((int));
 503
 504 /* This function can be used to update the breakpoint package's state
 505    after an exec() system call has been executed.
 506
 507    This function causes the following:
 508
 509    - All eventpoints are marked "not inserted".
 510    - All eventpoints with a symbolic address are reset such that
 511    the symbolic address must be reevaluated before the eventpoints
 512    can be reinserted.
 513    - The solib breakpoints are explicitly removed from the breakpoint
 514    list.
 515    - A step-resume breakpoint, if any, is explicitly removed from the
 516    breakpoint list.
 517    - All eventpoints without a symbolic address are removed from the
 518    breakpoint list. */
 519 extern void update_breakpoints_after_exec PARAMS ((void));
 520
 521 /* This function can be used to physically remove hardware breakpoints
 522    and watchpoints from the specified traced inferior process, without
 523    modifying the breakpoint package's state.  This can be useful for
 524    those targets which support following the processes of a fork() or
 525    vfork() system call, when one of the resulting two processes is to
 526    be detached and allowed to run free.
 527
 528    It is an error to use this function on the process whose id is
 529    inferior_pid.  */
 530 extern int detach_breakpoints PARAMS ((int));
 531
 532 extern void enable_longjmp_breakpoint PARAMS ((void));
 533
 534 extern void disable_longjmp_breakpoint PARAMS ((void));
 535
 536 extern void set_longjmp_resume_breakpoint PARAMS ((CORE_ADDR,
 537                                                    struct frame_info *));
 538 /* These functions respectively disable or reenable all currently
 539    enabled watchpoints.  When disabled, the watchpoints are marked
 540    call_disabled.  When reenabled, they are marked enabled.
 541
 542    The intended client of these functions is infcmd.c\run_stack_dummy.
 543
 544    The inferior must be stopped, and all breakpoints removed, when
 545    these functions are used.
 546
 547    The need for these functions is that on some targets (e.g., HP-UX),
 548    gdb is unable to unwind through the dummy frame that is pushed as
 549    part of the implementation of a call command.  Watchpoints can
 550    cause the inferior to stop in places where this frame is visible,
 551    and that can cause execution control to become very confused.
 552
 553    Note that if a user sets breakpoints in an interactively call
 554    function, the call_disabled watchpoints will have been reenabled
 555    when the first such breakpoint is reached.  However, on targets
 556    that are unable to unwind through the call dummy frame, watches
 557    of stack-based storage may then be deleted, because gdb will
 558    believe that their watched storage is out of scope.  (Sigh.) */
 559 extern void
 560 disable_watchpoints_before_interactive_call_start PARAMS ((void));
 561
 562 extern void
 563 enable_watchpoints_after_interactive_call_stop PARAMS ((void));
 564
 565
 566 extern void clear_breakpoint_hit_counts PARAMS ((void));
 567
 568 /* The following are for displays, which aren't really breakpoints, but
 569    here is as good a place as any for them.  */
 570
 571 extern void disable_current_display PARAMS ((void));
 572
 573 extern void do_displays PARAMS ((void));
 574
 575 extern void disable_display PARAMS ((int));
 576
 577 extern void clear_displays PARAMS ((void));
 578
 579 extern void disable_breakpoint PARAMS ((struct breakpoint *));
 580
 581 extern void enable_breakpoint PARAMS ((struct breakpoint *));
 582
 583 extern void create_solib_event_breakpoint PARAMS ((CORE_ADDR));
 584
 585 extern void remove_solib_event_breakpoints PARAMS ((void));
 586
 587 extern void disable_breakpoints_in_shlibs PARAMS ((int silent));
 588
 589 extern void re_enable_breakpoints_in_shlibs PARAMS ((void));
 590
 591 extern void create_solib_load_event_breakpoint PARAMS ((char *, int, char *, char *));
 592
 593 extern void create_solib_unload_event_breakpoint PARAMS ((char *, int, char *, char *));
 594
 595 extern void create_fork_event_catchpoint PARAMS ((int, char *));
 596
 597 extern void create_vfork_event_catchpoint PARAMS ((int, char *));
 598
 599 extern void create_exec_event_catchpoint PARAMS ((int, char *));
 600
 601 /* This function returns TRUE if ep is a catchpoint. */
 602 extern int ep_is_catchpoint PARAMS ((struct breakpoint *));
 603
 604 /* This function returns TRUE if ep is a catchpoint of a
 605    shared library (aka dynamically-linked library) event,
 606    such as a library load or unload. */
 607 extern int ep_is_shlib_catchpoint PARAMS ((struct breakpoint *));
 608
 609 extern struct breakpoint *set_breakpoint_sal PARAMS ((struct symtab_and_line));
 610
 611 #endif /* !defined (BREAKPOINT_H) */