gdb/breakpoint.h

   1 /* Data structures associated with breakpoints in GDB.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3    2002, 2003, 2004
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #if !defined (BREAKPOINT_H)
  24 #define BREAKPOINT_H 1
  25
  26 #include "frame.h"
  27 #include "value.h"
  28
  29 #include "gdb-events.h"
  30
  31 struct value;
  32 struct block;
  33
  34 /* This is the maximum number of bytes a breakpoint instruction can take.
  35    Feel free to increase it.  It's just used in a few places to size
  36    arrays that should be independent of the target architecture.  */
  37
  38 #define BREAKPOINT_MAX  16
  39 \f
  40 /* Type of breakpoint. */
  41 /* FIXME In the future, we should fold all other breakpoint-like things into
  42    here.  This includes:
  43
  44    * single-step (for machines where we have to simulate single stepping)
  45    (probably, though perhaps it is better for it to look as much as
  46    possible like a single-step to wait_for_inferior).  */
  47
  48 enum bptype
  49   {
  50     bp_none = 0,                /* Eventpoint has been deleted. */
  51     bp_breakpoint,              /* Normal breakpoint */
  52     bp_hardware_breakpoint,     /* Hardware assisted breakpoint */
  53     bp_until,                   /* used by until command */
  54     bp_finish,                  /* used by finish command */
  55     bp_watchpoint,              /* Watchpoint */
  56     bp_hardware_watchpoint,     /* Hardware assisted watchpoint */
  57     bp_read_watchpoint,         /* read watchpoint, (hardware assisted) */
  58     bp_access_watchpoint,       /* access watchpoint, (hardware assisted) */
  59     bp_longjmp,                 /* secret breakpoint to find longjmp() */
  60     bp_longjmp_resume,          /* secret breakpoint to escape longjmp() */
  61
  62     /* Used by wait_for_inferior for stepping over subroutine calls, for
  63        stepping over signal handlers, and for skipping prologues.  */
  64     bp_step_resume,
  65
  66     /* Used by wait_for_inferior for stepping over signal handlers.  */
  67     bp_through_sigtramp,
  68
  69     /* Used to detect when a watchpoint expression has gone out of
  70        scope.  These breakpoints are usually not visible to the user.
  71
  72        This breakpoint has some interesting properties:
  73
  74        1) There's always a 1:1 mapping between watchpoints
  75        on local variables and watchpoint_scope breakpoints.
  76
  77        2) It automatically deletes itself and the watchpoint it's
  78        associated with when hit.
  79
  80        3) It can never be disabled.  */
  81     bp_watchpoint_scope,
  82
  83     /* The breakpoint at the end of a call dummy.  */
  84     /* FIXME: What if the function we are calling longjmp()s out of the
  85        call, or the user gets out with the "return" command?  We currently
  86        have no way of cleaning up the breakpoint in these (obscure) situations.
  87        (Probably can solve this by noticing longjmp, "return", etc., it's
  88        similar to noticing when a watchpoint on a local variable goes out
  89        of scope (with hardware support for watchpoints)).  */
  90     bp_call_dummy,
  91
  92     /* Some dynamic linkers (HP, maybe Solaris) can arrange for special
  93        code in the inferior to run when significant events occur in the
  94        dynamic linker (for example a library is loaded or unloaded).
  95
  96        By placing a breakpoint in this magic code GDB will get control
  97        when these significant events occur.  GDB can then re-examine
  98        the dynamic linker's data structures to discover any newly loaded
  99        dynamic libraries.  */
 100     bp_shlib_event,
 101
 102     /* Some multi-threaded systems can arrange for a location in the
 103        inferior to be executed when certain thread-related events occur
 104        (such as thread creation or thread death).
 105
 106        By placing a breakpoint at one of these locations, GDB will get
 107        control when these events occur.  GDB can then update its thread
 108        lists etc.  */
 109
 110     bp_thread_event,
 111
 112     /* On the same principal, an overlay manager can arrange to call a
 113        magic location in the inferior whenever there is an interesting
 114        change in overlay status.  GDB can update its overlay tables
 115        and fiddle with breakpoints in overlays when this breakpoint
 116        is hit.  */
 117
 118     bp_overlay_event,
 119
 120     /* These breakpoints are used to implement the "catch load" command
 121        on platforms whose dynamic linkers support such functionality.  */
 122     bp_catch_load,
 123
 124     /* These breakpoints are used to implement the "catch unload" command
 125        on platforms whose dynamic linkers support such functionality.  */
 126     bp_catch_unload,
 127
 128     /* These are not really breakpoints, but are catchpoints that
 129        implement the "catch fork", "catch vfork" and "catch exec" commands
 130        on platforms whose kernel support such functionality.  (I.e.,
 131        kernels which can raise an event when a fork or exec occurs, as
 132        opposed to the debugger setting breakpoints on functions named
 133        "fork" or "exec".) */
 134     bp_catch_fork,
 135     bp_catch_vfork,
 136     bp_catch_exec,
 137
 138     /* These are catchpoints to implement "catch catch" and "catch throw"
 139        commands for C++ exception handling. */
 140     bp_catch_catch,
 141     bp_catch_throw
 142
 143
 144   };
 145
 146 /* States of enablement of breakpoint. */
 147
 148 enum enable_state
 149   {
 150     bp_disabled,        /* The eventpoint is inactive, and cannot trigger. */
 151     bp_enabled,         /* The eventpoint is active, and can trigger. */
 152     bp_shlib_disabled,  /* The eventpoint's address is in an unloaded solib.
 153                            The eventpoint will be automatically enabled
 154                            and reset when that solib is loaded. */
 155     bp_call_disabled,   /* The eventpoint has been disabled while a call
 156                            into the inferior is "in flight", because some
 157                            eventpoints interfere with the implementation of
 158                            a call on some targets.  The eventpoint will be
 159                            automatically enabled and reset when the call
 160                            "lands" (either completes, or stops at another
 161                            eventpoint). */
 162     bp_permanent        /* There is a breakpoint instruction hard-wired into
 163                            the target's code.  Don't try to write another
 164                            breakpoint instruction on top of it, or restore
 165                            its value.  Step over it using the architecture's
 166                            SKIP_INSN macro.  */
 167   };
 168
 169
 170 /* Disposition of breakpoint.  Ie: what to do after hitting it. */
 171
 172 enum bpdisp
 173   {
 174     disp_del,                   /* Delete it */
 175     disp_del_at_next_stop,      /* Delete at next stop, whether hit or not */
 176     disp_disable,               /* Disable it */
 177     disp_donttouch              /* Leave it alone */
 178   };
 179
 180 enum target_hw_bp_type
 181   {
 182     hw_write   = 0,             /* Common  HW watchpoint */
 183     hw_read    = 1,             /* Read    HW watchpoint */
 184     hw_access  = 2,             /* Access  HW watchpoint */
 185     hw_execute = 3              /* Execute HW breakpoint */
 186   };
 187
 188
 189 /* Information used by targets to insert and remove breakpoints.  */
 190
 191 struct bp_target_info
 192 {
 193   /* Address at which the breakpoint was placed.  This is normally the
 194      same as ADDRESS from the bp_location, except when adjustment
 195      happens in BREAKPOINT_FROM_PC.  The most common form of
 196      adjustment is stripping an alternate ISA marker from the PC which
 197      is used to determine the type of breakpoint to insert.  */
 198   CORE_ADDR placed_address;
 199
 200   /* If the breakpoint lives in memory and reading that memory would
 201      give back the breakpoint, instead of the original contents, then
 202      the original contents are cached here.  Only SHADOW_LEN bytes of
 203      this buffer are valid, and only when the breakpoint is inserted.  */
 204   gdb_byte shadow_contents[BREAKPOINT_MAX];
 205
 206   /* The length of the data cached in SHADOW_CONTENTS.  */
 207   int shadow_len;
 208
 209   /* The size of the placed breakpoint, according to
 210      BREAKPOINT_FROM_PC, when the breakpoint was inserted.  This is
 211      generally the same as SHADOW_LEN, unless we did not need
 212      to read from the target to implement the memory breakpoint
 213      (e.g. if a remote stub handled the details).  We may still
 214      need the size to remove the breakpoint safely.  */
 215   int placed_size;
 216 };
 217
 218 /* GDB maintains two types of information about each breakpoint (or
 219    watchpoint, or other related event).  The first type corresponds
 220    to struct breakpoint; this is a relatively high-level structure
 221    which contains the source location(s), stopping conditions, user
 222    commands to execute when the breakpoint is hit, and so forth.
 223
 224    The second type of information corresponds to struct bp_location.
 225    Each breakpoint has one or (eventually) more locations associated
 226    with it, which represent target-specific and machine-specific
 227    mechanisms for stopping the program.  For instance, a watchpoint
 228    expression may require multiple hardware watchpoints in order to
 229    catch all changes in the value of the expression being watched.  */
 230
 231 enum bp_loc_type
 232 {
 233   bp_loc_software_breakpoint,
 234   bp_loc_hardware_breakpoint,
 235   bp_loc_hardware_watchpoint,
 236   bp_loc_other                  /* Miscellaneous...  */
 237 };
 238
 239 struct bp_location
 240 {
 241   /* Chain pointer to the next breakpoint location.  */
 242   struct bp_location *next;
 243
 244   /* Type of this breakpoint location.  */
 245   enum bp_loc_type loc_type;
 246
 247   /* Each breakpoint location must belong to exactly one higher-level
 248      breakpoint.  This and the DUPLICATE flag are more straightforward
 249      than reference counting.  */
 250   struct breakpoint *owner;
 251
 252   /* Nonzero if this breakpoint is now inserted.  */
 253   char inserted;
 254
 255   /* Nonzero if this is not the first breakpoint in the list
 256      for the given address.  */
 257   char duplicate;
 258
 259   /* If we someday support real thread-specific breakpoints, then
 260      the breakpoint location will need a thread identifier.  */
 261
 262   /* Data for specific breakpoint types.  These could be a union, but
 263      simplicity is more important than memory usage for breakpoints.  */
 264
 265   /* Note that zero is a perfectly valid code address on some platforms
 266      (for example, the mn10200 (OBSOLETE) and mn10300 simulators).  NULL
 267      is not a special value for this field.  Valid for all types except
 268      bp_loc_other.  */
 269   CORE_ADDR address;
 270
 271   /* For any breakpoint type with an address, this is the BFD section
 272      associated with the address.  Used primarily for overlay debugging.  */
 273   asection *section;
 274
 275   /* Address at which breakpoint was requested, either by the user or
 276      by GDB for internal breakpoints.  This will usually be the same
 277      as ``address'' (above) except for cases in which
 278      ADJUST_BREAKPOINT_ADDRESS has computed a different address at
 279      which to place the breakpoint in order to comply with a
 280      processor's architectual constraints.  */
 281   CORE_ADDR requested_address;
 282
 283   /* Details of the placed breakpoint, when inserted.  */
 284   struct bp_target_info target_info;
 285
 286   /* Similarly, for the breakpoint at an overlay's LMA, if necessary.  */
 287   struct bp_target_info overlay_target_info;
 288 };
 289
 290 /* This structure is a collection of function pointers that, if available,
 291    will be called instead of the performing the default action for this
 292    bptype.  */
 293
 294 struct breakpoint_ops
 295 {
 296   /* The normal print routine for this breakpoint, called when we
 297      hit it.  */
 298   enum print_stop_action (*print_it) (struct breakpoint *);
 299
 300   /* Display information about this breakpoint, for "info breakpoints".  */
 301   void (*print_one) (struct breakpoint *, CORE_ADDR *);
 302
 303   /* Display information about this breakpoint after setting it (roughly
 304      speaking; this is called from "mention").  */
 305   void (*print_mention) (struct breakpoint *);
 306 };
 307
 308 /* Note that the ->silent field is not currently used by any commands
 309    (though the code is in there if it was to be, and set_raw_breakpoint
 310    does set it to 0).  I implemented it because I thought it would be
 311    useful for a hack I had to put in; I'm going to leave it in because
 312    I can see how there might be times when it would indeed be useful */
 313
 314 /* This is for a breakpoint or a watchpoint.  */
 315
 316 struct breakpoint
 317   {
 318     struct breakpoint *next;
 319     /* Type of breakpoint. */
 320     enum bptype type;
 321     /* Zero means disabled; remember the info but don't break here.  */
 322     enum enable_state enable_state;
 323     /* What to do with this breakpoint after we hit it. */
 324     enum bpdisp disposition;
 325     /* Number assigned to distinguish breakpoints.  */
 326     int number;
 327
 328     /* Location(s) associated with this high-level breakpoint.  */
 329     struct bp_location *loc;
 330
 331     /* Line number of this address.  */
 332
 333     int line_number;
 334
 335     /* Source file name of this address.  */
 336
 337     char *source_file;
 338
 339     /* Non-zero means a silent breakpoint (don't print frame info
 340        if we stop here). */
 341     unsigned char silent;
 342     /* Number of stops at this breakpoint that should
 343        be continued automatically before really stopping.  */
 344     int ignore_count;
 345     /* Chain of command lines to execute when this breakpoint is hit.  */
 346     struct command_line *commands;
 347     /* Stack depth (address of frame).  If nonzero, break only if fp
 348        equals this.  */
 349     struct frame_id frame_id;
 350     /* Conditional.  Break only if this expression's value is nonzero.  */
 351     struct expression *cond;
 352
 353     /* String we used to set the breakpoint (malloc'd).  */
 354     char *addr_string;
 355     /* Language we used to set the breakpoint.  */
 356     enum language language;
 357     /* Input radix we used to set the breakpoint.  */
 358     int input_radix;
 359     /* String form of the breakpoint condition (malloc'd), or NULL if there
 360        is no condition.  */
 361     char *cond_string;
 362     /* String form of exp (malloc'd), or NULL if none.  */
 363     char *exp_string;
 364
 365     /* The expression we are watching, or NULL if not a watchpoint.  */
 366     struct expression *exp;
 367     /* The largest block within which it is valid, or NULL if it is
 368        valid anywhere (e.g. consists just of global symbols).  */
 369     struct block *exp_valid_block;
 370     /* Value of the watchpoint the last time we checked it.  */
 371     struct value *val;
 372
 373     /* Holds the value chain for a hardware watchpoint expression.  */
 374     struct value *val_chain;
 375
 376     /* Holds the address of the related watchpoint_scope breakpoint
 377        when using watchpoints on local variables (might the concept
 378        of a related breakpoint be useful elsewhere, if not just call
 379        it the watchpoint_scope breakpoint or something like that. FIXME).  */
 380     struct breakpoint *related_breakpoint;
 381
 382     /* Holds the frame address which identifies the frame this
 383        watchpoint should be evaluated in, or `null' if the watchpoint
 384        should be evaluated on the outermost frame.  */
 385     struct frame_id watchpoint_frame;
 386
 387     /* Thread number for thread-specific breakpoint, or -1 if don't care */
 388     int thread;
 389
 390     /* Count of the number of times this breakpoint was taken, dumped
 391        with the info, but not used for anything else.  Useful for
 392        seeing how many times you hit a break prior to the program
 393        aborting, so you can back up to just before the abort.  */
 394     int hit_count;
 395
 396     /* Filename of a dynamically-linked library (dll), used for
 397        bp_catch_load and bp_catch_unload (malloc'd), or NULL if any
 398        library is significant.  */
 399     char *dll_pathname;
 400
 401     /* Filename of a dll whose state change (e.g., load or unload)
 402        triggered this catchpoint.  This field is only valid immediately
 403        after this catchpoint has triggered.  */
 404     char *triggered_dll_pathname;
 405
 406     /* Process id of a child process whose forking triggered this
 407        catchpoint.  This field is only valid immediately after this
 408        catchpoint has triggered.  */
 409     int forked_inferior_pid;
 410
 411     /* Filename of a program whose exec triggered this catchpoint.
 412        This field is only valid immediately after this catchpoint has
 413        triggered.  */
 414     char *exec_pathname;
 415
 416     /* Methods associated with this breakpoint.  */
 417     struct breakpoint_ops *ops;
 418
 419     /* Was breakpoint issued from a tty?  Saved for the use of pending breakpoints.  */
 420     int from_tty;
 421
 422     /* Flag value for pending breakpoint.
 423        first bit  : 0 non-temporary, 1 temporary.
 424        second bit : 0 normal breakpoint, 1 hardware breakpoint. */
 425     int flag;
 426
 427     /* Is breakpoint pending on shlib loads?  */
 428     int pending;
 429   };
 430 \f
 431 /* The following stuff is an abstract data type "bpstat" ("breakpoint
 432    status").  This provides the ability to determine whether we have
 433    stopped at a breakpoint, and what we should do about it.  */
 434
 435 typedef struct bpstats *bpstat;
 436
 437 /* Interface:  */
 438 /* Clear a bpstat so that it says we are not at any breakpoint.
 439    Also free any storage that is part of a bpstat.  */
 440 extern void bpstat_clear (bpstat *);
 441
 442 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
 443    is part of the bpstat is copied as well.  */
 444 extern bpstat bpstat_copy (bpstat);
 445
 446 extern bpstat bpstat_stop_status (CORE_ADDR pc, ptid_t ptid,
 447                                   int stopped_by_watchpoint);
 448 \f
 449 /* This bpstat_what stuff tells wait_for_inferior what to do with a
 450    breakpoint (a challenging task).  */
 451
 452 enum bpstat_what_main_action
 453   {
 454     /* Perform various other tests; that is, this bpstat does not
 455        say to perform any action (e.g. failed watchpoint and nothing
 456        else).  */
 457     BPSTAT_WHAT_KEEP_CHECKING,
 458
 459     /* Rather than distinguish between noisy and silent stops here, it
 460        might be cleaner to have bpstat_print make that decision (also
 461        taking into account stop_print_frame and source_only).  But the
 462        implications are a bit scary (interaction with auto-displays, etc.),
 463        so I won't try it.  */
 464
 465     /* Stop silently.  */
 466     BPSTAT_WHAT_STOP_SILENT,
 467
 468     /* Stop and print.  */
 469     BPSTAT_WHAT_STOP_NOISY,
 470
 471     /* Remove breakpoints, single step once, then put them back in and
 472        go back to what we were doing.  It's possible that this should be
 473        removed from the main_action and put into a separate field, to more
 474        cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE.  */
 475     BPSTAT_WHAT_SINGLE,
 476
 477     /* Set longjmp_resume breakpoint, remove all other breakpoints,
 478        and continue.  The "remove all other breakpoints" part is required
 479        if we are also stepping over another breakpoint as well as doing
 480        the longjmp handling.  */
 481     BPSTAT_WHAT_SET_LONGJMP_RESUME,
 482
 483     /* Clear longjmp_resume breakpoint, then handle as
 484        BPSTAT_WHAT_KEEP_CHECKING.  */
 485     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME,
 486
 487     /* Clear longjmp_resume breakpoint, then handle as BPSTAT_WHAT_SINGLE.  */
 488     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE,
 489
 490     /* Clear step resume breakpoint, and keep checking.  */
 491     BPSTAT_WHAT_STEP_RESUME,
 492
 493     /* Clear through_sigtramp breakpoint, muck with trap_expected, and keep
 494        checking.  */
 495     BPSTAT_WHAT_THROUGH_SIGTRAMP,
 496
 497     /* Check the dynamic linker's data structures for new libraries, then
 498        keep checking.  */
 499     BPSTAT_WHAT_CHECK_SHLIBS,
 500
 501     /* Check the dynamic linker's data structures for new libraries, then
 502        resume out of the dynamic linker's callback, stop and print.  */
 503     BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK,
 504
 505     /* This is just used to keep track of how many enums there are.  */
 506     BPSTAT_WHAT_LAST
 507   };
 508
 509 struct bpstat_what
 510   {
 511     enum bpstat_what_main_action main_action;
 512
 513     /* Did we hit a call dummy breakpoint?  This only goes with a main_action
 514        of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
 515        continuing from a call dummy without popping the frame is not a
 516        useful one).  */
 517     int call_dummy;
 518   };
 519
 520 /* The possible return values for print_bpstat, print_it_normal,
 521    print_it_done, print_it_noop. */
 522 enum print_stop_action
 523   {
 524     PRINT_UNKNOWN = -1,
 525     PRINT_SRC_AND_LOC,
 526     PRINT_SRC_ONLY,
 527     PRINT_NOTHING
 528   };
 529
 530 /* Tell what to do about this bpstat.  */
 531 struct bpstat_what bpstat_what (bpstat);
 532 \f
 533 /* Find the bpstat associated with a breakpoint.  NULL otherwise. */
 534 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
 535
 536 /* Find a step_resume breakpoint associated with this bpstat.
 537    (If there are multiple step_resume bp's on the list, this function
 538    will arbitrarily pick one.)
 539
 540    It is an error to use this function if BPSTAT doesn't contain a
 541    step_resume breakpoint.
 542
 543    See wait_for_inferior's use of this function.
 544  */
 545 extern struct breakpoint *bpstat_find_step_resume_breakpoint (bpstat);
 546
 547 /* Nonzero if a signal that we got in wait() was due to circumstances
 548    explained by the BS.  */
 549 /* Currently that is true if we have hit a breakpoint, or if there is
 550    a watchpoint enabled.  */
 551 #define bpstat_explains_signal(bs) ((bs) != NULL)
 552
 553 /* Nonzero if we should step constantly (e.g. watchpoints on machines
 554    without hardware support).  This isn't related to a specific bpstat,
 555    just to things like whether watchpoints are set.  */
 556 extern int bpstat_should_step (void);
 557
 558 /* Nonzero if there are enabled hardware watchpoints. */
 559 extern int bpstat_have_active_hw_watchpoints (void);
 560
 561 /* Print a message indicating what happened.  Returns nonzero to
 562    say that only the source line should be printed after this (zero
 563    return means print the frame as well as the source line).  */
 564 extern enum print_stop_action bpstat_print (bpstat);
 565
 566 /* Return the breakpoint number of the first breakpoint we are stopped
 567    at.  *BSP upon return is a bpstat which points to the remaining
 568    breakpoints stopped at (but which is not guaranteed to be good for
 569    anything but further calls to bpstat_num).
 570    Return 0 if passed a bpstat which does not indicate any breakpoints.  */
 571 extern int bpstat_num (bpstat *);
 572
 573 /* Perform actions associated with having stopped at *BSP.  Actually, we just
 574    use this for breakpoint commands.  Perhaps other actions will go here
 575    later, but this is executed at a late time (from the command loop).  */
 576 extern void bpstat_do_actions (bpstat *);
 577
 578 /* Modify BS so that the actions will not be performed.  */
 579 extern void bpstat_clear_actions (bpstat);
 580
 581 /* Given a bpstat that records zero or more triggered eventpoints, this
 582    function returns another bpstat which contains only the catchpoints
 583    on that first list, if any.
 584  */
 585 extern void bpstat_get_triggered_catchpoints (bpstat, bpstat *);
 586
 587 /* Implementation:  */
 588
 589 /* Values used to tell the printing routine how to behave for this bpstat. */
 590 enum bp_print_how
 591   {
 592     /* This is used when we want to do a normal printing of the reason
 593        for stopping. The output will depend on the type of eventpoint
 594        we are dealing with. This is the default value, most commonly
 595        used. */
 596     print_it_normal,
 597     /* This is used when nothing should be printed for this bpstat entry.  */
 598     print_it_noop,
 599     /* This is used when everything which needs to be printed has
 600        already been printed.  But we still want to print the frame.  */
 601     print_it_done
 602   };
 603
 604 struct bpstats
 605   {
 606     /* Linked list because there can be two breakpoints at the same
 607        place, and a bpstat reflects the fact that both have been hit.  */
 608     bpstat next;
 609     /* Breakpoint that we are at.  */
 610     struct breakpoint *breakpoint_at;
 611     /* Commands left to be done.  */
 612     struct command_line *commands;
 613     /* Old value associated with a watchpoint.  */
 614     struct value *old_val;
 615
 616     /* Nonzero if this breakpoint tells us to print the frame.  */
 617     char print;
 618
 619     /* Nonzero if this breakpoint tells us to stop.  */
 620     char stop;
 621
 622     /* Tell bpstat_print and print_bp_stop_message how to print stuff
 623        associated with this element of the bpstat chain.  */
 624     enum bp_print_how print_it;
 625   };
 626
 627 enum inf_context
 628   {
 629     inf_starting,
 630     inf_running,
 631     inf_exited
 632   };
 633
 634 /* The possible return values for breakpoint_here_p.
 635    We guarantee that zero always means "no breakpoint here".  */
 636 enum breakpoint_here
 637   {
 638     no_breakpoint_here = 0,
 639     ordinary_breakpoint_here,
 640     permanent_breakpoint_here
 641   };
 642 \f
 643
 644 /* Prototypes for breakpoint-related functions.  */
 645
 646 extern enum breakpoint_here breakpoint_here_p (CORE_ADDR);
 647
 648 extern int breakpoint_inserted_here_p (CORE_ADDR);
 649
 650 extern int software_breakpoint_inserted_here_p (CORE_ADDR);
 651
 652 extern int breakpoint_thread_match (CORE_ADDR, ptid_t);
 653
 654 extern void until_break_command (char *, int, int);
 655
 656 extern void breakpoint_re_set (void);
 657
 658 extern void breakpoint_re_set_thread (struct breakpoint *);
 659
 660 extern int ep_is_exception_catchpoint (struct breakpoint *);
 661
 662 extern struct breakpoint *set_momentary_breakpoint
 663   (struct symtab_and_line, struct frame_id, enum bptype);
 664
 665 extern void set_ignore_count (int, int, int);
 666
 667 extern void set_default_breakpoint (int, CORE_ADDR, struct symtab *, int);
 668
 669 extern void mark_breakpoints_out (void);
 670
 671 extern void breakpoint_init_inferior (enum inf_context);
 672
 673 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
 674
 675 extern struct cleanup *make_exec_cleanup_delete_breakpoint (struct breakpoint *);
 676
 677 extern void delete_breakpoint (struct breakpoint *);
 678
 679 extern void breakpoint_auto_delete (bpstat);
 680
 681 extern void breakpoint_clear_ignore_counts (void);
 682
 683 extern void break_command (char *, int);
 684
 685 extern void hbreak_command_wrapper (char *, int);
 686 extern void thbreak_command_wrapper (char *, int);
 687 extern void rbreak_command_wrapper (char *, int);
 688 extern void watch_command_wrapper (char *, int);
 689 extern void awatch_command_wrapper (char *, int);
 690 extern void rwatch_command_wrapper (char *, int);
 691 extern void tbreak_command (char *, int);
 692
 693 extern int insert_breakpoints (void);
 694
 695 extern int remove_breakpoints (void);
 696
 697 /* This function can be used to physically insert eventpoints from the
 698    specified traced inferior process, without modifying the breakpoint
 699    package's state.  This can be useful for those targets which support
 700    following the processes of a fork() or vfork() system call, when both
 701    of the resulting two processes are to be followed.  */
 702 extern int reattach_breakpoints (int);
 703
 704 /* This function can be used to update the breakpoint package's state
 705    after an exec() system call has been executed.
 706
 707    This function causes the following:
 708
 709    - All eventpoints are marked "not inserted".
 710    - All eventpoints with a symbolic address are reset such that
 711    the symbolic address must be reevaluated before the eventpoints
 712    can be reinserted.
 713    - The solib breakpoints are explicitly removed from the breakpoint
 714    list.
 715    - A step-resume breakpoint, if any, is explicitly removed from the
 716    breakpoint list.
 717    - All eventpoints without a symbolic address are removed from the
 718    breakpoint list. */
 719 extern void update_breakpoints_after_exec (void);
 720
 721 /* This function can be used to physically remove hardware breakpoints
 722    and watchpoints from the specified traced inferior process, without
 723    modifying the breakpoint package's state.  This can be useful for
 724    those targets which support following the processes of a fork() or
 725    vfork() system call, when one of the resulting two processes is to
 726    be detached and allowed to run free.
 727
 728    It is an error to use this function on the process whose id is
 729    inferior_ptid.  */
 730 extern int detach_breakpoints (int);
 731
 732 extern void enable_longjmp_breakpoint (void);
 733 extern void disable_longjmp_breakpoint (void);
 734 extern void enable_overlay_breakpoints (void);
 735 extern void disable_overlay_breakpoints (void);
 736
 737 extern void set_longjmp_resume_breakpoint (CORE_ADDR, struct frame_id);
 738 /* These functions respectively disable or reenable all currently
 739    enabled watchpoints.  When disabled, the watchpoints are marked
 740    call_disabled.  When reenabled, they are marked enabled.
 741
 742    The intended client of these functions is call_function_by_hand.
 743
 744    The inferior must be stopped, and all breakpoints removed, when
 745    these functions are used.
 746
 747    The need for these functions is that on some targets (e.g., HP-UX),
 748    gdb is unable to unwind through the dummy frame that is pushed as
 749    part of the implementation of a call command.  Watchpoints can
 750    cause the inferior to stop in places where this frame is visible,
 751    and that can cause execution control to become very confused.
 752
 753    Note that if a user sets breakpoints in an interactively called
 754    function, the call_disabled watchpoints will have been reenabled
 755    when the first such breakpoint is reached.  However, on targets
 756    that are unable to unwind through the call dummy frame, watches
 757    of stack-based storage may then be deleted, because gdb will
 758    believe that their watched storage is out of scope.  (Sigh.) */
 759 extern void disable_watchpoints_before_interactive_call_start (void);
 760
 761 extern void enable_watchpoints_after_interactive_call_stop (void);
 762
 763
 764 extern void clear_breakpoint_hit_counts (void);
 765
 766 extern int get_number (char **);
 767
 768 extern int get_number_or_range (char **);
 769
 770 /* The following are for displays, which aren't really breakpoints, but
 771    here is as good a place as any for them.  */
 772
 773 extern void disable_current_display (void);
 774
 775 extern void do_displays (void);
 776
 777 extern void disable_display (int);
 778
 779 extern void clear_displays (void);
 780
 781 extern void disable_breakpoint (struct breakpoint *);
 782
 783 extern void enable_breakpoint (struct breakpoint *);
 784
 785 extern void make_breakpoint_permanent (struct breakpoint *);
 786
 787 extern struct breakpoint *create_solib_event_breakpoint (CORE_ADDR);
 788
 789 extern struct breakpoint *create_thread_event_breakpoint (CORE_ADDR);
 790
 791 extern void remove_solib_event_breakpoints (void);
 792
 793 extern void remove_thread_event_breakpoints (void);
 794
 795 extern void disable_breakpoints_in_shlibs (int silent);
 796
 797 extern void re_enable_breakpoints_in_shlibs (void);
 798
 799 extern void create_solib_load_event_breakpoint (char *, int, char *, char *);
 800
 801 extern void create_solib_unload_event_breakpoint (char *, int,
 802                                                   char *, char *);
 803
 804 extern void create_fork_event_catchpoint (int, char *);
 805
 806 extern void create_vfork_event_catchpoint (int, char *);
 807
 808 extern void create_exec_event_catchpoint (int, char *);
 809
 810 /* This function returns TRUE if ep is a catchpoint. */
 811 extern int ep_is_catchpoint (struct breakpoint *);
 812
 813 /* This function returns TRUE if ep is a catchpoint of a
 814    shared library (aka dynamically-linked library) event,
 815    such as a library load or unload. */
 816 extern int ep_is_shlib_catchpoint (struct breakpoint *);
 817
 818 extern struct breakpoint *set_breakpoint_sal (struct symtab_and_line);
 819
 820 /* Enable breakpoints and delete when hit.  Called with ARG == NULL
 821    deletes all breakpoints. */
 822 extern void delete_command (char *arg, int from_tty);
 823
 824 /* Pull all H/W watchpoints from the target. Return non-zero if the
 825    remove fails. */
 826 extern int remove_hw_watchpoints (void);
 827
 828 /* Manage a software single step breakpoint (or two).  Insert may be called
 829    twice before remove is called.  */
 830 extern void insert_single_step_breakpoint (CORE_ADDR);
 831 extern void remove_single_step_breakpoints (void);
 832
 833 /* Manage manual breakpoints, separate from the normal chain of
 834    breakpoints.  These functions are used in murky target-specific
 835    ways.  Please do not add more uses!  */
 836 extern void *deprecated_insert_raw_breakpoint (CORE_ADDR);
 837 extern int deprecated_remove_raw_breakpoint (void *);
 838
 839 /* Indicator of whether exception catchpoints should be nuked between
 840    runs of a program.  */
 841 extern int deprecated_exception_catchpoints_are_fragile;
 842
 843 /* Indicator of when exception catchpoints set-up should be
 844    reinitialized -- e.g. when program is re-run.  */
 845 extern int deprecated_exception_support_initialized;
 846
 847 #endif /* !defined (BREAKPOINT_H) */