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