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