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