gdb/breakpoint.h

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