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, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #if !defined (BREAKPOINT_H)
  21 #define BREAKPOINT_H 1
  22
  23 #include "frame.h"
  24 #include "value.h"
  25 #include "vec.h"
  26
  27 struct value;
  28 struct block;
  29 struct breakpoint_object;
  30
  31 /* This is the maximum number of bytes a breakpoint instruction can take.
  32    Feel free to increase it.  It's just used in a few places to size
  33    arrays that should be independent of the target architecture.  */
  34
  35 #define BREAKPOINT_MAX  16
  36 \f
  37
  38 /* Type of breakpoint.  */
  39 /* FIXME In the future, we should fold all other breakpoint-like things into
  40    here.  This includes:
  41
  42    * single-step (for machines where we have to simulate single stepping)
  43    (probably, though perhaps it is better for it to look as much as
  44    possible like a single-step to wait_for_inferior).  */
  45
  46 enum bptype
  47   {
  48     bp_none = 0,                /* Eventpoint has been deleted. */
  49     bp_breakpoint,              /* Normal breakpoint */
  50     bp_hardware_breakpoint,     /* Hardware assisted breakpoint */
  51     bp_until,                   /* used by until command */
  52     bp_finish,                  /* used by finish command */
  53     bp_watchpoint,              /* Watchpoint */
  54     bp_hardware_watchpoint,     /* Hardware assisted watchpoint */
  55     bp_read_watchpoint,         /* read watchpoint, (hardware assisted) */
  56     bp_access_watchpoint,       /* access watchpoint, (hardware assisted) */
  57     bp_longjmp,                 /* secret breakpoint to find longjmp() */
  58     bp_longjmp_resume,          /* secret breakpoint to escape longjmp() */
  59
  60     /* Used by wait_for_inferior for stepping over subroutine calls, for
  61        stepping over signal handlers, and for skipping prologues.  */
  62     bp_step_resume,
  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     /* A breakpoint set on std::terminate, that is used to catch
  88        otherwise uncaught exceptions thrown during an inferior call.  */
  89     bp_std_terminate,
  90
  91     /* Some dynamic linkers (HP, maybe Solaris) can arrange for special
  92        code in the inferior to run when significant events occur in the
  93        dynamic linker (for example a library is loaded or unloaded).
  94
  95        By placing a breakpoint in this magic code GDB will get control
  96        when these significant events occur.  GDB can then re-examine
  97        the dynamic linker's data structures to discover any newly loaded
  98        dynamic libraries.  */
  99     bp_shlib_event,
 100
 101     /* Some multi-threaded systems can arrange for a location in the
 102        inferior to be executed when certain thread-related events occur
 103        (such as thread creation or thread death).
 104
 105        By placing a breakpoint at one of these locations, GDB will get
 106        control when these events occur.  GDB can then update its thread
 107        lists etc.  */
 108
 109     bp_thread_event,
 110
 111     /* On the same principal, an overlay manager can arrange to call a
 112        magic location in the inferior whenever there is an interesting
 113        change in overlay status.  GDB can update its overlay tables
 114        and fiddle with breakpoints in overlays when this breakpoint
 115        is hit.  */
 116
 117     bp_overlay_event,
 118
 119     /* Master copies of longjmp breakpoints.  These are always installed
 120        as soon as an objfile containing longjmp is loaded, but they are
 121        always disabled.  While necessary, temporary clones of bp_longjmp
 122        type will be created and enabled.  */
 123
 124     bp_longjmp_master,
 125
 126     /* Master copies of std::terminate breakpoints.  */
 127     bp_std_terminate_master,
 128
 129     bp_catchpoint,
 130
 131     bp_tracepoint,
 132     bp_fast_tracepoint,
 133     bp_static_tracepoint,
 134
 135     /* Event for JIT compiled code generation or deletion.  */
 136     bp_jit_event,
 137   };
 138
 139 /* States of enablement of breakpoint. */
 140
 141 enum enable_state
 142   {
 143     bp_disabled,        /* The eventpoint is inactive, and cannot trigger. */
 144     bp_enabled,         /* The eventpoint is active, and can trigger. */
 145     bp_call_disabled,   /* The eventpoint has been disabled while a call
 146                            into the inferior is "in flight", because some
 147                            eventpoints interfere with the implementation of
 148                            a call on some targets.  The eventpoint will be
 149                            automatically enabled and reset when the call
 150                            "lands" (either completes, or stops at another
 151                            eventpoint). */
 152     bp_startup_disabled,/* The eventpoint has been disabled during inferior
 153                            startup.  This is necessary on some targets where
 154                            the main executable will get relocated during
 155                            startup, making breakpoint addresses invalid.
 156                            The eventpoint will be automatically enabled and
 157                            reset once inferior startup is complete.  */
 158     bp_permanent        /* There is a breakpoint instruction hard-wired into
 159                            the target's code.  Don't try to write another
 160                            breakpoint instruction on top of it, or restore
 161                            its value.  Step over it using the architecture's
 162                            SKIP_INSN macro.  */
 163   };
 164
 165
 166 /* Disposition of breakpoint.  Ie: what to do after hitting it. */
 167
 168 enum bpdisp
 169   {
 170     disp_del,                   /* Delete it */
 171     disp_del_at_next_stop,      /* Delete at next stop, whether hit or not */
 172     disp_disable,               /* Disable it */
 173     disp_donttouch              /* Leave it alone */
 174   };
 175
 176 enum target_hw_bp_type
 177   {
 178     hw_write   = 0,             /* Common  HW watchpoint */
 179     hw_read    = 1,             /* Read    HW watchpoint */
 180     hw_access  = 2,             /* Access  HW watchpoint */
 181     hw_execute = 3              /* Execute HW breakpoint */
 182   };
 183
 184
 185 /* Information used by targets to insert and remove breakpoints.  */
 186
 187 struct bp_target_info
 188 {
 189   /* Address space at which the breakpoint was placed.  */
 190   struct address_space *placed_address_space;
 191
 192   /* Address at which the breakpoint was placed.  This is normally the
 193      same as ADDRESS from the bp_location, except when adjustment
 194      happens in gdbarch_breakpoint_from_pc.  The most common form of
 195      adjustment is stripping an alternate ISA marker from the PC which
 196      is used to determine the type of breakpoint to insert.  */
 197   CORE_ADDR placed_address;
 198
 199   /* If the breakpoint lives in memory and reading that memory would
 200      give back the breakpoint, instead of the original contents, then
 201      the original contents are cached here.  Only SHADOW_LEN bytes of
 202      this buffer are valid, and only when the breakpoint is inserted.  */
 203   gdb_byte shadow_contents[BREAKPOINT_MAX];
 204
 205   /* The length of the data cached in SHADOW_CONTENTS.  */
 206   int shadow_len;
 207
 208   /* The size of the placed breakpoint, according to
 209      gdbarch_breakpoint_from_pc, when the breakpoint was inserted.  This is
 210      generally the same as SHADOW_LEN, unless we did not need
 211      to read from the target to implement the memory breakpoint
 212      (e.g. if a remote stub handled the details).  We may still
 213      need the size to remove the breakpoint safely.  */
 214   int placed_size;
 215 };
 216
 217 /* GDB maintains two types of information about each breakpoint (or
 218    watchpoint, or other related event).  The first type corresponds
 219    to struct breakpoint; this is a relatively high-level structure
 220    which contains the source location(s), stopping conditions, user
 221    commands to execute when the breakpoint is hit, and so forth.
 222
 223    The second type of information corresponds to struct bp_location.
 224    Each breakpoint has one or (eventually) more locations associated
 225    with it, which represent target-specific and machine-specific
 226    mechanisms for stopping the program.  For instance, a watchpoint
 227    expression may require multiple hardware watchpoints in order to
 228    catch all changes in the value of the expression being watched.  */
 229
 230 enum bp_loc_type
 231 {
 232   bp_loc_software_breakpoint,
 233   bp_loc_hardware_breakpoint,
 234   bp_loc_hardware_watchpoint,
 235   bp_loc_other                  /* Miscellaneous...  */
 236 };
 237
 238 struct bp_location
 239 {
 240   /* Chain pointer to the next breakpoint location for
 241      the same parent breakpoint.  */
 242   struct bp_location *next;
 243
 244   /* The reference count.  */
 245   int refc;
 246
 247   /* Type of this breakpoint location.  */
 248   enum bp_loc_type loc_type;
 249
 250   /* Each breakpoint location must belong to exactly one higher-level
 251      breakpoint.  This pointer is NULL iff this bp_location is no
 252      longer attached to a breakpoint.  For example, when a breakpoint
 253      is deleted, its locations may still be found in the
 254      moribund_locations list, or if we had stopped for it, in
 255      bpstats.  */
 256   struct breakpoint *owner;
 257
 258   /* Conditional.  Break only if this expression's value is nonzero.
 259      Unlike string form of condition, which is associated with
 260      breakpoint, this is associated with location, since if breakpoint
 261      has several locations, the evaluation of expression can be
 262      different for different locations.  Only valid for real
 263      breakpoints; a watchpoint's conditional expression is stored in
 264      the owner breakpoint object.  */
 265   struct expression *cond;
 266
 267   /* This location's address is in an unloaded solib, and so this
 268      location should not be inserted.  It will be automatically
 269      enabled when that solib is loaded.  */
 270   char shlib_disabled;
 271
 272   /* Is this particular location enabled.  */
 273   char enabled;
 274
 275   /* Nonzero if this breakpoint is now inserted.  */
 276   char inserted;
 277
 278   /* Nonzero if this is not the first breakpoint in the list
 279      for the given address.  */
 280   char duplicate;
 281
 282   /* If we someday support real thread-specific breakpoints, then
 283      the breakpoint location will need a thread identifier.  */
 284
 285   /* Data for specific breakpoint types.  These could be a union, but
 286      simplicity is more important than memory usage for breakpoints.  */
 287
 288   /* Architecture associated with this location's address.  May be
 289      different from the breakpoint architecture.  */
 290   struct gdbarch *gdbarch;
 291
 292   /* The program space associated with this breakpoint location
 293      address.  Note that an address space may be represented in more
 294      than one program space (e.g. each uClinux program will be given
 295      its own program space, but there will only be one address space
 296      for all of them), but we must not insert more than one location
 297      at the same address in the same address space.  */
 298   struct program_space *pspace;
 299
 300   /* Note that zero is a perfectly valid code address on some platforms
 301      (for example, the mn10200 (OBSOLETE) and mn10300 simulators).  NULL
 302      is not a special value for this field.  Valid for all types except
 303      bp_loc_other.  */
 304   CORE_ADDR address;
 305
 306   /* For hardware watchpoints, the size of data ad ADDRESS being watches.  */
 307   int length;
 308
 309   /* Type of hardware watchpoint. */
 310   enum target_hw_bp_type watchpoint_type;
 311
 312   /* For any breakpoint type with an address, this is the section
 313      associated with the address.  Used primarily for overlay debugging.  */
 314   struct obj_section *section;
 315
 316   /* Address at which breakpoint was requested, either by the user or
 317      by GDB for internal breakpoints.  This will usually be the same
 318      as ``address'' (above) except for cases in which
 319      ADJUST_BREAKPOINT_ADDRESS has computed a different address at
 320      which to place the breakpoint in order to comply with a
 321      processor's architectual constraints.  */
 322   CORE_ADDR requested_address;
 323
 324   char *function_name;
 325
 326   /* Details of the placed breakpoint, when inserted.  */
 327   struct bp_target_info target_info;
 328
 329   /* Similarly, for the breakpoint at an overlay's LMA, if necessary.  */
 330   struct bp_target_info overlay_target_info;
 331
 332   /* In a non-stop mode, it's possible that we delete a breakpoint,
 333      but as we do that, some still running thread hits that breakpoint.
 334      For that reason, we need to keep locations belonging to deleted
 335      breakpoints for a bit, so that don't report unexpected SIGTRAP.
 336      We can't keep such locations forever, so we use a heuristic --
 337      after we process certain number of inferior events since
 338      breakpoint was deleted, we retire all locations of that breakpoint.
 339      This variable keeps a number of events still to go, when
 340      it becomes 0 this location is retired.  */
 341   int events_till_retirement;
 342 };
 343
 344 /* This structure is a collection of function pointers that, if available,
 345    will be called instead of the performing the default action for this
 346    bptype.  */
 347
 348 struct breakpoint_ops
 349 {
 350   /* Insert the breakpoint or activate the catchpoint.  Should raise
 351      an exception if the operation failed.  */
 352   void (*insert) (struct breakpoint *);
 353
 354   /* Remove the breakpoint/catchpoint that was previously inserted
 355      with the "insert" method above.  Return non-zero if the operation
 356      succeeded.  */
 357   int (*remove) (struct breakpoint *);
 358
 359   /* Return non-zero if the debugger should tell the user that this
 360      breakpoint was hit.  */
 361   int (*breakpoint_hit) (struct breakpoint *);
 362
 363   /* The normal print routine for this breakpoint, called when we
 364      hit it.  */
 365   enum print_stop_action (*print_it) (struct breakpoint *);
 366
 367   /* Display information about this breakpoint, for "info breakpoints".  */
 368   void (*print_one) (struct breakpoint *, struct bp_location **);
 369
 370   /* Display information about this breakpoint after setting it (roughly
 371      speaking; this is called from "mention").  */
 372   void (*print_mention) (struct breakpoint *);
 373
 374   /* Print to FP the CLI command that recreates this breakpoint.  */
 375   void (*print_recreate) (struct breakpoint *, struct ui_file *fp);
 376 };
 377
 378 enum watchpoint_triggered
 379 {
 380   /* This watchpoint definitely did not trigger.  */
 381   watch_triggered_no = 0,
 382
 383   /* Some hardware watchpoint triggered, and it might have been this
 384      one, but we do not know which it was.  */
 385   watch_triggered_unknown,
 386
 387   /* This hardware watchpoint definitely did trigger.  */
 388   watch_triggered_yes
 389 };
 390
 391 /* This is used to declare the VEC syscalls_to_be_caught.  */
 392 DEF_VEC_I(int);
 393
 394 typedef struct bp_location *bp_location_p;
 395 DEF_VEC_P(bp_location_p);
 396
 397 /* A reference-counted struct command_line.  This lets multiple
 398    breakpoints share a single command list.  This is an implementation
 399    detail to the breakpoints module.  */
 400 struct counted_command_line;
 401
 402 /* Note that the ->silent field is not currently used by any commands
 403    (though the code is in there if it was to be, and set_raw_breakpoint
 404    does set it to 0).  I implemented it because I thought it would be
 405    useful for a hack I had to put in; I'm going to leave it in because
 406    I can see how there might be times when it would indeed be useful */
 407
 408 /* This is for a breakpoint or a watchpoint.  */
 409
 410 struct breakpoint
 411   {
 412     struct breakpoint *next;
 413     /* Type of breakpoint. */
 414     enum bptype type;
 415     /* Zero means disabled; remember the info but don't break here.  */
 416     enum enable_state enable_state;
 417     /* What to do with this breakpoint after we hit it. */
 418     enum bpdisp disposition;
 419     /* Number assigned to distinguish breakpoints.  */
 420     int number;
 421
 422     /* Location(s) associated with this high-level breakpoint.  */
 423     struct bp_location *loc;
 424
 425     /* Line number of this address.  */
 426
 427     int line_number;
 428
 429     /* Source file name of this address.  */
 430
 431     char *source_file;
 432
 433     /* Non-zero means a silent breakpoint (don't print frame info
 434        if we stop here). */
 435     unsigned char silent;
 436     /* Number of stops at this breakpoint that should
 437        be continued automatically before really stopping.  */
 438     int ignore_count;
 439     /* Chain of command lines to execute when this breakpoint is hit.  */
 440     struct counted_command_line *commands;
 441     /* Stack depth (address of frame).  If nonzero, break only if fp
 442        equals this.  */
 443     struct frame_id frame_id;
 444
 445     /* The program space used to set the breakpoint.  */
 446     struct program_space *pspace;
 447
 448     /* String we used to set the breakpoint (malloc'd).  */
 449     char *addr_string;
 450     /* Architecture we used to set the breakpoint.  */
 451     struct gdbarch *gdbarch;
 452     /* Language we used to set the breakpoint.  */
 453     enum language language;
 454     /* Input radix we used to set the breakpoint.  */
 455     int input_radix;
 456     /* String form of the breakpoint condition (malloc'd), or NULL if there
 457        is no condition.  */
 458     char *cond_string;
 459     /* String form of exp to use for displaying to the user (malloc'd), or
 460        NULL if none.  */
 461     char *exp_string;
 462     /* String form to use for reparsing of EXP (malloc'd) or NULL.  */
 463     char *exp_string_reparse;
 464
 465     /* The expression we are watching, or NULL if not a watchpoint.  */
 466     struct expression *exp;
 467     /* The largest block within which it is valid, or NULL if it is
 468        valid anywhere (e.g. consists just of global symbols).  */
 469     struct block *exp_valid_block;
 470     /* The conditional expression if any.  NULL if not a watchpoint.  */
 471     struct expression *cond_exp;
 472     /* The largest block within which it is valid, or NULL if it is
 473        valid anywhere (e.g. consists just of global symbols).  */
 474     struct block *cond_exp_valid_block;
 475     /* Value of the watchpoint the last time we checked it, or NULL
 476        when we do not know the value yet or the value was not
 477        readable.  VAL is never lazy.  */
 478     struct value *val;
 479     /* Nonzero if VAL is valid.  If VAL_VALID is set but VAL is NULL,
 480        then an error occurred reading the value.  */
 481     int val_valid;
 482
 483     /* Holds the address of the related watchpoint_scope breakpoint
 484        when using watchpoints on local variables (might the concept
 485        of a related breakpoint be useful elsewhere, if not just call
 486        it the watchpoint_scope breakpoint or something like that. FIXME).  */
 487     struct breakpoint *related_breakpoint;
 488
 489     /* Holds the frame address which identifies the frame this
 490        watchpoint should be evaluated in, or `null' if the watchpoint
 491        should be evaluated on the outermost frame.  */
 492     struct frame_id watchpoint_frame;
 493
 494     /* Holds the thread which identifies the frame this watchpoint
 495        should be considered in scope for, or `null_ptid' if the
 496        watchpoint should be evaluated in all threads.  */
 497     ptid_t watchpoint_thread;
 498
 499     /* For hardware watchpoints, the triggered status according to the
 500        hardware.  */
 501     enum watchpoint_triggered watchpoint_triggered;
 502
 503     /* Thread number for thread-specific breakpoint, or -1 if don't care.  */
 504     int thread;
 505
 506     /* Ada task number for task-specific breakpoint, or 0 if don't care.  */
 507     int task;
 508
 509     /* Count of the number of times this breakpoint was taken, dumped
 510        with the info, but not used for anything else.  Useful for
 511        seeing how many times you hit a break prior to the program
 512        aborting, so you can back up to just before the abort.  */
 513     int hit_count;
 514
 515     /* Process id of a child process whose forking triggered this
 516        catchpoint.  This field is only valid immediately after this
 517        catchpoint has triggered.  */
 518     ptid_t forked_inferior_pid;
 519
 520     /* Filename of a program whose exec triggered this catchpoint.
 521        This field is only valid immediately after this catchpoint has
 522        triggered.  */
 523     char *exec_pathname;
 524
 525     /* Syscall numbers used for the 'catch syscall' feature.
 526        If no syscall has been specified for filtering, its value is NULL.
 527        Otherwise, it holds a list of all syscalls to be caught.
 528        The list elements are allocated with xmalloc.  */
 529     VEC(int) *syscalls_to_be_caught;
 530
 531     /* Methods associated with this breakpoint.  */
 532     struct breakpoint_ops *ops;
 533
 534     /* Is breakpoint's condition not yet parsed because we found
 535        no location initially so had no context to parse
 536        the condition in.  */
 537     int condition_not_parsed;
 538
 539     /* Number of times this tracepoint should single-step
 540        and collect additional data.  */
 541     long step_count;
 542
 543     /* Number of times this tracepoint should be hit before
 544        disabling/ending.  */
 545     int pass_count;
 546
 547     /* The number of the tracepoint on the target.  */
 548     int number_on_target;
 549
 550     /* The static tracepoint marker id, if known.  */
 551     char *static_trace_marker_id;
 552
 553     /* LTTng/UST allow more than one marker with the same ID string,
 554        although it unadvised because it confuses tools.  When setting
 555        static tracepoints by marker ID, this will record the index in
 556        the array of markers we found for the given marker ID for which
 557        this static tracepoint corresponds.  When resetting
 558        breakpoints, we will use this index to try to find the same
 559        marker again.  */
 560     int static_trace_marker_id_idx;
 561
 562     /* With a Python scripting enabled GDB, store a reference to the
 563        Python object that has been associated with this breakpoint.
 564        This is always NULL for a GDB that is not script enabled.  It
 565        can sometimes be NULL for enabled GDBs as not all breakpoint
 566        types are tracked by the Python scripting API.  */
 567     struct breakpoint_object *py_bp_object;
 568 };
 569
 570 typedef struct breakpoint *breakpoint_p;
 571 DEF_VEC_P(breakpoint_p);
 572 \f
 573 /* The following stuff is an abstract data type "bpstat" ("breakpoint
 574    status").  This provides the ability to determine whether we have
 575    stopped at a breakpoint, and what we should do about it.  */
 576
 577 typedef struct bpstats *bpstat;
 578
 579 /* Clears a chain of bpstat, freeing storage
 580    of each.  */
 581 extern void bpstat_clear (bpstat *);
 582
 583 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
 584    is part of the bpstat is copied as well.  */
 585 extern bpstat bpstat_copy (bpstat);
 586
 587 extern bpstat bpstat_stop_status (struct address_space *aspace,
 588                                   CORE_ADDR pc, ptid_t ptid);
 589 \f
 590 /* This bpstat_what stuff tells wait_for_inferior what to do with a
 591    breakpoint (a challenging task).
 592
 593    The enum values order defines priority-like order of the actions.
 594    Once you've decided that some action is appropriate, you'll never
 595    go back and decide something of a lower priority is better.  Each
 596    of these actions is mutually exclusive with the others.  That
 597    means, that if you find yourself adding a new action class here and
 598    wanting to tell GDB that you have two simultaneous actions to
 599    handle, something is wrong, and you probably don't actually need a
 600    new action type.
 601
 602    Note that a step resume breakpoint overrides another breakpoint of
 603    signal handling (see comment in wait_for_inferior at where we set
 604    the step_resume breakpoint).  */
 605
 606 enum bpstat_what_main_action
 607   {
 608     /* Perform various other tests; that is, this bpstat does not
 609        say to perform any action (e.g. failed watchpoint and nothing
 610        else).  */
 611     BPSTAT_WHAT_KEEP_CHECKING,
 612
 613     /* Remove breakpoints, single step once, then put them back in and
 614        go back to what we were doing.  It's possible that this should be
 615        removed from the main_action and put into a separate field, to more
 616        cleanly handle BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE.  */
 617     BPSTAT_WHAT_SINGLE,
 618
 619     /* Set longjmp_resume breakpoint, remove all other breakpoints,
 620        and continue.  The "remove all other breakpoints" part is required
 621        if we are also stepping over another breakpoint as well as doing
 622        the longjmp handling.  */
 623     BPSTAT_WHAT_SET_LONGJMP_RESUME,
 624
 625     /* Clear longjmp_resume breakpoint, then handle as
 626        BPSTAT_WHAT_KEEP_CHECKING.  */
 627     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME,
 628
 629     /* Rather than distinguish between noisy and silent stops here, it
 630        might be cleaner to have bpstat_print make that decision (also
 631        taking into account stop_print_frame and source_only).  But the
 632        implications are a bit scary (interaction with auto-displays, etc.),
 633        so I won't try it.  */
 634
 635     /* Stop silently.  */
 636     BPSTAT_WHAT_STOP_SILENT,
 637
 638     /* Stop and print.  */
 639     BPSTAT_WHAT_STOP_NOISY,
 640
 641     /* Clear step resume breakpoint, and keep checking.  */
 642     BPSTAT_WHAT_STEP_RESUME,
 643   };
 644
 645 /* An enum indicating the kind of "stack dummy" stop.  This is a bit
 646    of a misnomer because only one kind of truly a stack dummy.  */
 647 enum stop_stack_kind
 648   {
 649     /* We didn't stop at a stack dummy breakpoint.  */
 650     STOP_NONE = 0,
 651
 652     /* Stopped at a stack dummy.  */
 653     STOP_STACK_DUMMY,
 654
 655     /* Stopped at std::terminate.  */
 656     STOP_STD_TERMINATE
 657   };
 658
 659 struct bpstat_what
 660   {
 661     enum bpstat_what_main_action main_action;
 662
 663     /* Did we hit a call dummy breakpoint?  This only goes with a main_action
 664        of BPSTAT_WHAT_STOP_SILENT or BPSTAT_WHAT_STOP_NOISY (the concept of
 665        continuing from a call dummy without popping the frame is not a
 666        useful one).  */
 667     enum stop_stack_kind call_dummy;
 668   };
 669
 670 /* The possible return values for print_bpstat, print_it_normal,
 671    print_it_done, print_it_noop. */
 672 enum print_stop_action
 673   {
 674     PRINT_UNKNOWN = -1,
 675     PRINT_SRC_AND_LOC,
 676     PRINT_SRC_ONLY,
 677     PRINT_NOTHING
 678   };
 679
 680 /* Tell what to do about this bpstat.  */
 681 struct bpstat_what bpstat_what (bpstat);
 682 \f
 683 /* Find the bpstat associated with a breakpoint.  NULL otherwise. */
 684 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
 685
 686 /* Nonzero if a signal that we got in wait() was due to circumstances
 687    explained by the BS.  */
 688 /* Currently that is true if we have hit a breakpoint, or if there is
 689    a watchpoint enabled.  */
 690 #define bpstat_explains_signal(bs) ((bs) != NULL)
 691
 692 /* Nonzero is this bpstat causes a stop.  */
 693 extern int bpstat_causes_stop (bpstat);
 694
 695 /* Nonzero if we should step constantly (e.g. watchpoints on machines
 696    without hardware support).  This isn't related to a specific bpstat,
 697    just to things like whether watchpoints are set.  */
 698 extern int bpstat_should_step (void);
 699
 700 /* Print a message indicating what happened.  Returns nonzero to
 701    say that only the source line should be printed after this (zero
 702    return means print the frame as well as the source line).  */
 703 extern enum print_stop_action bpstat_print (bpstat);
 704
 705 /* Put in *NUM the breakpoint number of the first breakpoint we are stopped
 706    at.  *BSP upon return is a bpstat which points to the remaining
 707    breakpoints stopped at (but which is not guaranteed to be good for
 708    anything but further calls to bpstat_num).
 709    Return 0 if passed a bpstat which does not indicate any breakpoints.
 710    Return -1 if stopped at a breakpoint that has been deleted since
 711    we set it.
 712    Return 1 otherwise.  */
 713 extern int bpstat_num (bpstat *, int *);
 714
 715 /* Perform actions associated with the stopped inferior.  Actually, we
 716    just use this for breakpoint commands.  Perhaps other actions will
 717    go here later, but this is executed at a late time (from the
 718    command loop).  */
 719 extern void bpstat_do_actions (void);
 720
 721 /* Modify BS so that the actions will not be performed.  */
 722 extern void bpstat_clear_actions (bpstat);
 723
 724 /* Implementation:  */
 725
 726 /* Values used to tell the printing routine how to behave for this bpstat. */
 727 enum bp_print_how
 728   {
 729     /* This is used when we want to do a normal printing of the reason
 730        for stopping. The output will depend on the type of eventpoint
 731        we are dealing with. This is the default value, most commonly
 732        used. */
 733     print_it_normal,
 734     /* This is used when nothing should be printed for this bpstat entry.  */
 735     print_it_noop,
 736     /* This is used when everything which needs to be printed has
 737        already been printed.  But we still want to print the frame.  */
 738     print_it_done
 739   };
 740
 741 struct bpstats
 742   {
 743     /* Linked list because there can be more than one breakpoint at
 744        the same place, and a bpstat reflects the fact that all have
 745        been hit.  */
 746     bpstat next;
 747
 748     /* Location that caused the stop.  Locations are refcounted, so
 749        this will never be NULL.  Note that this location may end up
 750        detached from a breakpoint, but that does not necessary mean
 751        that the struct breakpoint is gone.  E.g., consider a
 752        watchpoint with a condition that involves an inferior function
 753        call.  Watchpoint locations are recreated often (on resumes,
 754        hence on infcalls too).  Between creating the bpstat and after
 755        evaluating the watchpoint condition, this location may hence
 756        end up detached from its original owner watchpoint, even though
 757        the watchpoint is still listed.  If it's condition evaluates as
 758        true, we still want this location to cause a stop, and we will
 759        still need to know which watchpoint it was originally attached.
 760        What this means is that we should not (in most cases) follow
 761        the `bpstat->bp_location->owner' link, but instead use the
 762        `breakpoint_at' field below.  */
 763     struct bp_location *bp_location_at;
 764
 765     /* Breakpoint that caused the stop.  This is nullified if the
 766        breakpoint ends up being deleted.  See comments on
 767        `bp_location_at' above for why do we need this field instead of
 768        following the location's owner.  */
 769     struct breakpoint *breakpoint_at;
 770
 771     /* The associated command list.  */
 772     struct counted_command_line *commands;
 773
 774     /* Commands left to be done.  This points somewhere in
 775        base_command.  */
 776     struct command_line *commands_left;
 777
 778     /* Old value associated with a watchpoint.  */
 779     struct value *old_val;
 780
 781     /* Nonzero if this breakpoint tells us to print the frame.  */
 782     char print;
 783
 784     /* Nonzero if this breakpoint tells us to stop.  */
 785     char stop;
 786
 787     /* Tell bpstat_print and print_bp_stop_message how to print stuff
 788        associated with this element of the bpstat chain.  */
 789     enum bp_print_how print_it;
 790   };
 791
 792 enum inf_context
 793   {
 794     inf_starting,
 795     inf_running,
 796     inf_exited,
 797     inf_execd
 798   };
 799
 800 /* The possible return values for breakpoint_here_p.
 801    We guarantee that zero always means "no breakpoint here".  */
 802 enum breakpoint_here
 803   {
 804     no_breakpoint_here = 0,
 805     ordinary_breakpoint_here,
 806     permanent_breakpoint_here
 807   };
 808 \f
 809
 810 /* Prototypes for breakpoint-related functions.  */
 811
 812 extern enum breakpoint_here breakpoint_here_p (struct address_space *, CORE_ADDR);
 813
 814 extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
 815
 816 extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
 817
 818 extern int regular_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
 819
 820 extern int software_breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
 821
 822 /* Returns true if there's a hardware watchpoint or access watchpoint
 823    inserted in the range defined by ADDR and LEN.  */
 824 extern int hardware_watchpoint_inserted_in_range (struct address_space *,
 825                                                   CORE_ADDR addr,
 826                                                   ULONGEST len);
 827
 828 extern int breakpoint_thread_match (struct address_space *, CORE_ADDR, ptid_t);
 829
 830 extern void until_break_command (char *, int, int);
 831
 832 extern void breakpoint_re_set (void);
 833
 834 extern void breakpoint_re_set_thread (struct breakpoint *);
 835
 836 extern struct breakpoint *set_momentary_breakpoint
 837   (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
 838
 839 extern struct breakpoint *set_momentary_breakpoint_at_pc
 840   (struct gdbarch *, CORE_ADDR pc, enum bptype type);
 841
 842 extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
 843
 844 extern void set_ignore_count (int, int, int);
 845
 846 extern void set_default_breakpoint (int, struct program_space *,
 847                                     CORE_ADDR, struct symtab *, int);
 848
 849 extern void breakpoint_init_inferior (enum inf_context);
 850
 851 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
 852
 853 extern void delete_breakpoint (struct breakpoint *);
 854
 855 extern void breakpoint_auto_delete (bpstat);
 856
 857 /* Return the chain of command lines to execute when this breakpoint
 858    is hit.  */
 859 extern struct command_line *breakpoint_commands (struct breakpoint *b);
 860
 861 extern void break_command (char *, int);
 862
 863 extern void hbreak_command_wrapper (char *, int);
 864 extern void thbreak_command_wrapper (char *, int);
 865 extern void rbreak_command_wrapper (char *, int);
 866 extern void watch_command_wrapper (char *, int, int);
 867 extern void awatch_command_wrapper (char *, int, int);
 868 extern void rwatch_command_wrapper (char *, int, int);
 869 extern void tbreak_command (char *, int);
 870
 871 extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
 872                               char *cond_string, int thread,
 873                               int parse_condition_and_thread,
 874                               int tempflag, enum bptype wanted_type,
 875                               int ignore_count,
 876                               enum auto_boolean pending_break_support,
 877                               struct breakpoint_ops *ops,
 878                               int from_tty,
 879                               int enabled,
 880                               int internal);
 881
 882 extern void insert_breakpoints (void);
 883
 884 extern int remove_breakpoints (void);
 885
 886 extern int remove_breakpoints_pid (int pid);
 887
 888 /* This function can be used to physically insert eventpoints from the
 889    specified traced inferior process, without modifying the breakpoint
 890    package's state.  This can be useful for those targets which support
 891    following the processes of a fork() or vfork() system call, when both
 892    of the resulting two processes are to be followed.  */
 893 extern int reattach_breakpoints (int);
 894
 895 /* This function can be used to update the breakpoint package's state
 896    after an exec() system call has been executed.
 897
 898    This function causes the following:
 899
 900    - All eventpoints are marked "not inserted".
 901    - All eventpoints with a symbolic address are reset such that
 902    the symbolic address must be reevaluated before the eventpoints
 903    can be reinserted.
 904    - The solib breakpoints are explicitly removed from the breakpoint
 905    list.
 906    - A step-resume breakpoint, if any, is explicitly removed from the
 907    breakpoint list.
 908    - All eventpoints without a symbolic address are removed from the
 909    breakpoint list. */
 910 extern void update_breakpoints_after_exec (void);
 911
 912 /* This function can be used to physically remove hardware breakpoints
 913    and watchpoints from the specified traced inferior process, without
 914    modifying the breakpoint package's state.  This can be useful for
 915    those targets which support following the processes of a fork() or
 916    vfork() system call, when one of the resulting two processes is to
 917    be detached and allowed to run free.
 918
 919    It is an error to use this function on the process whose id is
 920    inferior_ptid.  */
 921 extern int detach_breakpoints (int);
 922
 923 /* This function is called when program space PSPACE is about to be
 924    deleted.  It takes care of updating breakpoints to not reference
 925    this PSPACE anymore.  */
 926 extern void breakpoint_program_space_exit (struct program_space *pspace);
 927
 928 extern void set_longjmp_breakpoint (int thread);
 929 extern void delete_longjmp_breakpoint (int thread);
 930
 931 extern void enable_overlay_breakpoints (void);
 932 extern void disable_overlay_breakpoints (void);
 933
 934 extern void set_std_terminate_breakpoint (void);
 935 extern void delete_std_terminate_breakpoint (void);
 936
 937 /* These functions respectively disable or reenable all currently
 938    enabled watchpoints.  When disabled, the watchpoints are marked
 939    call_disabled.  When reenabled, they are marked enabled.
 940
 941    The intended client of these functions is call_function_by_hand.
 942
 943    The inferior must be stopped, and all breakpoints removed, when
 944    these functions are used.
 945
 946    The need for these functions is that on some targets (e.g., HP-UX),
 947    gdb is unable to unwind through the dummy frame that is pushed as
 948    part of the implementation of a call command.  Watchpoints can
 949    cause the inferior to stop in places where this frame is visible,
 950    and that can cause execution control to become very confused.
 951
 952    Note that if a user sets breakpoints in an interactively called
 953    function, the call_disabled watchpoints will have been reenabled
 954    when the first such breakpoint is reached.  However, on targets
 955    that are unable to unwind through the call dummy frame, watches
 956    of stack-based storage may then be deleted, because gdb will
 957    believe that their watched storage is out of scope.  (Sigh.) */
 958 extern void disable_watchpoints_before_interactive_call_start (void);
 959
 960 extern void enable_watchpoints_after_interactive_call_stop (void);
 961
 962 /* These functions disable and re-enable all breakpoints during
 963    inferior startup.  They are intended to be called from solib
 964    code where necessary.  This is needed on platforms where the
 965    main executable is relocated at some point during startup
 966    processing, making breakpoint addresses invalid.
 967
 968    If additional breakpoints are created after the routine
 969    disable_breakpoints_before_startup but before the routine
 970    enable_breakpoints_after_startup was called, they will also
 971    be marked as disabled.  */
 972 extern void disable_breakpoints_before_startup (void);
 973 extern void enable_breakpoints_after_startup (void);
 974
 975 /* For script interpreters that need to define breakpoint commands
 976    after they've already read the commands into a struct command_line.  */
 977 extern enum command_control_type commands_from_control_command
 978   (char *arg, struct command_line *cmd);
 979
 980 extern void clear_breakpoint_hit_counts (void);
 981
 982 extern int get_number (char **);
 983
 984 extern int get_number_or_range (char **);
 985
 986 extern struct breakpoint *get_breakpoint (int num);
 987
 988 /* The following are for displays, which aren't really breakpoints, but
 989    here is as good a place as any for them.  */
 990
 991 extern void disable_current_display (void);
 992
 993 extern void do_displays (void);
 994
 995 extern void disable_display (int);
 996
 997 extern void clear_displays (void);
 998
 999 extern void disable_breakpoint (struct breakpoint *);
