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.  */
 442   int (*breakpoint_hit) (const struct bp_location *bl, struct address_space *,
 443                          CORE_ADDR);
 444
 445   /* Check internal conditions of the breakpoint referred to by BS.
 446      If we should not stop for this breakpoint, set BS->stop to 0.  */
 447   void (*check_status) (struct bpstats *bs);
 448
 449   /* Tell how many hardware resources (debug registers) are needed
 450      for this breakpoint.  If this function is not provided, then
 451      the breakpoint or watchpoint needs one debug register.  */
 452   int (*resources_needed) (const struct bp_location *);
 453
 454   /* Tell whether we can downgrade from a hardware watchpoint to a software
 455      one.  If not, the user will not be able to enable the watchpoint when
 456      there are not enough hardware resources available.  */
 457   int (*works_in_software_mode) (const struct breakpoint *);
 458
 459   /* The normal print routine for this breakpoint, called when we
 460      hit it.  */
 461   enum print_stop_action (*print_it) (struct bpstats *bs);
 462
 463   /* Display information about this breakpoint, for "info
 464      breakpoints".  */
 465   void (*print_one) (struct breakpoint *, struct bp_location **);
 466
 467   /* Display extra information about this breakpoint, below the normal
 468      breakpoint description in "info breakpoints".
 469
 470      In the example below, the "address range" line was printed
 471      by print_one_detail_ranged_breakpoint.
 472
 473      (gdb) info breakpoints
 474      Num     Type           Disp Enb Address    What
 475      2       hw breakpoint  keep y              in main at test-watch.c:70
 476              address range: [0x10000458, 0x100004c7]
 477
 478    */
 479   void (*print_one_detail) (const struct breakpoint *, struct ui_out *);
 480
 481   /* Display information about this breakpoint after setting it
 482      (roughly speaking; this is called from "mention").  */
 483   void (*print_mention) (struct breakpoint *);
 484
 485   /* Print to FP the CLI command that recreates this breakpoint.  */
 486   void (*print_recreate) (struct breakpoint *, struct ui_file *fp);
 487
 488   /* Create SALs from address string, storing the result in linespec_result.
 489
 490      For an explanation about the arguments, see the function
 491      `create_sals_from_address_default'.
 492
 493      This function is called inside `create_breakpoint'.  */
 494   void (*create_sals_from_address) (char **, struct linespec_result *,
 495                                     enum bptype, char *, char **);
 496
 497   /* This method will be responsible for creating a breakpoint given its SALs.
 498      Usually, it just calls `create_breakpoints_sal' (for ordinary
 499      breakpoints).  However, there may be some special cases where we might
 500      need to do some tweaks, e.g., see
 501      `strace_marker_create_breakpoints_sal'.
 502
 503      This function is called inside `create_breakpoint'.  */
 504   void (*create_breakpoints_sal) (struct gdbarch *,
 505                                   struct linespec_result *,
 506                                   struct linespec_sals *, char *,
 507                                   enum bptype, enum bpdisp, int, int,
 508                                   int, const struct breakpoint_ops *,
 509                                   int, int, int);
 510
 511   /* Given the address string (second parameter), this method decodes it
 512      and provides the SAL locations related to it.  For ordinary breakpoints,
 513      it calls `decode_line_full'.
 514
 515      This function is called inside `addr_string_to_sals'.  */
 516   void (*decode_linespec) (struct breakpoint *, char **,
 517                            struct symtabs_and_lines *);
 518 };
 519
 520 /* Helper for breakpoint_ops->print_recreate implementations.  Prints
 521    the "thread" or "task" condition of B, and then a newline.
 522
 523    Necessary because most breakpoint implementations accept
 524    thread/task conditions at the end of the spec line, like "break foo
 525    thread 1", which needs outputting before any breakpoint-type
 526    specific extra command necessary for B's recreation.  */
 527 extern void print_recreate_thread (struct breakpoint *b, struct ui_file *fp);
 528
 529 enum watchpoint_triggered
 530 {
 531   /* This watchpoint definitely did not trigger.  */
 532   watch_triggered_no = 0,
 533
 534   /* Some hardware watchpoint triggered, and it might have been this
 535      one, but we do not know which it was.  */
 536   watch_triggered_unknown,
 537
 538   /* This hardware watchpoint definitely did trigger.  */
 539   watch_triggered_yes
 540 };
 541
 542 /* This is used to declare the VEC syscalls_to_be_caught.  */
 543 DEF_VEC_I(int);
 544
 545 typedef struct bp_location *bp_location_p;
 546 DEF_VEC_P(bp_location_p);
 547
 548 /* A reference-counted struct command_line.  This lets multiple
 549    breakpoints share a single command list.  This is an implementation
 550    detail to the breakpoints module.  */
 551 struct counted_command_line;
 552
 553 /* Some targets (e.g., embedded PowerPC) need two debug registers to set
 554    a watchpoint over a memory region.  If this flag is true, GDB will use
 555    only one register per watchpoint, thus assuming that all acesses that
 556    modify a memory location happen at its starting address. */
 557
 558 extern int target_exact_watchpoints;
 559
 560 /* Note that the ->silent field is not currently used by any commands
 561    (though the code is in there if it was to be, and set_raw_breakpoint
 562    does set it to 0).  I implemented it because I thought it would be
 563    useful for a hack I had to put in; I'm going to leave it in because
 564    I can see how there might be times when it would indeed be useful */
 565
 566 /* This is for all kinds of breakpoints.  */
 567
 568 struct breakpoint
 569   {
 570     /* Methods associated with this breakpoint.  */
 571     const struct breakpoint_ops *ops;
 572
 573     struct breakpoint *next;
 574     /* Type of breakpoint.  */
 575     enum bptype type;
 576     /* Zero means disabled; remember the info but don't break here.  */
 577     enum enable_state enable_state;
 578     /* What to do with this breakpoint after we hit it.  */
 579     enum bpdisp disposition;
 580     /* Number assigned to distinguish breakpoints.  */
 581     int number;
 582
 583     /* Location(s) associated with this high-level breakpoint.  */
 584     struct bp_location *loc;
 585
 586     /* Non-zero means a silent breakpoint (don't print frame info
 587        if we stop here).  */
 588     unsigned char silent;
 589     /* Non-zero means display ADDR_STRING to the user verbatim.  */
 590     unsigned char display_canonical;
 591     /* Number of stops at this breakpoint that should
 592        be continued automatically before really stopping.  */
 593     int ignore_count;
 594     /* Chain of command lines to execute when this breakpoint is
 595        hit.  */
 596     struct counted_command_line *commands;
 597     /* Stack depth (address of frame).  If nonzero, break only if fp
 598        equals this.  */
 599     struct frame_id frame_id;
 600
 601     /* The program space used to set the breakpoint.  This is only set
 602        for breakpoints which are specific to a program space; for
 603        non-thread-specific ordinary breakpoints this is NULL.  */
 604     struct program_space *pspace;
 605
 606     /* String we used to set the breakpoint (malloc'd).  */
 607     char *addr_string;
 608
 609     /* The filter that should be passed to decode_line_full when
 610        re-setting this breakpoint.  This may be NULL, but otherwise is
 611        allocated with xmalloc.  */
 612     char *filter;
 613
 614     /* For a ranged breakpoint, the string we used to find
 615        the end of the range (malloc'd).  */
 616     char *addr_string_range_end;
 617
 618     /* Architecture we used to set the breakpoint.  */
 619     struct gdbarch *gdbarch;
 620     /* Language we used to set the breakpoint.  */
 621     enum language language;
 622     /* Input radix we used to set the breakpoint.  */
 623     int input_radix;
 624     /* String form of the breakpoint condition (malloc'd), or NULL if
 625        there is no condition.  */
 626     char *cond_string;
 627     /* String form of exp to use for displaying to the user
 628        (malloc'd), or NULL if none.  */
 629
 630     /* Holds the address of the related watchpoint_scope breakpoint
 631        when using watchpoints on local variables (might the concept of
 632        a related breakpoint be useful elsewhere, if not just call it
 633        the watchpoint_scope breakpoint or something like that.
 634        FIXME).  */
 635     struct breakpoint *related_breakpoint;
 636
 637     /* Thread number for thread-specific breakpoint,
 638        or -1 if don't care.  */
 639     int thread;
 640
 641     /* Ada task number for task-specific breakpoint,
 642        or 0 if don't care.  */
 643     int task;
 644
 645     /* Count of the number of times this breakpoint was taken, dumped
 646        with the info, but not used for anything else.  Useful for
 647        seeing how many times you hit a break prior to the program
 648        aborting, so you can back up to just before the abort.  */
 649     int hit_count;
 650
 651     /* Is breakpoint's condition not yet parsed because we found
 652        no location initially so had no context to parse
 653        the condition in.  */
 654     int condition_not_parsed;
 655
 656     /* With a Python scripting enabled GDB, store a reference to the
 657        Python object that has been associated with this breakpoint.
 658        This is always NULL for a GDB that is not script enabled.  It
 659        can sometimes be NULL for enabled GDBs as not all breakpoint
 660        types are tracked by the Python scripting API.  */
 661     struct breakpoint_object *py_bp_object;
 662   };
 663
 664 /* An instance of this type is used to represent a watchpoint.  It
 665    includes a "struct breakpoint" as a kind of base class; users
 666    downcast to "struct breakpoint *" when needed.  */
 667
 668 struct watchpoint
 669 {
 670   /* The base class.  */
 671   struct breakpoint base;
 672
 673   /* String form of exp to use for displaying to the user (malloc'd),
 674      or NULL if none.  */
 675   char *exp_string;
 676   /* String form to use for reparsing of EXP (malloc'd) or NULL.  */
 677   char *exp_string_reparse;
 678
 679   /* The expression we are watching, or NULL if not a watchpoint.  */
 680   struct expression *exp;
 681   /* The largest block within which it is valid, or NULL if it is
 682      valid anywhere (e.g. consists just of global symbols).  */
 683   struct block *exp_valid_block;
 684   /* The conditional expression if any.  */
 685   struct expression *cond_exp;
 686   /* The largest block within which it is valid, or NULL if it is
 687      valid anywhere (e.g. consists just of global symbols).  */
 688   struct block *cond_exp_valid_block;
 689   /* Value of the watchpoint the last time we checked it, or NULL when
 690      we do not know the value yet or the value was not readable.  VAL
 691      is never lazy.  */
 692   struct value *val;
 693   /* Nonzero if VAL is valid.  If VAL_VALID is set but VAL is NULL,
 694      then an error occurred reading the value.  */
 695   int val_valid;
 696
 697   /* Holds the frame address which identifies the frame this
 698      watchpoint should be evaluated in, or `null' if the watchpoint
 699      should be evaluated on the outermost frame.  */
 700   struct frame_id watchpoint_frame;
 701
 702   /* Holds the thread which identifies the frame this watchpoint
 703      should be considered in scope for, or `null_ptid' if the
 704      watchpoint should be evaluated in all threads.  */
 705   ptid_t watchpoint_thread;
 706
 707   /* For hardware watchpoints, the triggered status according to the
 708      hardware.  */
 709   enum watchpoint_triggered watchpoint_triggered;
 710
 711   /* Whether this watchpoint is exact (see
 712      target_exact_watchpoints).  */
 713   int exact;
 714
 715   /* The mask address for a masked hardware watchpoint.  */
 716   CORE_ADDR hw_wp_mask;
 717 };
 718
 719 /* Returns true if BPT is really a watchpoint.  */
 720
 721 extern int is_watchpoint (const struct breakpoint *bpt);
 722
 723 /* An instance of this type is used to represent all kinds of
 724    tracepoints.  It includes a "struct breakpoint" as a kind of base
 725    class; users downcast to "struct breakpoint *" when needed.  */
 726
 727 struct tracepoint
 728 {
 729   /* The base class.  */
 730   struct breakpoint base;
 731
 732   /* Number of times this tracepoint should single-step and collect
 733      additional data.  */
 734   long step_count;
 735
 736   /* Number of times this tracepoint should be hit before
 737      disabling/ending.  */
 738   int pass_count;
 739
 740   /* The number of the tracepoint on the target.  */
 741   int number_on_target;
 742
 743   /* The total space taken by all the trace frames for this
 744      tracepoint.  */
 745   ULONGEST traceframe_usage;
 746
 747   /* The static tracepoint marker id, if known.  */
 748   char *static_trace_marker_id;
 749
 750   /* LTTng/UST allow more than one marker with the same ID string,
 751      although it unadvised because it confuses tools.  When setting
 752      static tracepoints by marker ID, this will record the index in
 753      the array of markers we found for the given marker ID for which
 754      this static tracepoint corresponds.  When resetting breakpoints,
 755      we will use this index to try to find the same marker again.  */
 756   int static_trace_marker_id_idx;
 757 };
 758
 759 typedef struct breakpoint *breakpoint_p;
 760 DEF_VEC_P(breakpoint_p);
 761 \f
 762 /* The following stuff is an abstract data type "bpstat" ("breakpoint
 763    status").  This provides the ability to determine whether we have
 764    stopped at a breakpoint, and what we should do about it.  */
 765
 766 typedef struct bpstats *bpstat;
 767
 768 /* Clears a chain of bpstat, freeing storage
 769    of each.  */
 770 extern void bpstat_clear (bpstat *);
 771
 772 /* Return a copy of a bpstat.  Like "bs1 = bs2" but all storage that
 773    is part of the bpstat is copied as well.  */
 774 extern bpstat bpstat_copy (bpstat);
 775
 776 extern bpstat bpstat_stop_status (struct address_space *aspace,
 777                                   CORE_ADDR pc, ptid_t ptid);
 778 \f
 779 /* This bpstat_what stuff tells wait_for_inferior what to do with a
 780    breakpoint (a challenging task).
 781
 782    The enum values order defines priority-like order of the actions.
 783    Once you've decided that some action is appropriate, you'll never
 784    go back and decide something of a lower priority is better.  Each
 785    of these actions is mutually exclusive with the others.  That
 786    means, that if you find yourself adding a new action class here and
 787    wanting to tell GDB that you have two simultaneous actions to
 788    handle, something is wrong, and you probably don't actually need a
 789    new action type.
 790
 791    Note that a step resume breakpoint overrides another breakpoint of
 792    signal handling (see comment in wait_for_inferior at where we set
 793    the step_resume breakpoint).  */
 794
 795 enum bpstat_what_main_action
 796   {
 797     /* Perform various other tests; that is, this bpstat does not
 798        say to perform any action (e.g. failed watchpoint and nothing
 799        else).  */
 800     BPSTAT_WHAT_KEEP_CHECKING,
 801
 802     /* Remove breakpoints, single step once, then put them back in and
 803        go back to what we were doing.  It's possible that this should
 804        be removed from the main_action and put into a separate field,
 805        to more cleanly handle
 806        BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE.  */
 807     BPSTAT_WHAT_SINGLE,
 808
 809     /* Set longjmp_resume breakpoint, remove all other breakpoints,
 810        and continue.  The "remove all other breakpoints" part is
 811        required if we are also stepping over another breakpoint as
 812        well as doing the longjmp handling.  */
 813     BPSTAT_WHAT_SET_LONGJMP_RESUME,
 814
 815     /* Clear longjmp_resume breakpoint, then handle as
 816        BPSTAT_WHAT_KEEP_CHECKING.  */
 817     BPSTAT_WHAT_CLEAR_LONGJMP_RESUME,
 818
 819     /* Clear step resume breakpoint, and keep checking.  */
 820     BPSTAT_WHAT_STEP_RESUME,
 821
 822     /* Rather than distinguish between noisy and silent stops here, it
 823        might be cleaner to have bpstat_print make that decision (also
 824        taking into account stop_print_frame and source_only).  But the
 825        implications are a bit scary (interaction with auto-displays,
 826        etc.), so I won't try it.  */
 827
 828     /* Stop silently.  */
 829     BPSTAT_WHAT_STOP_SILENT,
 830
 831     /* Stop and print.  */
 832     BPSTAT_WHAT_STOP_NOISY,
 833
 834     /* Clear step resume breakpoint, and keep checking.  High-priority
 835        step-resume breakpoints are used when even if there's a user
 836        breakpoint at the current PC when we set the step-resume
 837        breakpoint, we don't want to re-handle any breakpoint other
 838        than the step-resume when it's hit; instead we want to move
 839        past the breakpoint.  This is used in the case of skipping
 840        signal handlers.  */
 841     BPSTAT_WHAT_HP_STEP_RESUME,
 842   };
 843
 844 /* An enum indicating the kind of "stack dummy" stop.  This is a bit
 845    of a misnomer because only one kind of truly a stack dummy.  */
 846 enum stop_stack_kind
 847   {
 848     /* We didn't stop at a stack dummy breakpoint.  */
 849     STOP_NONE = 0,
 850
 851     /* Stopped at a stack dummy.  */
 852     STOP_STACK_DUMMY,
 853
 854     /* Stopped at std::terminate.  */
 855     STOP_STD_TERMINATE
 856   };
 857
 858 struct bpstat_what
 859   {
 860     enum bpstat_what_main_action main_action;
 861
 862     /* Did we hit a call dummy breakpoint?  This only goes with a
 863        main_action of BPSTAT_WHAT_STOP_SILENT or
 864        BPSTAT_WHAT_STOP_NOISY (the concept of continuing from a call
 865        dummy without popping the frame is not a useful one).  */
 866     enum stop_stack_kind call_dummy;
 867
 868     /* Used for BPSTAT_WHAT_SET_LONGJMP_RESUME and
 869        BPSTAT_WHAT_CLEAR_LONGJMP_RESUME.  True if we are handling a
 870        longjmp, false if we are handling an exception.  */
 871     int is_longjmp;
 872   };
 873
 874 /* The possible return values for print_bpstat, print_it_normal,
 875    print_it_done, print_it_noop.  */
 876 enum print_stop_action
 877   {
 878     /* We printed nothing or we need to do some more analysis.  */
 879     PRINT_UNKNOWN = -1,
 880
 881     /* We printed something, and we *do* desire that something to be
 882        followed by a location.  */
 883     PRINT_SRC_AND_LOC,
 884
 885     /* We printed something, and we do *not* desire that something to
 886        be followed by a location.  */
 887     PRINT_SRC_ONLY,
 888
 889     /* We already printed all we needed to print, don't print anything
 890        else.  */
 891     PRINT_NOTHING
 892   };
 893
 894 /* Tell what to do about this bpstat.  */
 895 struct bpstat_what bpstat_what (bpstat);
 896 \f
 897 /* Find the bpstat associated with a breakpoint.  NULL otherwise.  */
 898 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
 899
 900 /* Nonzero if a signal that we got in wait() was due to circumstances
 901    explained by the BS.  */
 902 /* Currently that is true if we have hit a breakpoint, or if there is
 903    a watchpoint enabled.  */
 904 #define bpstat_explains_signal(bs) ((bs) != NULL)
 905
 906 /* Nonzero is this bpstat causes a stop.  */
 907 extern int bpstat_causes_stop (bpstat);
 908
 909 /* Nonzero if we should step constantly (e.g. watchpoints on machines
 910    without hardware support).  This isn't related to a specific bpstat,
 911    just to things like whether watchpoints are set.  */
 912 extern int bpstat_should_step (void);
 913
 914 /* Print a message indicating what happened.  Returns nonzero to
 915    say that only the source line should be printed after this (zero
 916    return means print the frame as well as the source line).  */
 917 extern enum print_stop_action bpstat_print (bpstat, int);
 918
 919 /* Put in *NUM the breakpoint number of the first breakpoint we are
 920    stopped at.  *BSP upon return is a bpstat which points to the
 921    remaining breakpoints stopped at (but which is not guaranteed to be
 922    good for anything but further calls to bpstat_num).
 923
 924    Return 0 if passed a bpstat which does not indicate any breakpoints.
 925    Return -1 if stopped at a breakpoint that has been deleted since
 926    we set it.
 927    Return 1 otherwise.  */
 928 extern int bpstat_num (bpstat *, int *);
 929
 930 /* Perform actions associated with the stopped inferior.  Actually, we
 931    just use this for breakpoint commands.  Perhaps other actions will
 932    go here later, but this is executed at a late time (from the
 933    command loop).  */
 934 extern void bpstat_do_actions (void);
 935
 936 /* Modify all entries of STOP_BPSTAT of INFERIOR_PTID so that the actions will
 937    not be performed.  */
 938 extern void bpstat_clear_actions (void);
 939
 940 /* Implementation:  */
 941
 942 /* Values used to tell the printing routine how to behave for this
 943    bpstat.  */
 944 enum bp_print_how
 945   {
 946     /* This is used when we want to do a normal printing of the reason
 947        for stopping.  The output will depend on the type of eventpoint
 948        we are dealing with.  This is the default value, most commonly
 949        used.  */
 950     print_it_normal,
 951     /* This is used when nothing should be printed for this bpstat
 952        entry.  */
 953     print_it_noop,
 954     /* This is used when everything which needs to be printed has
 955        already been printed.  But we still want to print the frame.  */
 956     print_it_done
 957   };
 958
 959 struct bpstats
 960   {
 961     /* Linked list because there can be more than one breakpoint at
 962        the same place, and a bpstat reflects the fact that all have
 963        been hit.  */
 964     bpstat next;
 965
 966     /* Location that caused the stop.  Locations are refcounted, so
 967        this will never be NULL.  Note that this location may end up
 968        detached from a breakpoint, but that does not necessary mean
 969        that the struct breakpoint is gone.  E.g., consider a
 970        watchpoint with a condition that involves an inferior function
 971        call.  Watchpoint locations are recreated often (on resumes,
 972        hence on infcalls too).  Between creating the bpstat and after
 973        evaluating the watchpoint condition, this location may hence
 974        end up detached from its original owner watchpoint, even though
 975        the watchpoint is still listed.  If it's condition evaluates as
 976        true, we still want this location to cause a stop, and we will
 977        still need to know which watchpoint it was originally attached.
 978        What this means is that we should not (in most cases) follow
 979        the `bpstat->bp_location->owner' link, but instead use the
 980        `breakpoint_at' field below.  */
 981     struct bp_location *bp_location_at;
 982
 983     /* Breakpoint that caused the stop.  This is nullified if the
 984        breakpoint ends up being deleted.  See comments on
 985        `bp_location_at' above for why do we need this field instead of
 986        following the location's owner.  */
 987     struct breakpoint *breakpoint_at;
 988
 989     /* The associated command list.  */
 990     struct counted_command_line *commands;
 991
 992     /* Old value associated with a watchpoint.  */
 993     struct value *old_val;
 994
 995     /* Nonzero if this breakpoint tells us to print the frame.  */
 996     char print;
 997
 998     /* Nonzero if this breakpoint tells us to stop.  */
 999     char stop;
1000
1001     /* Tell bpstat_print and print_bp_stop_message how to print stuff
1002        associated with this element of the bpstat chain.  */
1003     enum bp_print_how print_it;
1004   };
1005
1006 enum inf_context
1007   {
1008     inf_starting,
1009     inf_running,
1010     inf_exited,
1011     inf_execd
1012   };
1013
1014 /* The possible return values for breakpoint_here_p.
1015    We guarantee that zero always means "no breakpoint here".  */
1016 enum breakpoint_here
1017   {
1018     no_breakpoint_here = 0,
1019     ordinary_breakpoint_here,
1020     permanent_breakpoint_here
1021   };
1022 \f
1023
1024 /* Prototypes for breakpoint-related functions.  */
1025
1026 extern enum breakpoint_here breakpoint_here_p (struct address_space *,
1027                                                CORE_ADDR);
1028
1029 extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
1030
1031 extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
1032
1033 extern int regular_breakpoint_inserted_here_p (struct address_space *,
1034                                                CORE_ADDR);
1035
1036 extern int software_breakpoint_inserted_here_p (struct address_space *,
1037                                                 CORE_ADDR);
1038
1039 /* Returns true if there's a hardware watchpoint or access watchpoint
1040    inserted in the range defined by ADDR and LEN.  */
1041 extern int hardware_watchpoint_inserted_in_range (struct address_space *,
1042                                                   CORE_ADDR addr,
1043                                                   ULONGEST len);
1044
1045 extern int breakpoint_thread_match (struct address_space *,
1046                                     CORE_ADDR, ptid_t);
1047
1048 extern void until_break_command (char *, int, int);
1049
1050 /* Initialize a struct bp_location.  */
1051
1052 extern void init_bp_location (struct bp_location *loc,
1053                               const struct bp_location_ops *ops,
1054                               struct breakpoint *owner);
1055
1056 extern void update_breakpoint_locations (struct breakpoint *b,
1057                                          struct symtabs_and_lines sals,
1058                                          struct symtabs_and_lines sals_end);
1059
1060 extern void breakpoint_re_set (void);
1061
1062 extern void breakpoint_re_set_thread (struct breakpoint *);
1063
1064 extern struct breakpoint *set_momentary_breakpoint
1065   (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
1066
1067 extern struct breakpoint *set_momentary_breakpoint_at_pc
1068   (struct gdbarch *, CORE_ADDR pc, enum bptype type);
1069
1070 extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
1071
1072 extern void set_ignore_count (int, int, int);
1073
1074 extern void breakpoint_init_inferior (enum inf_context);
1075
1076 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
1077
1078 extern void delete_breakpoint (struct breakpoint *);
1079
1080 extern void breakpoint_auto_delete (bpstat);
1081
1082 /* Return the chain of command lines to execute when this breakpoint
1083    is hit.  */
1084 extern struct command_line *breakpoint_commands (struct breakpoint *b);
1085
1086 /* Return a string image of DISP.  The string is static, and thus should
1087    NOT be deallocated after use.  */
1088 const char *bpdisp_text (enum bpdisp disp);
1089
1090 extern void break_command (char *, int);
1091
1092 extern void hbreak_command_wrapper (char *, int);
1093 extern void thbreak_command_wrapper (char *, int);
1094 extern void rbreak_command_wrapper (char *, int);
1095 extern void watch_command_wrapper (char *, int, int);
1096 extern void awatch_command_wrapper (char *, int, int);
1097 extern void rwatch_command_wrapper (char *, int, int);
1098 extern void tbreak_command (char *, int);
1099
1100 extern struct breakpoint_ops bkpt_breakpoint_ops;
1101
1102 extern void initialize_breakpoint_ops (void);
1103
1104 /* Arguments to pass as context to some catch command handlers.  */
1105 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
1106 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
1107
1108 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
1109    lists, and pass some additional user data to the command
1110    function.  */
1111
1112 extern void
1113   add_catch_command (char *name, char *docstring,
1114                      void (*sfunc) (char *args, int from_tty,
1115                                     struct cmd_list_element *command),
1116                      char **(*completer) (struct cmd_list_element *cmd,
1117                                           char *text, char *word),
1118                      void *user_data_catch,
1119                      void *user_data_tcatch);
1120
1121 /* Initialize a breakpoint struct for Ada exception catchpoints.  */
1122
1123 extern void
1124   init_ada_exception_breakpoint (struct breakpoint *b,
1125                                  struct gdbarch *gdbarch,
1126                                  struct symtab_and_line sal,
1127                                  char *addr_string,
1128                                  const struct breakpoint_ops *ops,
1129                                  int tempflag,
1130                                  int from_tty);
1131
1132 /* Add breakpoint B on the breakpoint list, and notify the user, the
1133    target and breakpoint_created observers of its existence.  If
1134    INTERNAL is non-zero, the breakpoint number will be allocated from
1135    the internal breakpoint count.  If UPDATE_GLL is non-zero,
1136    update_global_location_list will be called.  */
1137
1138 extern void install_breakpoint (int internal, struct breakpoint *b,
1139                                 int update_gll);
1140
1141 extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
1142                               char *cond_string, int thread,
1143                               int parse_condition_and_thread,
1144                               int tempflag, enum bptype wanted_type,
1145                               int ignore_count,
1146                               enum auto_boolean pending_break_support,
1147                               const struct breakpoint_ops *ops,
1148                               int from_tty,
1149                               int enabled,
1150                               int internal);
1151
1152 extern void insert_breakpoints (void);
1153
1154 extern int remove_breakpoints (void);
1155
1156 extern int remove_breakpoints_pid (int pid);
1157
1158 /* This function can be used to physically insert eventpoints from the
1159    specified traced inferior process, without modifying the breakpoint
1160    package's state.  This can be useful for those targets which
1161    support following the processes of a fork() or vfork() system call,
1162    when both of the resulting two processes are to be followed.  */
1163 extern int reattach_breakpoints (int);
1164
1165 /* This function can be used to update the breakpoint package's state
1166    after an exec() system call has been executed.
1167
1168    This function causes the following:
1169
1170    - All eventpoints are marked "not inserted".
1171    - All eventpoints with a symbolic address are reset such that
1172    the symbolic address must be reevaluated before the eventpoints
1173    can be reinserted.
1174    - The solib breakpoints are explicitly removed from the breakpoint
1175    list.
1176    - A step-resume breakpoint, if any, is explicitly removed from the
1177    breakpoint list.
1178    - All eventpoints without a symbolic address are removed from the
1179    breakpoint list.  */
1180 extern void update_breakpoints_after_exec (void);
1181
1182 /* This function can be used to physically remove hardware breakpoints
1183    and watchpoints from the specified traced inferior process, without
1184    modifying the breakpoint package's state.  This can be useful for
1185    those targets which support following the processes of a fork() or
1186    vfork() system call, when one of the resulting two processes is to
1187    be detached and allowed to run free.
1188
1189    It is an error to use this function on the process whose id is
1190    inferior_ptid.  */
1191 extern int detach_breakpoints (int);
1192
1193 /* This function is called when program space PSPACE is about to be
1194    deleted.  It takes care of updating breakpoints to not reference
1195    this PSPACE anymore.  */
1196 extern void breakpoint_program_space_exit (struct program_space *pspace);
1197
1198 extern void set_longjmp_breakpoint (struct thread_info *tp,
1199                                     struct frame_id frame);
1200 extern void delete_longjmp_breakpoint (int thread);
1201
1202 extern void enable_overlay_breakpoints (void);
1203 extern void disable_overlay_breakpoints (void);
1204
1205 extern void set_std_terminate_breakpoint (void);
1206 extern void delete_std_terminate_breakpoint (void);
1207
1208 /* These functions respectively disable or reenable all currently
1209    enabled watchpoints.  When disabled, the watchpoints are marked
1210    call_disabled.  When re-enabled, they are marked enabled.
1211
1212    The intended client of these functions is call_function_by_hand.
1213
1214    The inferior must be stopped, and all breakpoints removed, when
1215    these functions are used.
1216
1217    The need for these functions is that on some targets (e.g., HP-UX),
1218    gdb is unable to unwind through the dummy frame that is pushed as
1219    part of the implementation of a call command.  Watchpoints can
1220    cause the inferior to stop in places where this frame is visible,
1221    and that can cause execution control to become very confused.
1222
1223    Note that if a user sets breakpoints in an interactively called
1224    function, the call_disabled watchpoints will have been re-enabled
1225    when the first such breakpoint is reached.  However, on targets
1226    that are unable to unwind through the call dummy frame, watches
1227    of stack-based storage may then be deleted, because gdb will
1228    believe that their watched storage is out of scope.  (Sigh.) */
1229 extern void disable_watchpoints_before_interactive_call_start (void);
1230
1231 extern void enable_watchpoints_after_interactive_call_stop (void);
1232
1233 /* These functions disable and re-enable all breakpoints during
1234    inferior startup.  They are intended to be called from solib
1235    code where necessary.  This is needed on platforms where the
1236    main executable is relocated at some point during startup
1237    processing, making breakpoint addresses invalid.
1238
1239    If additional breakpoints are created after the routine
1240    disable_breakpoints_before_startup but before the routine
1241    enable_breakpoints_after_startup was called, they will also
1242    be marked as disabled.  */
1243 extern void disable_breakpoints_before_startup (void);
1244 extern void enable_breakpoints_after_startup (void);
1245
1246 /* For script interpreters that need to define breakpoint commands
1247    after they've already read the commands into a struct
1248    command_line.  */
1249 extern enum command_control_type commands_from_control_command
1250   (char *arg, struct command_line *cmd);
1251
1252 extern void clear_breakpoint_hit_counts (void);
1253
1254 extern struct breakpoint *get_breakpoint (int num);
1255
1256 /* The following are for displays, which aren't really breakpoints,
1257    but here is as good a place as any for them.  */
1258
1259 extern void disable_current_display (void);
1260
1261 extern void do_displays (void);
1262
1263 extern void disable_display (int);
1264
1265 extern void clear_displays (void);
1266
1267 extern void disable_breakpoint (struct breakpoint *);
1268
1269 extern void enable_breakpoint (struct breakpoint *);
1270
1271 extern void breakpoint_set_commands (struct breakpoint *b,
1272                                      struct command_line *commands);
1273
1274 extern void breakpoint_set_silent (struct breakpoint *b, int silent);
1275
1276 extern void breakpoint_set_thread (struct breakpoint *b, int thread);
1277
1278 extern void breakpoint_set_task (struct breakpoint *b, int task);
1279
1280 /* Clear the "inserted" flag in all breakpoints.  */
1281 extern void mark_breakpoints_out (void);
1282
1283 extern void make_breakpoint_permanent (struct breakpoint *);
1284
1285 extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
1286                                                        CORE_ADDR);
1287
1288 extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
1289                                                          CORE_ADDR);
1290
1291 extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
1292                                                           CORE_ADDR);
1293
1294 extern void remove_jit_event_breakpoints (void);
1295
1296 extern void remove_solib_event_breakpoints (void);
1297
1298 extern void remove_thread_event_breakpoints (void);
1299
1300 extern void disable_breakpoints_in_shlibs (void);
1301
1302 /* This function returns TRUE if ep is a catchpoint.  */
1303 extern int ep_is_catchpoint (struct breakpoint *);
1304
1305 /* Enable breakpoints and delete when hit.  Called with ARG == NULL
1306    deletes all breakpoints.  */
1307 extern void delete_command (char *arg, int from_tty);
1308
1309 /* Manage a software single step breakpoint (or two).  Insert may be
1310    called twice before remove is called.  */
1311 extern void insert_single_step_breakpoint (struct gdbarch *,
1312                                            struct address_space *,
1313                                            CORE_ADDR);
1314 extern int single_step_breakpoints_inserted (void);
1315 extern void remove_single_step_breakpoints (void);
1316 extern void cancel_single_step_breakpoints (void);
1317
1318 /* Manage manual breakpoints, separate from the normal chain of
1319    breakpoints.  These functions are used in murky target-specific
1320    ways.  Please do not add more uses!  */
1321 extern void *deprecated_insert_raw_breakpoint (struct gdbarch *,
1322                                                struct address_space *,
1323                                                CORE_ADDR);
1324 extern int deprecated_remove_raw_breakpoint (struct gdbarch *, void *);
1325
1326 /* Check if any hardware watchpoints have triggered, according to the
1327    target.  */
1328 int watchpoints_triggered (struct target_waitstatus *);
1329
1330 /* Helper for transparent breakpoint hiding for memory read and write
1331    routines.
1332
1333    Update one of READBUF or WRITEBUF with either the shadows
1334    (READBUF), or the breakpoint instructions (WRITEBUF) of inserted
1335    breakpoints at the memory range defined by MEMADDR and extending
1336    for LEN bytes.  If writing, then WRITEBUF is a copy of WRITEBUF_ORG
1337    on entry.*/
1338 extern void breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1339                                     const gdb_byte *writebuf_org,
1340                                     ULONGEST memaddr, LONGEST len);
1341
1342 extern int breakpoints_always_inserted_mode (void);
1343
1344 /* Called each time new event from target is processed.
1345    Retires previously deleted breakpoint locations that
1346    in our opinion won't ever trigger.  */
1347 extern void breakpoint_retire_moribund (void);
1348
1349 /* Set break condition of breakpoint B to EXP.  */
1350 extern void set_breakpoint_condition (struct breakpoint *b, char *exp,
1351                                       int from_tty);
1352
1353 /* Checks if we are catching syscalls or not.
1354    Returns 0 if not, greater than 0 if we are.  */
1355 extern int catch_syscall_enabled (void);
1356
1357 /* Checks if we are catching syscalls with the specific
1358    syscall_number.  Used for "filtering" the catchpoints.
1359    Returns 0 if not, greater than 0 if we are.  */
1360 extern int catching_syscall_number (int syscall_number);
1361
1362 /* Return a tracepoint with the given number if found.  */
1363 extern struct tracepoint *get_tracepoint (int num);
1364
1365 extern struct tracepoint *get_tracepoint_by_number_on_target (int num);
1366
1367 /* Find a tracepoint by parsing a number in the supplied string.  */
1368 extern struct tracepoint *
1369      get_tracepoint_by_number (char **arg,
1370                                struct get_number_or_range_state *state,
1371                                int optional_p);
1372
1373 /* Return a vector of all tracepoints currently defined.  The vector
1374    is newly allocated; the caller should free when done with it.  */
1375 extern VEC(breakpoint_p) *all_tracepoints (void);
1376
1377 extern int is_tracepoint (const struct breakpoint *b);
1378
1379 /* Return a vector of all static tracepoints defined at ADDR.  The
1380    vector is newly allocated; the caller should free when done with
1381    it.  */
1382 extern VEC(breakpoint_p) *static_tracepoints_here (CORE_ADDR addr);
1383
1384 /* Function that can be passed to read_command_line to validate
1385    that each command is suitable for tracepoint command list.  */
1386 extern void check_tracepoint_command (char *line, void *closure);
1387
1388 /* Call at the start and end of an "rbreak" command to register
1389    breakpoint numbers for a later "commands" command.  */
1390 extern void start_rbreak_breakpoints (void);
1391 extern void end_rbreak_breakpoints (void);
1392
1393 /* Breakpoint iterator function.
1394
1395    Calls a callback function once for each breakpoint, so long as the
1396    callback function returns false.  If the callback function returns
1397    true, the iteration will end and the current breakpoint will be
1398    returned.  This can be useful for implementing a search for a
1399    breakpoint with arbitrary attributes, or for applying an operation
1400    to every breakpoint.  */
1401 extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *,
1402                                                              void *), void *);
1403
1404 /* Nonzero if the specified PC cannot be a location where functions
1405    have been inlined.  */
1406
1407 extern int pc_at_non_inline_function (struct address_space *aspace,
1408                                       CORE_ADDR pc);
1409
1410 extern int user_breakpoint_p (struct breakpoint *);
1411
1412 /* Attempt to determine architecture of location identified by SAL.  */
1413 extern struct gdbarch *get_sal_arch (struct symtab_and_line sal);
1414
1415 #endif /* !defined (BREAKPOINT_H) */