1000
1001 extern void enable_breakpoint (struct breakpoint *);
1002
1003 extern void breakpoint_set_commands (struct breakpoint *b,
1004                                      struct command_line *commands);
1005
1006 /* Clear the "inserted" flag in all breakpoints.  */
1007 extern void mark_breakpoints_out (void);
1008
1009 extern void make_breakpoint_permanent (struct breakpoint *);
1010
1011 extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
1012                                                        CORE_ADDR);
1013
1014 extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
1015                                                          CORE_ADDR);
1016
1017 extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
1018                                                           CORE_ADDR);
1019
1020 extern void remove_solib_event_breakpoints (void);
1021
1022 extern void remove_thread_event_breakpoints (void);
1023
1024 extern void disable_breakpoints_in_shlibs (void);
1025
1026 /* This function returns TRUE if ep is a catchpoint. */
1027 extern int ep_is_catchpoint (struct breakpoint *);
1028
1029 /* Enable breakpoints and delete when hit.  Called with ARG == NULL
1030    deletes all breakpoints. */
1031 extern void delete_command (char *arg, int from_tty);
1032
1033 /* Pull all H/W watchpoints from the target. Return non-zero if the
1034    remove fails. */
1035 extern int remove_hw_watchpoints (void);
1036
1037 /* Manage a software single step breakpoint (or two).  Insert may be called
1038    twice before remove is called.  */
1039 extern void insert_single_step_breakpoint (struct gdbarch *,
1040                                            struct address_space *, CORE_ADDR);
1041 extern int single_step_breakpoints_inserted (void);
1042 extern void remove_single_step_breakpoints (void);
1043 extern void cancel_single_step_breakpoints (void);
1044
1045 /* Manage manual breakpoints, separate from the normal chain of
1046    breakpoints.  These functions are used in murky target-specific
1047    ways.  Please do not add more uses!  */
1048 extern void *deprecated_insert_raw_breakpoint (struct gdbarch *,
1049                                                struct address_space *, CORE_ADDR);
1050 extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *);
1051
1052 /* Check if any hardware watchpoints have triggered, according to the
1053    target.  */
1054 int watchpoints_triggered (struct target_waitstatus *);
1055
1056 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1057    by replacing any memory breakpoints with their shadowed contents.  */
1058 void breakpoint_restore_shadows (gdb_byte *buf, ULONGEST memaddr,
1059                                  LONGEST len);
1060
1061 extern int breakpoints_always_inserted_mode (void);
1062
1063 /* Called each time new event from target is processed.
1064    Retires previously deleted breakpoint locations that
1065    in our opinion won't ever trigger.  */
1066 extern void breakpoint_retire_moribund (void);
1067
1068 /* Set break condition of breakpoint B to EXP.  */
1069 extern void set_breakpoint_condition (struct breakpoint *b, char *exp,
1070                                       int from_tty);
1071
1072 /* Checks if we are catching syscalls or not.
1073    Returns 0 if not, greater than 0 if we are.  */
1074 extern int catch_syscall_enabled (void);
1075
1076 /* Checks if we are catching syscalls with the specific
1077    syscall_number.  Used for "filtering" the catchpoints.
1078    Returns 0 if not, greater than 0 if we are.  */
1079 extern int catching_syscall_number (int syscall_number);
1080
1081 /* Tell a breakpoint to be quiet.  */
1082 extern void make_breakpoint_silent (struct breakpoint *);
1083
1084 /* Return a tracepoint with the given number if found.  */
1085 extern struct breakpoint *get_tracepoint (int num);
1086
1087 extern struct breakpoint *get_tracepoint_by_number_on_target (int num);
1088
1089 /* Find a tracepoint by parsing a number in the supplied string.  */
1090 extern struct breakpoint *get_tracepoint_by_number (char **arg, int multi_p,
1091                                                     int optional_p);
1092
1093 /* Return a vector of all tracepoints currently defined.  The vector
1094    is newly allocated; the caller should free when done with it.  */
1095 extern VEC(breakpoint_p) *all_tracepoints (void);
1096
1097 extern int is_tracepoint (const struct breakpoint *b);
1098
1099 /* Return a vector of all static tracepoints defined at ADDR.  The
1100    vector is newly allocated; the caller should free when done with
1101    it.  */
1102 extern VEC(breakpoint_p) *static_tracepoints_here (CORE_ADDR addr);
1103
1104 /* Function that can be passed to read_command_line to validate
1105    that each command is suitable for tracepoint command list.  */
1106 extern void check_tracepoint_command (char *line, void *closure);
1107
1108 /* Call at the start and end of an "rbreak" command to register
1109    breakpoint numbers for a later "commands" command.  */
1110 extern void start_rbreak_breakpoints (void);
1111 extern void end_rbreak_breakpoints (void);
1112
1113 /* Breakpoint iterator function.
1114
1115    Calls a callback function once for each breakpoint, so long as the
1116    callback function returns false.  If the callback function returns
1117    true, the iteration will end and the current breakpoint will be
1118    returned.  This can be useful for implementing a search for a
1119    breakpoint with arbitrary attributes, or for applying an operation
1120    to every breakpoint.  */
1121 extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *,
1122                                                              void *), void *);
1123
1124 #endif /* !defined (BREAKPOINT_H) */