GDB (xrefs)
/tmp/gdb-7.10/gdb/breakpoint.h
Go to the documentation of this file.
1 /* Data structures associated with breakpoints in GDB.
2  Copyright (C) 1992-2015 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 #include "ax.h"
26 #include "command.h"
27 #include "break-common.h"
28 #include "probe.h"
29 
30 struct value;
31 struct block;
35 struct thread_info;
36 struct bpstats;
37 struct bp_location;
38 struct linespec_result;
39 struct linespec_sals;
40 
41 /* This is the maximum number of bytes a breakpoint instruction can
42  take. Feel free to increase it. It's just used in a few places to
43  size arrays that should be independent of the target
44  architecture. */
45 
46 #define BREAKPOINT_MAX 16
47 
48 
49 /* Type of breakpoint. */
50 
51 enum bptype
52  {
53  bp_none = 0, /* Eventpoint has been deleted */
54  bp_breakpoint, /* Normal breakpoint */
55  bp_hardware_breakpoint, /* Hardware assisted breakpoint */
56  bp_single_step, /* Software single-step */
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  /* Breakpoint placed to the same location(s) like bp_longjmp but used to
67  protect against stale DUMMY_FRAME. Multiple bp_longjmp_call_dummy and
68  one bp_call_dummy are chained together by related_breakpoint for each
69  DUMMY_FRAME. */
71 
72  /* An internal breakpoint that is installed on the unwinder's
73  debug hook. */
75  /* An internal breakpoint that is set at the point where an
76  exception will land. */
78 
79  /* Used by wait_for_inferior for stepping over subroutine calls,
80  and for skipping prologues. */
82 
83  /* Used by wait_for_inferior for stepping over signal
84  handlers. */
86 
87  /* Used to detect when a watchpoint expression has gone out of
88  scope. These breakpoints are usually not visible to the user.
89 
90  This breakpoint has some interesting properties:
91 
92  1) There's always a 1:1 mapping between watchpoints
93  on local variables and watchpoint_scope breakpoints.
94 
95  2) It automatically deletes itself and the watchpoint it's
96  associated with when hit.
97 
98  3) It can never be disabled. */
100 
101  /* The breakpoint at the end of a call dummy. See bp_longjmp_call_dummy it
102  is chained with by related_breakpoint. */
104 
105  /* A breakpoint set on std::terminate, that is used to catch
106  otherwise uncaught exceptions thrown during an inferior call. */
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. */
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 
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 
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 
143 
144  /* Master copies of std::terminate breakpoints. */
146 
147  /* Like bp_longjmp_master, but for exceptions. */
149 
151 
155 
156  /* A dynamic printf stops at the given location, does a formatted
157  print, then automatically continues. (Although this is sort of
158  like a macro packaging up standard breakpoint functionality,
159  GDB doesn't have a way to construct types of breakpoint from
160  elements of behavior.) */
162 
163  /* Event for JIT compiled code generation or deletion. */
165 
166  /* Breakpoint is placed at the STT_GNU_IFUNC resolver. When hit GDB
167  inserts new bp_gnu_ifunc_resolver_return at the caller.
168  bp_gnu_ifunc_resolver is still being kept here as a different thread
169  may still hit it before bp_gnu_ifunc_resolver_return is hit by the
170  original thread. */
172 
173  /* On its hit GDB now know the resolved address of the target
174  STT_GNU_IFUNC function. Associated bp_gnu_ifunc_resolver can be
175  deleted now and the breakpoint moved to the target function entry
176  point. */
178  };
179 
180 /* States of enablement of breakpoint. */
181 
183  {
184  bp_disabled, /* The eventpoint is inactive, and cannot
185  trigger. */
186  bp_enabled, /* The eventpoint is active, and can
187  trigger. */
188  bp_call_disabled, /* The eventpoint has been disabled while a
189  call into the inferior is "in flight",
190  because some eventpoints interfere with
191  the implementation of a call on some
192  targets. The eventpoint will be
193  automatically enabled and reset when the
194  call "lands" (either completes, or stops
195  at another eventpoint). */
196  };
197 
198 
199 /* Disposition of breakpoint. Ie: what to do after hitting it. */
200 
201 enum bpdisp
202  {
203  disp_del, /* Delete it */
204  disp_del_at_next_stop, /* Delete at next stop,
205  whether hit or not */
206  disp_disable, /* Disable it */
207  disp_donttouch /* Leave it alone */
208  };
209 
210 /* Status of breakpoint conditions used when synchronizing
211  conditions with the target. */
212 
214  {
218  };
219 
220 /* Information used by targets to insert and remove breakpoints. */
221 
223 {
224  /* Address space at which the breakpoint was placed. */
226 
227  /* Address at which the breakpoint was placed. This is normally
228  the same as REQUESTED_ADDRESS, except when adjustment happens in
229  gdbarch_breakpoint_from_pc. The most common form of adjustment
230  is stripping an alternate ISA marker from the PC which is used
231  to determine the type of breakpoint to insert. */
233 
234  /* Address at which the breakpoint was requested. */
236 
237  /* If this is a ranged breakpoint, then this field contains the
238  length of the range that will be watched for execution. */
239  int length;
240 
241  /* If the breakpoint lives in memory and reading that memory would
242  give back the breakpoint, instead of the original contents, then
243  the original contents are cached here. Only SHADOW_LEN bytes of
244  this buffer are valid, and only when the breakpoint is inserted. */
246 
247  /* The length of the data cached in SHADOW_CONTENTS. */
249 
250  /* The size of the placed breakpoint, according to
251  gdbarch_breakpoint_from_pc, when the breakpoint was inserted.
252  This is generally the same as SHADOW_LEN, unless we did not need
253  to read from the target to implement the memory breakpoint
254  (e.g. if a remote stub handled the details). We may still need
255  the size to remove the breakpoint safely. */
257 
258  /* Vector of conditions the target should evaluate if it supports target-side
259  breakpoint conditions. */
260  VEC(agent_expr_p) *conditions;
261 
262  /* Vector of commands the target should evaluate if it supports
263  target-side breakpoint commands. */
264  VEC(agent_expr_p) *tcommands;
265 
266  /* Flag that is true if the breakpoint should be left in place even
267  when GDB is not connected. */
268  int persist;
269 };
270 
271 /* GDB maintains two types of information about each breakpoint (or
272  watchpoint, or other related event). The first type corresponds
273  to struct breakpoint; this is a relatively high-level structure
274  which contains the source location(s), stopping conditions, user
275  commands to execute when the breakpoint is hit, and so forth.
276 
277  The second type of information corresponds to struct bp_location.
278  Each breakpoint has one or (eventually) more locations associated
279  with it, which represent target-specific and machine-specific
280  mechanisms for stopping the program. For instance, a watchpoint
281  expression may require multiple hardware watchpoints in order to
282  catch all changes in the value of the expression being watched. */
283 
285 {
289  bp_loc_other /* Miscellaneous... */
290 };
291 
292 /* This structure is a collection of function pointers that, if
293  available, will be called instead of performing the default action
294  for this bp_loc_type. */
295 
297 {
298  /* Destructor. Releases everything from SELF (but not SELF
299  itself). */
300  void (*dtor) (struct bp_location *self);
301 };
302 
304 {
305  /* Chain pointer to the next breakpoint location for
306  the same parent breakpoint. */
307  struct bp_location *next;
308 
309  /* Methods associated with this location. */
310  const struct bp_location_ops *ops;
311 
312  /* The reference count. */
313  int refc;
314 
315  /* Type of this breakpoint location. */
317 
318  /* Each breakpoint location must belong to exactly one higher-level
319  breakpoint. This pointer is NULL iff this bp_location is no
320  longer attached to a breakpoint. For example, when a breakpoint
321  is deleted, its locations may still be found in the
322  moribund_locations list, or if we had stopped for it, in
323  bpstats. */
324  struct breakpoint *owner;
325 
326  /* Conditional. Break only if this expression's value is nonzero.
327  Unlike string form of condition, which is associated with
328  breakpoint, this is associated with location, since if breakpoint
329  has several locations, the evaluation of expression can be
330  different for different locations. Only valid for real
331  breakpoints; a watchpoint's conditional expression is stored in
332  the owner breakpoint object. */
333  struct expression *cond;
334 
335  /* Conditional expression in agent expression
336  bytecode form. This is used for stub-side breakpoint
337  condition evaluation. */
339 
340  /* Signals that the condition has changed since the last time
341  we updated the global location list. This means the condition
342  needs to be sent to the target again. This is used together
343  with target-side breakpoint conditions.
344 
345  condition_unchanged: It means there has been no condition changes.
346 
347  condition_modified: It means this location had its condition modified.
348 
349  condition_updated: It means we already marked all the locations that are
350  duplicates of this location and thus we don't need to call
351  force_breakpoint_reinsertion (...) for this location. */
352 
354 
356 
357  /* Signals that breakpoint conditions and/or commands need to be
358  re-synched with the target. This has no use other than
359  target-side breakpoints. */
361 
362  /* This location's address is in an unloaded solib, and so this
363  location should not be inserted. It will be automatically
364  enabled when that solib is loaded. */
366 
367  /* Is this particular location enabled. */
368  char enabled;
369 
370  /* Nonzero if this breakpoint is now inserted. */
371  char inserted;
372 
373  /* Nonzero if this is a permanent breakpoint. There is a breakpoint
374  instruction hard-wired into the target's code. Don't try to
375  write another breakpoint instruction on top of it, or restore its
376  value. Step over it using the architecture's
377  gdbarch_skip_permanent_breakpoint method. */
378  char permanent;
379 
380  /* Nonzero if this is not the first breakpoint in the list
381  for the given address. location of tracepoint can _never_
382  be duplicated with other locations of tracepoints and other
383  kinds of breakpoints, because two locations at the same
384  address may have different actions, so both of these locations
385  should be downloaded and so that `tfind N' always works. */
386  char duplicate;
387 
388  /* If we someday support real thread-specific breakpoints, then
389  the breakpoint location will need a thread identifier. */
390 
391  /* Data for specific breakpoint types. These could be a union, but
392  simplicity is more important than memory usage for breakpoints. */
393 
394  /* Architecture associated with this location's address. May be
395  different from the breakpoint architecture. */
396  struct gdbarch *gdbarch;
397 
398  /* The program space associated with this breakpoint location
399  address. Note that an address space may be represented in more
400  than one program space (e.g. each uClinux program will be given
401  its own program space, but there will only be one address space
402  for all of them), but we must not insert more than one location
403  at the same address in the same address space. */
405 
406  /* Note that zero is a perfectly valid code address on some platforms
407  (for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL
408  is not a special value for this field. Valid for all types except
409  bp_loc_other. */
411 
412  /* For hardware watchpoints, the size of the memory region being
413  watched. For hardware ranged breakpoints, the size of the
414  breakpoint range. */
415  int length;
416 
417  /* Type of hardware watchpoint. */
419 
420  /* For any breakpoint type with an address, this is the section
421  associated with the address. Used primarily for overlay
422  debugging. */
424 
425  /* Address at which breakpoint was requested, either by the user or
426  by GDB for internal breakpoints. This will usually be the same
427  as ``address'' (above) except for cases in which
428  ADJUST_BREAKPOINT_ADDRESS has computed a different address at
429  which to place the breakpoint in order to comply with a
430  processor's architectual constraints. */
432 
433  /* An additional address assigned with this location. This is currently
434  only used by STT_GNU_IFUNC resolver breakpoints to hold the address
435  of the resolver function. */
437 
438  /* If the location comes from a probe point, this is the probe associated
439  with it. */
441 
443 
444  /* Details of the placed breakpoint, when inserted. */
446 
447  /* Similarly, for the breakpoint at an overlay's LMA, if necessary. */
449 
450  /* In a non-stop mode, it's possible that we delete a breakpoint,
451  but as we do that, some still running thread hits that breakpoint.
452  For that reason, we need to keep locations belonging to deleted
453  breakpoints for a bit, so that don't report unexpected SIGTRAP.
454  We can't keep such locations forever, so we use a heuristic --
455  after we process certain number of inferior events since
456  breakpoint was deleted, we retire all locations of that breakpoint.
457  This variable keeps a number of events still to go, when
458  it becomes 0 this location is retired. */
460 
461  /* Line number which was used to place this location.
462 
463  Breakpoint placed into a comment keeps it's user specified line number
464  despite ADDRESS resolves into a different line number. */
465 
467 
468  /* Symtab which was used to place this location. This is used
469  to find the corresponding source file name. */
470 
471  struct symtab *symtab;
472 };
473 
474 /* The possible return values for print_bpstat, print_it_normal,
475  print_it_done, print_it_noop. */
477 {
478  /* We printed nothing or we need to do some more analysis. */
480 
481  /* We printed something, and we *do* desire that something to be
482  followed by a location. */
484 
485  /* We printed something, and we do *not* desire that something to be
486  followed by a location. */
488 
489  /* We already printed all we needed to print, don't print anything
490  else. */
492 };
493 
494 /* This structure is a collection of function pointers that, if available,
495  will be called instead of the performing the default action for this
496  bptype. */
497 
499 {
500  /* Destructor. Releases everything from SELF (but not SELF
501  itself). */
502  void (*dtor) (struct breakpoint *self);
503 
504  /* Allocate a location for this breakpoint. */
505  struct bp_location * (*allocate_location) (struct breakpoint *);
506 
507  /* Reevaluate a breakpoint. This is necessary after symbols change
508  (e.g., an executable or DSO was loaded, or the inferior just
509  started). */
510  void (*re_set) (struct breakpoint *self);
511 
512  /* Insert the breakpoint or watchpoint or activate the catchpoint.
513  Return 0 for success, 1 if the breakpoint, watchpoint or
514  catchpoint type is not supported, -1 for failure. */
516 
517  /* Remove the breakpoint/catchpoint that was previously inserted
518  with the "insert" method above. Return 0 for success, 1 if the
519  breakpoint, watchpoint or catchpoint type is not supported,
520  -1 for failure. */
522 
523  /* Return true if it the target has stopped due to hitting
524  breakpoint location BL. This function does not check if we
525  should stop, only if BL explains the stop. ASPACE is the address
526  space in which the event occurred, BP_ADDR is the address at
527  which the inferior stopped, and WS is the target_waitstatus
528  describing the event. */
529  int (*breakpoint_hit) (const struct bp_location *bl,
530  struct address_space *aspace,
531  CORE_ADDR bp_addr,
532  const struct target_waitstatus *ws);
533 
534  /* Check internal conditions of the breakpoint referred to by BS.
535  If we should not stop for this breakpoint, set BS->stop to 0. */
536  void (*check_status) (struct bpstats *bs);
537 
538  /* Tell how many hardware resources (debug registers) are needed
539  for this breakpoint. If this function is not provided, then
540  the breakpoint or watchpoint needs one debug register. */
541  int (*resources_needed) (const struct bp_location *);
542 
543  /* Tell whether we can downgrade from a hardware watchpoint to a software
544  one. If not, the user will not be able to enable the watchpoint when
545  there are not enough hardware resources available. */
546  int (*works_in_software_mode) (const struct breakpoint *);
547 
548  /* The normal print routine for this breakpoint, called when we
549  hit it. */
550  enum print_stop_action (*print_it) (struct bpstats *bs);
551 
552  /* Display information about this breakpoint, for "info
553  breakpoints". */
554  void (*print_one) (struct breakpoint *, struct bp_location **);
555 
556  /* Display extra information about this breakpoint, below the normal
557  breakpoint description in "info breakpoints".
558 
559  In the example below, the "address range" line was printed
560  by print_one_detail_ranged_breakpoint.
561 
562  (gdb) info breakpoints
563  Num Type Disp Enb Address What
564  2 hw breakpoint keep y in main at test-watch.c:70
565  address range: [0x10000458, 0x100004c7]
566 
567  */
568  void (*print_one_detail) (const struct breakpoint *, struct ui_out *);
569 
570  /* Display information about this breakpoint after setting it
571  (roughly speaking; this is called from "mention"). */
572  void (*print_mention) (struct breakpoint *);
573 
574  /* Print to FP the CLI command that recreates this breakpoint. */
575  void (*print_recreate) (struct breakpoint *, struct ui_file *fp);
576 
577  /* Create SALs from address string, storing the result in linespec_result.
578 
579  For an explanation about the arguments, see the function
580  `create_sals_from_address_default'.
581 
582  This function is called inside `create_breakpoint'. */
583  void (*create_sals_from_address) (char **, struct linespec_result *,
584  enum bptype, char *, char **);
585 
586  /* This method will be responsible for creating a breakpoint given its SALs.
587  Usually, it just calls `create_breakpoints_sal' (for ordinary
588  breakpoints). However, there may be some special cases where we might
589  need to do some tweaks, e.g., see
590  `strace_marker_create_breakpoints_sal'.
591 
592  This function is called inside `create_breakpoint'. */
593  void (*create_breakpoints_sal) (struct gdbarch *,
594  struct linespec_result *,
595  char *, char *,
596  enum bptype, enum bpdisp, int, int,
597  int, const struct breakpoint_ops *,
598  int, int, int, unsigned);
599 
600  /* Given the address string (second parameter), this method decodes it
601  and provides the SAL locations related to it. For ordinary breakpoints,
602  it calls `decode_line_full'.
603 
604  This function is called inside `addr_string_to_sals'. */
605  void (*decode_linespec) (struct breakpoint *, char **,
606  struct symtabs_and_lines *);
607 
608  /* Return true if this breakpoint explains a signal. See
609  bpstat_explains_signal. */
610  int (*explains_signal) (struct breakpoint *, enum gdb_signal);
611 
612  /* Called after evaluating the breakpoint's condition,
613  and only if it evaluated true. */
614  void (*after_condition_true) (struct bpstats *bs);
615 };
616 
617 /* Helper for breakpoint_ops->print_recreate implementations. Prints
618  the "thread" or "task" condition of B, and then a newline.
619 
620  Necessary because most breakpoint implementations accept
621  thread/task conditions at the end of the spec line, like "break foo
622  thread 1", which needs outputting before any breakpoint-type
623  specific extra command necessary for B's recreation. */
624 extern void print_recreate_thread (struct breakpoint *b, struct ui_file *fp);
625 
627 {
628  /* This watchpoint definitely did not trigger. */
630 
631  /* Some hardware watchpoint triggered, and it might have been this
632  one, but we do not know which it was. */
634 
635  /* This hardware watchpoint definitely did trigger. */
637 };
638 
639 typedef struct bp_location *bp_location_p;
640 DEF_VEC_P(bp_location_p);
641 
642 /* A reference-counted struct command_line. This lets multiple
643  breakpoints share a single command list. This is an implementation
644  detail to the breakpoints module. */
645 struct counted_command_line;
646 
647 /* Some targets (e.g., embedded PowerPC) need two debug registers to set
648  a watchpoint over a memory region. If this flag is true, GDB will use
649  only one register per watchpoint, thus assuming that all acesses that
650  modify a memory location happen at its starting address. */
651 
652 extern int target_exact_watchpoints;
653 
654 /* Note that the ->silent field is not currently used by any commands
655  (though the code is in there if it was to be, and set_raw_breakpoint
656  does set it to 0). I implemented it because I thought it would be
657  useful for a hack I had to put in; I'm going to leave it in because
658  I can see how there might be times when it would indeed be useful */
659 
660 /* This is for all kinds of breakpoints. */
661 
663  {
664  /* Methods associated with this breakpoint. */
665  const struct breakpoint_ops *ops;
666 
667  struct breakpoint *next;
668  /* Type of breakpoint. */
669  enum bptype type;
670  /* Zero means disabled; remember the info but don't break here. */
672  /* What to do with this breakpoint after we hit it. */
674  /* Number assigned to distinguish breakpoints. */
675  int number;
676 
677  /* Location(s) associated with this high-level breakpoint. */
678  struct bp_location *loc;
679 
680  /* Non-zero means a silent breakpoint (don't print frame info
681  if we stop here). */
682  unsigned char silent;
683  /* Non-zero means display ADDR_STRING to the user verbatim. */
684  unsigned char display_canonical;
685  /* Number of stops at this breakpoint that should
686  be continued automatically before really stopping. */
688 
689  /* Number of stops at this breakpoint before it will be
690  disabled. */
692 
693  /* Chain of command lines to execute when this breakpoint is
694  hit. */
696  /* Stack depth (address of frame). If nonzero, break only if fp
697  equals this. */
699 
700  /* The program space used to set the breakpoint. This is only set
701  for breakpoints which are specific to a program space; for
702  non-thread-specific ordinary breakpoints this is NULL. */
704 
705  /* String we used to set the breakpoint (malloc'd). */
706  char *addr_string;
707 
708  /* The filter that should be passed to decode_line_full when
709  re-setting this breakpoint. This may be NULL, but otherwise is
710  allocated with xmalloc. */
711  char *filter;
712 
713  /* For a ranged breakpoint, the string we used to find
714  the end of the range (malloc'd). */
716 
717  /* Architecture we used to set the breakpoint. */
718  struct gdbarch *gdbarch;
719  /* Language we used to set the breakpoint. */
721  /* Input radix we used to set the breakpoint. */
723  /* String form of the breakpoint condition (malloc'd), or NULL if
724  there is no condition. */
725  char *cond_string;
726 
727  /* String form of extra parameters, or NULL if there are none.
728  Malloc'd. */
730 
731  /* Holds the address of the related watchpoint_scope breakpoint
732  when using watchpoints on local variables (might the concept of
733  a related breakpoint be useful elsewhere, if not just call it
734  the watchpoint_scope breakpoint or something like that.
735  FIXME). */
737 
738  /* Thread number for thread-specific breakpoint,
739  or -1 if don't care. */
740  int thread;
741 
742  /* Ada task number for task-specific breakpoint,
743  or 0 if don't care. */
744  int task;
745 
746  /* Count of the number of times this breakpoint was taken, dumped
747  with the info, but not used for anything else. Useful for
748  seeing how many times you hit a break prior to the program
749  aborting, so you can back up to just before the abort. */
751 
752  /* Is breakpoint's condition not yet parsed because we found
753  no location initially so had no context to parse
754  the condition in. */
756 
757  /* With a Python scripting enabled GDB, store a reference to the
758  Python object that has been associated with this breakpoint.
759  This is always NULL for a GDB that is not script enabled. It
760  can sometimes be NULL for enabled GDBs as not all breakpoint
761  types are tracked by the scripting language API. */
763 
764  /* Same as py_bp_object, but for Scheme. */
766  };
767 
768 /* An instance of this type is used to represent a watchpoint. It
769  includes a "struct breakpoint" as a kind of base class; users
770  downcast to "struct breakpoint *" when needed. */
771 
773 {
774  /* The base class. */
775  struct breakpoint base;
776 
777  /* String form of exp to use for displaying to the user (malloc'd),
778  or NULL if none. */
779  char *exp_string;
780  /* String form to use for reparsing of EXP (malloc'd) or NULL. */
782 
783  /* The expression we are watching, or NULL if not a watchpoint. */
784  struct expression *exp;
785  /* The largest block within which it is valid, or NULL if it is
786  valid anywhere (e.g. consists just of global symbols). */
787  const struct block *exp_valid_block;
788  /* The conditional expression if any. */
790  /* The largest block within which it is valid, or NULL if it is
791  valid anywhere (e.g. consists just of global symbols). */
793  /* Value of the watchpoint the last time we checked it, or NULL when
794  we do not know the value yet or the value was not readable. VAL
795  is never lazy. */
796  struct value *val;
797  /* Nonzero if VAL is valid. If VAL_VALID is set but VAL is NULL,
798  then an error occurred reading the value. */
800 
801  /* When watching the location of a bitfield, contains the offset and size of
802  the bitfield. Otherwise contains 0. */
805 
806  /* Holds the frame address which identifies the frame this
807  watchpoint should be evaluated in, or `null' if the watchpoint
808  should be evaluated on the outermost frame. */
810 
811  /* Holds the thread which identifies the frame this watchpoint
812  should be considered in scope for, or `null_ptid' if the
813  watchpoint should be evaluated in all threads. */
815 
816  /* For hardware watchpoints, the triggered status according to the
817  hardware. */
819 
820  /* Whether this watchpoint is exact (see
821  target_exact_watchpoints). */
822  int exact;
823 
824  /* The mask address for a masked hardware watchpoint. */
826 };
827 
828 /* Given a function FUNC (struct breakpoint *B, void *DATA) and
829  USER_DATA, call FUNC for every known breakpoint passing USER_DATA
830  as argument.
831 
832  If FUNC returns 1, the loop stops and the current
833  'struct breakpoint' being processed is returned. If FUNC returns
834  zero, the loop continues.
835 
836  This function returns either a 'struct breakpoint' pointer or NULL.
837  It was based on BFD's bfd_sections_find_if function. */
838 
839 extern struct breakpoint *breakpoint_find_if
840  (int (*func) (struct breakpoint *b, void *d), void *user_data);
841 
842 /* Return true if BPT is either a software breakpoint or a hardware
843  breakpoint. */
844 
845 extern int is_breakpoint (const struct breakpoint *bpt);
846 
847 /* Returns true if BPT is really a watchpoint. */
848 
849 extern int is_watchpoint (const struct breakpoint *bpt);
850 
851 /* An instance of this type is used to represent all kinds of
852  tracepoints. It includes a "struct breakpoint" as a kind of base
853  class; users downcast to "struct breakpoint *" when needed. */
854 
856 {
857  /* The base class. */
858  struct breakpoint base;
859 
860  /* Number of times this tracepoint should single-step and collect
861  additional data. */
863 
864  /* Number of times this tracepoint should be hit before
865  disabling/ending. */
867 
868  /* The number of the tracepoint on the target. */
870 
871  /* The total space taken by all the trace frames for this
872  tracepoint. */
874 
875  /* The static tracepoint marker id, if known. */
877 
878  /* LTTng/UST allow more than one marker with the same ID string,
879  although it unadvised because it confuses tools. When setting
880  static tracepoints by marker ID, this will record the index in
881  the array of markers we found for the given marker ID for which
882  this static tracepoint corresponds. When resetting breakpoints,
883  we will use this index to try to find the same marker again. */
885 };
886 
887 typedef struct breakpoint *breakpoint_p;
888 DEF_VEC_P(breakpoint_p);
889 
890 /* The following stuff is an abstract data type "bpstat" ("breakpoint
891  status"). This provides the ability to determine whether we have
892  stopped at a breakpoint, and what we should do about it. */
893 
894 typedef struct bpstats *bpstat;
895 
896 /* Clears a chain of bpstat, freeing storage
897  of each. */
898 extern void bpstat_clear (bpstat *);
899 
900 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
901  is part of the bpstat is copied as well. */
902 extern bpstat bpstat_copy (bpstat);
903 
904 extern bpstat bpstat_stop_status (struct address_space *aspace,
905  CORE_ADDR pc, ptid_t ptid,
906  const struct target_waitstatus *ws);
907 
908 /* This bpstat_what stuff tells wait_for_inferior what to do with a
909  breakpoint (a challenging task).
910 
911  The enum values order defines priority-like order of the actions.
912  Once you've decided that some action is appropriate, you'll never
913  go back and decide something of a lower priority is better. Each
914  of these actions is mutually exclusive with the others. That
915  means, that if you find yourself adding a new action class here and
916  wanting to tell GDB that you have two simultaneous actions to
917  handle, something is wrong, and you probably don't actually need a
918  new action type.
919 
920  Note that a step resume breakpoint overrides another breakpoint of
921  signal handling (see comment in wait_for_inferior at where we set
922  the step_resume breakpoint). */
923 
925  {
926  /* Perform various other tests; that is, this bpstat does not
927  say to perform any action (e.g. failed watchpoint and nothing
928  else). */
930 
931  /* Remove breakpoints, single step once, then put them back in and
932  go back to what we were doing. It's possible that this should
933  be removed from the main_action and put into a separate field,
934  to more cleanly handle
935  BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */
937 
938  /* Set longjmp_resume breakpoint, remove all other breakpoints,
939  and continue. The "remove all other breakpoints" part is
940  required if we are also stepping over another breakpoint as
941  well as doing the longjmp handling. */
943 
944  /* Clear longjmp_resume breakpoint, then handle as
945  BPSTAT_WHAT_KEEP_CHECKING. */
947 
948  /* Clear step resume breakpoint, and keep checking. */
950 
951  /* Rather than distinguish between noisy and silent stops here, it
952  might be cleaner to have bpstat_print make that decision (also
953  taking into account stop_print_frame and source_only). But the
954  implications are a bit scary (interaction with auto-displays,
955  etc.), so I won't try it. */
956 
957  /* Stop silently. */
959 
960  /* Stop and print. */
962 
963  /* Clear step resume breakpoint, and keep checking. High-priority
964  step-resume breakpoints are used when even if there's a user
965  breakpoint at the current PC when we set the step-resume
966  breakpoint, we don't want to re-handle any breakpoint other
967  than the step-resume when it's hit; instead we want to move
968  past the breakpoint. This is used in the case of skipping
969  signal handlers. */
971  };
972 
973 /* An enum indicating the kind of "stack dummy" stop. This is a bit
974  of a misnomer because only one kind of truly a stack dummy. */
976  {
977  /* We didn't stop at a stack dummy breakpoint. */
979 
980  /* Stopped at a stack dummy. */
982 
983  /* Stopped at std::terminate. */
985  };
986 
988  {
990 
991  /* Did we hit a call dummy breakpoint? This only goes with a
992  main_action of BPSTAT_WHAT_STOP_SILENT or
993  BPSTAT_WHAT_STOP_NOISY (the concept of continuing from a call
994  dummy without popping the frame is not a useful one). */
996 
997  /* Used for BPSTAT_WHAT_SET_LONGJMP_RESUME and
998  BPSTAT_WHAT_CLEAR_LONGJMP_RESUME. True if we are handling a
999  longjmp, false if we are handling an exception. */
1001  };
1002 
1003 /* Tell what to do about this bpstat. */
1004 struct bpstat_what bpstat_what (bpstat);
1005 
1006 /* Find the bpstat associated with a breakpoint. NULL otherwise. */
1007 bpstat bpstat_find_breakpoint (bpstat, struct breakpoint *);
1008 
1009 /* Nonzero if a signal that we got in target_wait() was due to
1010  circumstances explained by the bpstat; the signal is therefore not
1011  random. */
1012 extern int bpstat_explains_signal (bpstat, enum gdb_signal);
1013 
1014 /* Nonzero is this bpstat causes a stop. */
1015 extern int bpstat_causes_stop (bpstat);
1016 
1017 /* Nonzero if we should step constantly (e.g. watchpoints on machines
1018  without hardware support). This isn't related to a specific bpstat,
1019  just to things like whether watchpoints are set. */
1020 extern int bpstat_should_step (void);
1021 
1022 /* Print a message indicating what happened. Returns nonzero to
1023  say that only the source line should be printed after this (zero
1024  return means print the frame as well as the source line). */
1025 extern enum print_stop_action bpstat_print (bpstat, int);
1026 
1027 /* Put in *NUM the breakpoint number of the first breakpoint we are
1028  stopped at. *BSP upon return is a bpstat which points to the
1029  remaining breakpoints stopped at (but which is not guaranteed to be
1030  good for anything but further calls to bpstat_num).
1031 
1032  Return 0 if passed a bpstat which does not indicate any breakpoints.
1033  Return -1 if stopped at a breakpoint that has been deleted since
1034  we set it.
1035  Return 1 otherwise. */
1036 extern int bpstat_num (bpstat *, int *);
1037 
1038 /* Perform actions associated with the stopped inferior. Actually, we
1039  just use this for breakpoint commands. Perhaps other actions will
1040  go here later, but this is executed at a late time (from the
1041  command loop). */
1042 extern void bpstat_do_actions (void);
1043 
1044 /* Modify all entries of STOP_BPSTAT of INFERIOR_PTID so that the actions will
1045  not be performed. */
1046 extern void bpstat_clear_actions (void);
1047 
1048 /* Implementation: */
1049 
1050 /* Values used to tell the printing routine how to behave for this
1051  bpstat. */
1053  {
1054  /* This is used when we want to do a normal printing of the reason
1055  for stopping. The output will depend on the type of eventpoint
1056  we are dealing with. This is the default value, most commonly
1057  used. */
1059  /* This is used when nothing should be printed for this bpstat
1060  entry. */
1062  /* This is used when everything which needs to be printed has
1063  already been printed. But we still want to print the frame. */
1065  };
1066 
1067 struct bpstats
1068  {
1069  /* Linked list because there can be more than one breakpoint at
1070  the same place, and a bpstat reflects the fact that all have
1071  been hit. */
1072  bpstat next;
1073 
1074  /* Location that caused the stop. Locations are refcounted, so
1075  this will never be NULL. Note that this location may end up
1076  detached from a breakpoint, but that does not necessary mean
1077  that the struct breakpoint is gone. E.g., consider a
1078  watchpoint with a condition that involves an inferior function
1079  call. Watchpoint locations are recreated often (on resumes,
1080  hence on infcalls too). Between creating the bpstat and after
1081  evaluating the watchpoint condition, this location may hence
1082  end up detached from its original owner watchpoint, even though
1083  the watchpoint is still listed. If it's condition evaluates as
1084  true, we still want this location to cause a stop, and we will
1085  still need to know which watchpoint it was originally attached.
1086  What this means is that we should not (in most cases) follow
1087  the `bpstat->bp_location->owner' link, but instead use the
1088  `breakpoint_at' field below. */
1090 
1091  /* Breakpoint that caused the stop. This is nullified if the
1092  breakpoint ends up being deleted. See comments on
1093  `bp_location_at' above for why do we need this field instead of
1094  following the location's owner. */
1096 
1097  /* The associated command list. */
1099 
1100  /* Old value associated with a watchpoint. */
1101  struct value *old_val;
1102 
1103  /* Nonzero if this breakpoint tells us to print the frame. */
1104  char print;
1105 
1106  /* Nonzero if this breakpoint tells us to stop. */
1107  char stop;
1108 
1109  /* Tell bpstat_print and print_bp_stop_message how to print stuff
1110  associated with this element of the bpstat chain. */
1112  };
1113 
1115  {
1120  };
1121 
1122 /* The possible return values for breakpoint_here_p.
1123  We guarantee that zero always means "no breakpoint here". */
1125  {
1129  };
1130 
1131 
1132 /* Prototypes for breakpoint-related functions. */
1133 
1134 /* Return 1 if there's a program/permanent breakpoint planted in
1135  memory at ADDRESS, return 0 otherwise. */
1136 
1138 
1139 extern enum breakpoint_here breakpoint_here_p (struct address_space *,
1140  CORE_ADDR);
1141 
1142 extern int moribund_breakpoint_here_p (struct address_space *, CORE_ADDR);
1143 
1144 extern int breakpoint_inserted_here_p (struct address_space *, CORE_ADDR);
1145 
1147  CORE_ADDR);
1148 
1150  CORE_ADDR);
1151 
1152 /* Return non-zero iff there is a hardware breakpoint inserted at
1153  PC. */
1155  CORE_ADDR);
1156 
1157 /* Check whether any location of BP is inserted at PC. */
1158 
1159 extern int breakpoint_has_location_inserted_here (struct breakpoint *bp,
1160  struct address_space *aspace,
1161  CORE_ADDR pc);
1162 
1164  CORE_ADDR);
1165 
1166 /* Returns true if there's a hardware watchpoint or access watchpoint
1167  inserted in the range defined by ADDR and LEN. */
1169  CORE_ADDR addr,
1170  ULONGEST len);
1171 
1172 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
1173  same breakpoint location. In most targets, this can only be true
1174  if ASPACE1 matches ASPACE2. On targets that have global
1175  breakpoints, the address space doesn't really matter. */
1176 
1177 extern int breakpoint_address_match (struct address_space *aspace1,
1178  CORE_ADDR addr1,
1179  struct address_space *aspace2,
1180  CORE_ADDR addr2);
1181 
1182 extern void until_break_command (char *, int, int);
1183 
1184 /* Initialize a struct bp_location. */
1185 
1186 extern void init_bp_location (struct bp_location *loc,
1187  const struct bp_location_ops *ops,
1188  struct breakpoint *owner);
1189 
1190 extern void update_breakpoint_locations (struct breakpoint *b,
1191  struct symtabs_and_lines sals,
1192  struct symtabs_and_lines sals_end);
1193 
1194 extern void breakpoint_re_set (void);
1195 
1196 extern void breakpoint_re_set_thread (struct breakpoint *);
1197 
1198 extern struct breakpoint *set_momentary_breakpoint
1199  (struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype);
1200 
1202  (struct gdbarch *, CORE_ADDR pc, enum bptype type);
1203 
1204 extern struct breakpoint *clone_momentary_breakpoint (struct breakpoint *bpkt);
1205 
1206 extern void set_ignore_count (int, int, int);
1207 
1208 extern void breakpoint_init_inferior (enum inf_context);
1209 
1210 extern struct cleanup *make_cleanup_delete_breakpoint (struct breakpoint *);
1211 
1212 extern void delete_breakpoint (struct breakpoint *);
1213 
1214 extern void breakpoint_auto_delete (bpstat);
1215 
1216 typedef void (*walk_bp_location_callback) (struct bp_location *, void *);
1217 
1219 
1220 /* Return the chain of command lines to execute when this breakpoint
1221  is hit. */
1222 extern struct command_line *breakpoint_commands (struct breakpoint *b);
1223 
1224 /* Return a string image of DISP. The string is static, and thus should
1225  NOT be deallocated after use. */
1226 const char *bpdisp_text (enum bpdisp disp);
1227 
1228 extern void break_command (char *, int);
1229 
1230 extern void hbreak_command_wrapper (char *, int);
1231 extern void thbreak_command_wrapper (char *, int);
1232 extern void rbreak_command_wrapper (char *, int);
1233 extern void watch_command_wrapper (char *, int, int);
1234 extern void awatch_command_wrapper (char *, int, int);
1235 extern void rwatch_command_wrapper (char *, int, int);
1236 extern void tbreak_command (char *, int);
1237 
1238 extern struct breakpoint_ops base_breakpoint_ops;
1239 extern struct breakpoint_ops bkpt_breakpoint_ops;
1242 
1243 extern void initialize_breakpoint_ops (void);
1244 
1245 /* Arguments to pass as context to some catch command handlers. */
1246 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
1247 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
1248 
1249 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
1250  lists, and pass some additional user data to the command
1251  function. */
1252 
1253 extern void
1254  add_catch_command (char *name, char *docstring,
1255  cmd_sfunc_ftype *sfunc,
1256  completer_ftype *completer,
1257  void *user_data_catch,
1258  void *user_data_tcatch);
1259 
1260 /* Initialize a breakpoint struct for Ada exception catchpoints. */
1261 
1262 extern void
1264  struct gdbarch *gdbarch,
1265  struct symtab_and_line sal,
1266  char *addr_string,
1267  const struct breakpoint_ops *ops,
1268  int tempflag,
1269  int enabled,
1270  int from_tty);
1271 
1272 extern void init_catchpoint (struct breakpoint *b,
1273  struct gdbarch *gdbarch, int tempflag,
1274  char *cond_string,
1275  const struct breakpoint_ops *ops);
1276 
1277 /* Add breakpoint B on the breakpoint list, and notify the user, the
1278  target and breakpoint_created observers of its existence. If
1279  INTERNAL is non-zero, the breakpoint number will be allocated from
1280  the internal breakpoint count. If UPDATE_GLL is non-zero,
1281  update_global_location_list will be called. */
1282 
1283 extern void install_breakpoint (int internal, struct breakpoint *b,
1284  int update_gll);
1285 
1286 /* Flags that can be passed down to create_breakpoint, etc., to affect
1287  breakpoint creation in several ways. */
1288 
1290  {
1291  /* We're adding a breakpoint to our tables that is already
1292  inserted in the target. */
1294  };
1295 
1296 extern int create_breakpoint (struct gdbarch *gdbarch, char *arg,
1297  char *cond_string, int thread,
1298  char *extra_string,
1299  int parse_arg,
1300  int tempflag, enum bptype wanted_type,
1301  int ignore_count,
1303  const struct breakpoint_ops *ops,
1304  int from_tty,
1305  int enabled,
1306  int internal, unsigned flags);
1307 
1308 extern void insert_breakpoints (void);
1309 
1310 extern int remove_breakpoints (void);
1311 
1312 extern int remove_breakpoints_pid (int pid);
1313 
1314 /* This function can be used to physically insert eventpoints from the
1315  specified traced inferior process, without modifying the breakpoint
1316  package's state. This can be useful for those targets which
1317  support following the processes of a fork() or vfork() system call,
1318  when both of the resulting two processes are to be followed. */
1319 extern int reattach_breakpoints (int);
1320 
1321 /* This function can be used to update the breakpoint package's state
1322  after an exec() system call has been executed.
1323 
1324  This function causes the following:
1325 
1326  - All eventpoints are marked "not inserted".
1327  - All eventpoints with a symbolic address are reset such that
1328  the symbolic address must be reevaluated before the eventpoints
1329  can be reinserted.
1330  - The solib breakpoints are explicitly removed from the breakpoint
1331  list.
1332  - A step-resume breakpoint, if any, is explicitly removed from the
1333  breakpoint list.
1334  - All eventpoints without a symbolic address are removed from the
1335  breakpoint list. */
1336 extern void update_breakpoints_after_exec (void);
1337 
1338 /* This function can be used to physically remove hardware breakpoints
1339  and watchpoints from the specified traced inferior process, without
1340  modifying the breakpoint package's state. This can be useful for
1341  those targets which support following the processes of a fork() or
1342  vfork() system call, when one of the resulting two processes is to
1343  be detached and allowed to run free.
1344 
1345  It is an error to use this function on the process whose id is
1346  inferior_ptid. */
1347 extern int detach_breakpoints (ptid_t ptid);
1348 
1349 /* This function is called when program space PSPACE is about to be
1350  deleted. It takes care of updating breakpoints to not reference
1351  this PSPACE anymore. */
1352 extern void breakpoint_program_space_exit (struct program_space *pspace);
1353 
1354 extern void set_longjmp_breakpoint (struct thread_info *tp,
1355  struct frame_id frame);
1356 extern void delete_longjmp_breakpoint (int thread);
1357 
1358 /* Mark all longjmp breakpoints from THREAD for later deletion. */
1359 extern void delete_longjmp_breakpoint_at_next_stop (int thread);
1360 
1362 extern void check_longjmp_breakpoint_for_call_dummy (struct thread_info *tp);
1363 
1364 extern void enable_overlay_breakpoints (void);
1365 extern void disable_overlay_breakpoints (void);
1366 
1367 extern void set_std_terminate_breakpoint (void);
1368 extern void delete_std_terminate_breakpoint (void);
1369 
1370 /* These functions respectively disable or reenable all currently
1371  enabled watchpoints. When disabled, the watchpoints are marked
1372  call_disabled. When re-enabled, they are marked enabled.
1373 
1374  The intended client of these functions is call_function_by_hand.
1375 
1376  The inferior must be stopped, and all breakpoints removed, when
1377  these functions are used.
1378 
1379  The need for these functions is that on some targets (e.g., HP-UX),
1380  gdb is unable to unwind through the dummy frame that is pushed as
1381  part of the implementation of a call command. Watchpoints can
1382  cause the inferior to stop in places where this frame is visible,
1383  and that can cause execution control to become very confused.
1384 
1385  Note that if a user sets breakpoints in an interactively called
1386  function, the call_disabled watchpoints will have been re-enabled
1387  when the first such breakpoint is reached. However, on targets
1388  that are unable to unwind through the call dummy frame, watches
1389  of stack-based storage may then be deleted, because gdb will
1390  believe that their watched storage is out of scope. (Sigh.) */
1392 
1394 
1395 /* These functions disable and re-enable all breakpoints during
1396  inferior startup. They are intended to be called from solib
1397  code where necessary. This is needed on platforms where the
1398  main executable is relocated at some point during startup
1399  processing, making breakpoint addresses invalid.
1400 
1401  If additional breakpoints are created after the routine
1402  disable_breakpoints_before_startup but before the routine
1403  enable_breakpoints_after_startup was called, they will also
1404  be marked as disabled. */
1405 extern void disable_breakpoints_before_startup (void);
1406 extern void enable_breakpoints_after_startup (void);
1407 
1408 /* For script interpreters that need to define breakpoint commands
1409  after they've already read the commands into a struct
1410  command_line. */
1412  (char *arg, struct command_line *cmd);
1413 
1414 extern void clear_breakpoint_hit_counts (void);
1415 
1416 extern struct breakpoint *get_breakpoint (int num);
1417 
1418 /* The following are for displays, which aren't really breakpoints,
1419  but here is as good a place as any for them. */
1420 
1421 extern void disable_current_display (void);
1422 
1423 extern void do_displays (void);
1424 
1425 extern void disable_display (int);
1426 
1427 extern void clear_displays (void);
1428 
1429 extern void disable_breakpoint (struct breakpoint *);
1430 
1431 extern void enable_breakpoint (struct breakpoint *);
1432 
1433 extern void breakpoint_set_commands (struct breakpoint *b,
1434  struct command_line *commands);
1435 
1436 extern void breakpoint_set_silent (struct breakpoint *b, int silent);
1437 
1438 extern void breakpoint_set_thread (struct breakpoint *b, int thread);
1439 
1440 extern void breakpoint_set_task (struct breakpoint *b, int task);
1441 
1442 /* Clear the "inserted" flag in all breakpoints. */
1443 extern void mark_breakpoints_out (void);
1444 
1445 extern struct breakpoint *create_jit_event_breakpoint (struct gdbarch *,
1446  CORE_ADDR);
1447 
1448 extern struct breakpoint *create_solib_event_breakpoint (struct gdbarch *,
1449  CORE_ADDR);
1450 
1451 /* Create an solib event breakpoint at ADDRESS in the current program
1452  space, and immediately try to insert it. Returns a pointer to the
1453  breakpoint on success. Deletes the new breakpoint and returns NULL
1454  if inserting the breakpoint fails. */
1456  (struct gdbarch *gdbarch, CORE_ADDR address);
1457 
1458 extern struct breakpoint *create_thread_event_breakpoint (struct gdbarch *,
1459  CORE_ADDR);
1460 
1461 extern void remove_jit_event_breakpoints (void);
1462 
1463 extern void remove_solib_event_breakpoints (void);
1464 
1465 /* Mark solib event breakpoints of the current program space with
1466  delete at next stop disposition. */
1468 
1469 extern void remove_thread_event_breakpoints (void);
1470 
1471 extern void disable_breakpoints_in_shlibs (void);
1472 
1473 /* This function returns TRUE if ep is a catchpoint. */
1474 extern int is_catchpoint (struct breakpoint *);
1475 
1476 /* Shared helper function (MI and CLI) for creating and installing
1477  a shared object event catchpoint. */
1478 extern void add_solib_catchpoint (char *arg, int is_load, int is_temp,
1479  int enabled);
1480 
1481 /* Enable breakpoints and delete when hit. Called with ARG == NULL
1482  deletes all breakpoints. */
1483 extern void delete_command (char *arg, int from_tty);
1484 
1485 /* Create and insert a new software single step breakpoint for the
1486  current thread. May be called multiple times; each time will add a
1487  new location to the set of potential addresses the next instruction
1488  is at. */
1489 extern void insert_single_step_breakpoint (struct gdbarch *,
1490  struct address_space *,
1491  CORE_ADDR);
1492 /* Check if any hardware watchpoints have triggered, according to the
1493  target. */
1495 
1496 /* Helper for transparent breakpoint hiding for memory read and write
1497  routines.
1498 
1499  Update one of READBUF or WRITEBUF with either the shadows
1500  (READBUF), or the breakpoint instructions (WRITEBUF) of inserted
1501  breakpoints at the memory range defined by MEMADDR and extending
1502  for LEN bytes. If writing, then WRITEBUF is a copy of WRITEBUF_ORG
1503  on entry.*/
1504 extern void breakpoint_xfer_memory (gdb_byte *readbuf, gdb_byte *writebuf,
1505  const gdb_byte *writebuf_org,
1506  ULONGEST memaddr, LONGEST len);
1507 
1508 /* Return true if breakpoints should be inserted now. That'll be the
1509  case if either:
1510 
1511  - the target has global breakpoints.
1512 
1513  - "breakpoint always-inserted" is on, and the target has
1514  execution.
1515 
1516  - threads are executing.
1517 */
1518 extern int breakpoints_should_be_inserted_now (void);
1519 
1520 /* Called each time new event from target is processed.
1521  Retires previously deleted breakpoint locations that
1522  in our opinion won't ever trigger. */
1523 extern void breakpoint_retire_moribund (void);
1524 
1525 /* Set break condition of breakpoint B to EXP. */
1526 extern void set_breakpoint_condition (struct breakpoint *b, const char *exp,
1527  int from_tty);
1528 
1529 /* Checks if we are catching syscalls or not.
1530  Returns 0 if not, greater than 0 if we are. */
1531 extern int catch_syscall_enabled (void);
1532 
1533 /* Checks if we are catching syscalls with the specific
1534  syscall_number. Used for "filtering" the catchpoints.
1535  Returns 0 if not, greater than 0 if we are. */
1536 extern int catching_syscall_number (int syscall_number);
1537 
1538 /* Return a tracepoint with the given number if found. */
1539 extern struct tracepoint *get_tracepoint (int num);
1540 
1541 extern struct tracepoint *get_tracepoint_by_number_on_target (int num);
1542 
1543 /* Find a tracepoint by parsing a number in the supplied string. */
1544 extern struct tracepoint *
1545  get_tracepoint_by_number (char **arg,
1546  struct get_number_or_range_state *state);
1547 
1548 /* Return a vector of all tracepoints currently defined. The vector
1549  is newly allocated; the caller should free when done with it. */
1550 extern VEC(breakpoint_p) *all_tracepoints (void);
1551 
1552 extern int is_tracepoint (const struct breakpoint *b);
1553 
1554 /* Return a vector of all static tracepoints defined at ADDR. The
1555  vector is newly allocated; the caller should free when done with
1556  it. */
1557 extern VEC(breakpoint_p) *static_tracepoints_here (CORE_ADDR addr);
1558 
1559 /* Function that can be passed to read_command_line to validate
1560  that each command is suitable for tracepoint command list. */
1561 extern void check_tracepoint_command (char *line, void *closure);
1562 
1563 /* Call at the start and end of an "rbreak" command to register
1564  breakpoint numbers for a later "commands" command. */
1565 extern void start_rbreak_breakpoints (void);
1566 extern void end_rbreak_breakpoints (void);
1567 
1568 /* Breakpoint iterator function.
1569 
1570  Calls a callback function once for each breakpoint, so long as the
1571  callback function returns false. If the callback function returns
1572  true, the iteration will end and the current breakpoint will be
1573  returned. This can be useful for implementing a search for a
1574  breakpoint with arbitrary attributes, or for applying an operation
1575  to every breakpoint. */
1576 extern struct breakpoint *iterate_over_breakpoints (int (*) (struct breakpoint *,
1577  void *), void *);
1578 
1579 /* Nonzero if the specified PC cannot be a location where functions
1580  have been inlined. */
1581 
1582 extern int pc_at_non_inline_function (struct address_space *aspace,
1583  CORE_ADDR pc,
1584  const struct target_waitstatus *ws);
1585 
1586 extern int user_breakpoint_p (struct breakpoint *);
1587 
1588 /* Attempt to determine architecture of location identified by SAL. */
1589 extern struct gdbarch *get_sal_arch (struct symtab_and_line sal);
1590 
1591 extern void breakpoint_free_objfile (struct objfile *objfile);
1592 
1593 extern char *ep_parse_optional_if_clause (char **arg);
1594 
1595 #endif /* !defined (BREAKPOINT_H) */
VEC(breakpoint_p)*all_tracepoints(void)
Definition: breakpoint.c:1239
char enabled
Definition: breakpoint.h:368
int breakpoint_has_location_inserted_here(struct breakpoint *bp, struct address_space *aspace, CORE_ADDR pc)
Definition: breakpoint.c:14842
struct agent_expr * cond_bytecode
Definition: breakpoint.h:338
CORE_ADDR reqstd_address
Definition: breakpoint.h:235
DEF_VEC_P(bp_location_p)
void init_bp_location(struct bp_location *loc, const struct bp_location_ops *ops, struct breakpoint *owner)
Definition: breakpoint.c:7152
enum condition_status condition_changed
Definition: breakpoint.h:353
void(* walk_bp_location_callback)(struct bp_location *, void *)
Definition: breakpoint.h:1216
int input_radix
Definition: breakpoint.h:722
void thbreak_command_wrapper(char *, int)
int line_number
Definition: breakpoint.h:466
CORE_ADDR hw_wp_mask
Definition: breakpoint.h:825
void(* print_recreate)(struct breakpoint *, struct ui_file *fp)
Definition: breakpoint.h:575
breakpoint_here
Definition: breakpoint.h:1124
void disable_breakpoints_before_startup(void)
Definition: breakpoint.c:8716
int breakpoints_should_be_inserted_now(void)
Definition: breakpoint.c:460
void add_catch_command(char *name, char *docstring, cmd_sfunc_ftype *sfunc, completer_ftype *completer, void *user_data_catch, void *user_data_tcatch)
Definition: breakpoint.c:15474
int is_breakpoint(const struct breakpoint *bpt)
Definition: breakpoint.c:1674
struct breakpoint_ops tracepoint_breakpoint_ops
Definition: breakpoint.c:13329
void set_ignore_count(int, int, int)
Definition: breakpoint.c:14331
command_control_type
Definition: defs.h:379
void awatch_command_wrapper(char *, int, int)
Definition: breakpoint.c:11393
enum language language
Definition: breakpoint.h:720
struct tracepoint * get_tracepoint_by_number(char **arg, struct get_number_or_range_state *state)
Definition: breakpoint.c:15234
void delete_longjmp_breakpoint(int thread)
Definition: breakpoint.c:7469
struct command_line * breakpoint_commands(struct breakpoint *b)
Definition: breakpoint.c:372
void bpstat_do_actions(void)
Definition: breakpoint.c:4668
bfd_vma CORE_ADDR
Definition: common-types.h:41
enum target_hw_bp_type watchpoint_type
Definition: breakpoint.h:418
int pc_at_non_inline_function(struct address_space *aspace, CORE_ADDR pc, const struct target_waitstatus *ws)
Definition: breakpoint.c:15536
int(* works_in_software_mode)(const struct breakpoint *)
Definition: breakpoint.h:546
stop_stack_kind
Definition: breakpoint.h:975
void bpstat_clear(bpstat *)
Definition: breakpoint.c:4381
void do_displays(void)
Definition: printcmd.c:1819
void(* func)(char *)
int events_till_retirement
Definition: breakpoint.h:459
struct counted_command_line * commands
Definition: breakpoint.h:695
struct bpstats * bpstat
Definition: breakpoint.h:894
void init_ada_exception_breakpoint(struct breakpoint *b, struct gdbarch *gdbarch, struct symtab_and_line sal, char *addr_string, const struct breakpoint_ops *ops, int tempflag, int enabled, int from_tty)
Definition: breakpoint.c:11665
bpdisp
Definition: breakpoint.h:201
enum print_stop_action(* print_it)(struct bpstats *bs)
Definition: breakpoint.h:550
void rbreak_command_wrapper(char *, int)
Definition: symtab.c:4872
void bpstat_clear_actions(void)
Definition: breakpoint.c:4508
struct gdbarch * get_sal_arch(struct symtab_and_line sal)
Definition: breakpoint.c:7371
struct counted_command_line * commands
Definition: breakpoint.h:1098
static enum auto_boolean pending_break_support
Definition: breakpoint.c:413
struct symtab * symtab
Definition: breakpoint.h:471
int(* resources_needed)(const struct bp_location *)
Definition: breakpoint.h:541
char duplicate
Definition: breakpoint.h:386
int is_tracepoint(const struct breakpoint *b)
Definition: breakpoint.c:1163
void(* dtor)(struct bp_location *self)
Definition: breakpoint.h:300
struct breakpoint_ops dprintf_breakpoint_ops
Definition: breakpoint.c:319
struct obj_section * section
Definition: breakpoint.h:423
struct breakpoint * create_solib_event_breakpoint(struct gdbarch *, CORE_ADDR)
Definition: breakpoint.c:7721
enum command_control_type commands_from_control_command(char *arg, struct command_line *cmd)
Definition: breakpoint.c:1447
bpstat next
Definition: breakpoint.h:1072
struct breakpoint base
Definition: breakpoint.h:858
void remove_solib_event_breakpoints(void)
Definition: breakpoint.c:7681
struct value * val
Definition: breakpoint.h:796
void(* print_mention)(struct breakpoint *)
Definition: breakpoint.h:572
int(* breakpoint_hit)(const struct bp_location *bl, struct address_space *aspace, CORE_ADDR bp_addr, const struct target_waitstatus *ws)
Definition: breakpoint.h:529
int hardware_watchpoint_inserted_in_range(struct address_space *, CORE_ADDR addr, ULONGEST len)
Definition: breakpoint.c:4323
Definition: ax.h:95
int is_watchpoint(const struct breakpoint *bpt)
Definition: breakpoint.c:1695
int program_breakpoint_here_p(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:8925
int software_breakpoint_inserted_here_p(struct address_space *, CORE_ADDR)
Definition: breakpoint.c:4279
const struct block * cond_exp_valid_block
Definition: breakpoint.h:792
void disable_display(int)
Definition: printcmd.c:1831
void breakpoint_re_set(void)
Definition: breakpoint.c:14273
void initialize_breakpoint_ops(void)
Definition: breakpoint.c:15571
struct gdbpy_breakpoint_object * py_bp_object
Definition: breakpoint.h:762
int bpstat_explains_signal(bpstat, enum gdb_signal)
Definition: breakpoint.c:4453
enum print_stop_action bpstat_print(bpstat, int)
Definition: breakpoint.c:4839
VEC(agent_expr_p)*conditions
bpstat bpstat_stop_status(struct address_space *aspace, CORE_ADDR pc, ptid_t ptid, const struct target_waitstatus *ws)
Definition: breakpoint.c:5493
void init_catchpoint(struct breakpoint *b, struct gdbarch *gdbarch, int tempflag, char *cond_string, const struct breakpoint_ops *ops)
Definition: breakpoint.c:8439
Definition: ui-out.c:99
void rwatch_command_wrapper(char *, int, int)
Definition: breakpoint.c:11381
void check_tracepoint_command(char *line, void *closure)
Definition: breakpoint.c:1312
struct gdbarch * gdbarch
Definition: breakpoint.h:718
char * exp_string
Definition: breakpoint.h:779
Definition: ptid.h:35
struct program_space * pspace
Definition: breakpoint.h:703
long step_count
Definition: breakpoint.h:862
bpstat bpstat_copy(bpstat)
Definition: breakpoint.c:4402
void breakpoint_program_space_exit(struct program_space *pspace)
Definition: breakpoint.c:2941
void hbreak_command_wrapper(char *, int)
struct bp_location * bp_location_p
Definition: breakpoint.h:639
int hit_count
Definition: breakpoint.h:750
int breakpoint_inserted_here_p(struct address_space *, CORE_ADDR)
Definition: breakpoint.c:4256
mach_port_t kern_return_t mach_port_t msgports mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
Definition: gnu-nat.c:1885
enum bpdisp disposition
Definition: breakpoint.h:673
void iterate_over_bp_locations(walk_bp_location_callback)
Definition: breakpoint.c:3005
void disable_breakpoint(struct breakpoint *)
Definition: breakpoint.c:14486
bp_print_how
Definition: breakpoint.h:1052
int(* insert_location)(struct bp_location *)
Definition: breakpoint.h:515
void delete_breakpoint(struct breakpoint *)
Definition: breakpoint.c:13539
enum stop_stack_kind call_dummy
Definition: breakpoint.h:995
const char *const name
Definition: aarch64-tdep.c:68
enum breakpoint_here breakpoint_here_p(struct address_space *, CORE_ADDR)
Definition: breakpoint.c:4187
void add_solib_catchpoint(char *arg, int is_load, int is_temp, int enabled)
Definition: breakpoint.c:8366
struct expression * cond_exp
Definition: breakpoint.h:789
char inserted
Definition: breakpoint.h:371
struct bp_location * next
Definition: breakpoint.h:307
struct bp_target_info overlay_target_info
Definition: breakpoint.h:448
void start_rbreak_breakpoints(void)
Definition: breakpoint.c:686
int regular_breakpoint_inserted_here_p(struct address_space *, CORE_ADDR)
ptid_t watchpoint_thread
Definition: breakpoint.h:814
char * extra_string
Definition: breakpoint.h:729
int bpstat_causes_stop(bpstat)
Definition: breakpoint.c:5910
char * function_name
Definition: breakpoint.h:442
struct bp_location * bp_location_at
Definition: breakpoint.h:1089
void disable_breakpoints_in_shlibs(void)
Definition: breakpoint.c:7748
struct program_space * pspace
Definition: breakpoint.h:404
int user_breakpoint_p(struct breakpoint *)
Definition: breakpoint.c:6645
struct tracepoint * get_tracepoint_by_number_on_target(int num)
Definition: breakpoint.c:15213
void until_break_command(char *, int, int)
Definition: breakpoint.c:11431
int static_trace_marker_id_idx
Definition: breakpoint.h:884
char print
Definition: breakpoint.h:1104
struct breakpoint * set_momentary_breakpoint(struct gdbarch *, struct symtab_and_line, struct frame_id, enum bptype)
char * cond_string
Definition: breakpoint.h:725
const struct block * exp_valid_block
Definition: breakpoint.h:787
#define BREAKPOINT_MAX
Definition: breakpoint.h:46
gdb_byte shadow_contents[BREAKPOINT_MAX]
Definition: breakpoint.h:245
void enable_breakpoint(struct breakpoint *)
Definition: breakpoint.c:14637
enum bp_print_how print_it
Definition: breakpoint.h:1111
void cmd_sfunc_ftype(char *args, int from_tty, struct cmd_list_element *c)
Definition: command.h:154
Definition: gdbtypes.h:749
struct breakpoint * breakpoint_find_if(int(*func)(struct breakpoint *b, void *d), void *user_data)
void insert_single_step_breakpoint(struct gdbarch *, struct address_space *, CORE_ADDR)
Definition: breakpoint.c:14816
void breakpoint_set_commands(struct breakpoint *b, struct command_line *commands)
Definition: breakpoint.c:1261
void(* decode_linespec)(struct breakpoint *, char **, struct symtabs_and_lines *)
Definition: breakpoint.h:605
void breakpoint_auto_delete(bpstat)
Definition: breakpoint.c:11914
int pass_count
Definition: breakpoint.h:866
struct cleanup * make_cleanup_delete_breakpoint(struct breakpoint *)
Definition: breakpoint.c:13638
void delete_longjmp_breakpoint_at_next_stop(int thread)
Definition: breakpoint.c:7482
struct expression * exp
Definition: breakpoint.h:784
int number_on_target
Definition: breakpoint.h:869
const struct bp_location_ops * ops
Definition: breakpoint.h:310
int detach_breakpoints(ptid_t ptid)
Definition: breakpoint.c:3847
void set_breakpoint_condition(struct breakpoint *b, const char *exp, int from_tty)
Definition: breakpoint.c:960
bpstat bpstat_find_breakpoint(bpstat, struct breakpoint *)
Definition: breakpoint.c:4437
void tbreak_command(char *, int)
Definition: breakpoint.c:9914
condition_status
Definition: breakpoint.h:213
struct breakpoint * clone_momentary_breakpoint(struct breakpoint *bpkt)
Definition: breakpoint.c:8822
int bpstat_should_step(void)
Definition: breakpoint.c:5899
void breakpoint_free_objfile(struct objfile *objfile)
Definition: breakpoint.c:15561
int(* explains_signal)(struct breakpoint *, enum gdb_signal)
Definition: breakpoint.h:610
enum watchpoint_triggered watchpoint_triggered
Definition: breakpoint.h:818
struct gdbscm_breakpoint_object * scm_bp_object
Definition: breakpoint.h:765
CORE_ADDR placed_address
Definition: breakpoint.h:232
Definition: symtab.h:925
char * ep_parse_optional_if_clause(char **arg)
Definition: breakpoint.c:11552
void breakpoint_xfer_memory(gdb_byte *readbuf, gdb_byte *writebuf, const gdb_byte *writebuf_org, ULONGEST memaddr, LONGEST len)
Definition: breakpoint.c:1581
void clear_displays(void)
Definition: printcmd.c:1567
CORE_ADDR requested_address
Definition: breakpoint.h:431
Definition: probe.h:185
bpstat_what_main_action
Definition: breakpoint.h:924
unsigned char display_canonical
Definition: breakpoint.h:684
bptype
Definition: breakpoint.h:51
void(* check_status)(struct bpstats *bs)
Definition: breakpoint.h:536
bp_loc_type
Definition: breakpoint.h:284
void update_breakpoints_after_exec(void)
Definition: breakpoint.c:3725
void clear_breakpoint_hit_counts(void)
Definition: breakpoint.c:703
Definition: block.h:60
Definition: value.c:172
int val_valid
Definition: breakpoint.h:799
int moribund_breakpoint_here_p(struct address_space *, CORE_ADDR)
Definition: breakpoint.c:4220
enum bptype type
Definition: breakpoint.h:669
struct breakpoint_ops bkpt_breakpoint_ops
Definition: breakpoint.c:313
int is_catchpoint(struct breakpoint *)
Definition: breakpoint.c:4359
struct breakpoint * breakpoint_at
Definition: breakpoint.h:1095
void delete_std_terminate_breakpoint(void)
Definition: breakpoint.c:7610
struct breakpoint_ops base_breakpoint_ops
Definition: breakpoint.c:12761
int catching_syscall_number(int syscall_number)
void(* create_sals_from_address)(char **, struct linespec_result *, enum bptype, char *, char **)
Definition: breakpoint.h:583
struct tracepoint * get_tracepoint(int num)
Definition: breakpoint.c:15197
print_stop_action
Definition: breakpoint.h:476
void disable_current_display(void)
Definition: printcmd.c:1845
void set_longjmp_breakpoint(struct thread_info *tp, struct frame_id frame)
Definition: breakpoint.c:7440
void disable_overlay_breakpoints(void)
Definition: breakpoint.c:7579
void remove_solib_event_breakpoints_at_next_stop(void)
Definition: breakpoint.c:7694
const char const char int
Definition: command.h:229
int remove_breakpoints_pid(int pid)
Definition: breakpoint.c:3224
bfd_byte gdb_byte
Definition: common-types.h:38
int watchpoints_triggered(struct target_waitstatus *)
Definition: breakpoint.c:4912
void breakpoint_init_inferior(enum inf_context)
Definition: breakpoint.c:4080
void disable_watchpoints_before_interactive_call_start(void)
Definition: breakpoint.c:8686
void print_recreate_thread(struct breakpoint *b, struct ui_file *fp)
Definition: breakpoint.c:15272
char * static_trace_marker_id
Definition: breakpoint.h:876
enum bp_loc_type loc_type
Definition: breakpoint.h:316
enable_state
Definition: breakpoint.h:182
int remove_breakpoints(void)
Definition: breakpoint.c:3184
int target_exact_watchpoints
Definition: breakpoint.c:551
void breakpoint_re_set_thread(struct breakpoint *)
Definition: breakpoint.c:14311
int single_step_breakpoint_inserted_here_p(struct address_space *, CORE_ADDR)
Definition: breakpoint.c:14860
watchpoint_triggered
Definition: breakpoint.h:626
ULONGEST traceframe_usage
Definition: breakpoint.h:873
struct breakpoint * create_jit_event_breakpoint(struct gdbarch *, CORE_ADDR)
Definition: breakpoint.c:7657
unsigned char silent
Definition: breakpoint.h:682
CORE_ADDR related_address
Definition: breakpoint.h:436
int val_bitpos
Definition: breakpoint.h:803
int catch_syscall_enabled(void)
struct bp_location * loc
Definition: breakpoint.h:678
void install_breakpoint(int internal, struct breakpoint *b, int update_gll)
Definition: breakpoint.c:8456
const char * bpdisp_text(enum bpdisp disp)
Definition: breakpoint.c:383
int create_breakpoint(struct gdbarch *gdbarch, char *arg, char *cond_string, int thread, char *extra_string, int parse_arg, int tempflag, enum bptype wanted_type, int ignore_count, enum auto_boolean pending_break_support, const struct breakpoint_ops *ops, int from_tty, int enabled, int internal, unsigned flags)
Definition: breakpoint.c:9585
struct breakpoint * get_breakpoint(int num)
Definition: breakpoint.c:774
int(* remove_location)(struct bp_location *)
Definition: breakpoint.h:521
void remove_jit_event_breakpoints(void)
Definition: breakpoint.c:7670
char * addr_string
Definition: breakpoint.h:706
int line
Definition: symtab.h:1570
void end_rbreak_breakpoints(void)
Definition: breakpoint.c:695
int enable_count
Definition: breakpoint.h:691
void(* print_one_detail)(const struct breakpoint *, struct ui_out *)
Definition: breakpoint.h:568
char permanent
Definition: breakpoint.h:378
target_hw_bp_type
Definition: break-common.h:22
struct breakpoint * create_thread_event_breakpoint(struct gdbarch *, CORE_ADDR)
Definition: breakpoint.c:7620
struct breakpoint * related_breakpoint
Definition: breakpoint.h:736
struct agent_expr * cmd_bytecode
Definition: breakpoint.h:355
auto_boolean
Definition: defs.h:196
void(* after_condition_true)(struct bpstats *bs)
Definition: breakpoint.h:614
char shlib_disabled
Definition: breakpoint.h:365
void set_std_terminate_breakpoint(void)
Definition: breakpoint.c:7595
int breakpoint_address_match(struct address_space *aspace1, CORE_ADDR addr1, struct address_space *aspace2, CORE_ADDR addr2)
Definition: breakpoint.c:6993
void remove_thread_event_breakpoints(void)
Definition: breakpoint.c:7638
void enable_breakpoints_after_startup(void)
Definition: breakpoint.c:8723
unsigned long long ULONGEST
Definition: common-types.h:53
int reattach_breakpoints(int)
Definition: breakpoint.c:3246
void breakpoint_retire_moribund(void)
Definition: breakpoint.c:12486
language
Definition: defs.h:167
struct breakpoint * breakpoint_p
Definition: breakpoint.h:887
int condition_not_parsed
Definition: breakpoint.h:755
int ignore_count
Definition: breakpoint.h:687
void(* dtor)(struct breakpoint *self)
Definition: breakpoint.h:502
inf_context
Definition: breakpoint.h:1114
char stop
Definition: breakpoint.h:1107
void check_longjmp_breakpoint_for_call_dummy(struct thread_info *tp)
Definition: breakpoint.c:7537
struct breakpoint * set_longjmp_breakpoint_for_call_dummy(void)
Definition: breakpoint.c:7500
void mark_breakpoints_out(void)
Definition: breakpoint.c:4058
struct bp_target_info target_info
Definition: breakpoint.h:445
void insert_breakpoints(void)
Definition: breakpoint.c:2984
void break_command(char *, int)
Definition: breakpoint.c:9908
void breakpoint_set_thread(struct breakpoint *b, int thread)
Definition: breakpoint.c:1289
struct breakpoint * set_momentary_breakpoint_at_pc(struct gdbarch *, CORE_ADDR pc, enum bptype type)
Definition: breakpoint.c:8832
char * addr_string_range_end
Definition: breakpoint.h:715
void enable_watchpoints_after_interactive_call_stop(void)
Definition: breakpoint.c:8701
CORE_ADDR address
Definition: breakpoint.h:410
int val_bitsize
Definition: breakpoint.h:804
int hardware_breakpoint_inserted_here_p(struct address_space *, CORE_ADDR)
Definition: breakpoint.c:4302
int bpstat_num(bpstat *, int *)
Definition: breakpoint.c:4486
void delete_command(char *arg, int from_tty)
Definition: breakpoint.c:13696
CORE_ADDR address
Definition: value.c:216
struct address_space * placed_address_space
Definition: breakpoint.h:225
breakpoint_create_flags
Definition: breakpoint.h:1289
void breakpoint_set_task(struct breakpoint *b, int task)
Definition: breakpoint.c:1302
void watch_command_wrapper(char *, int, int)
Definition: breakpoint.c:11350
struct breakpoint * create_and_insert_solib_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7729
enum enable_state enable_state
Definition: breakpoint.h:671
struct gdbarch * gdbarch
Definition: breakpoint.h:396
void enable_overlay_breakpoints(void)
Definition: breakpoint.c:7565
struct breakpoint * owner
Definition: breakpoint.h:324
struct breakpoint * iterate_over_breakpoints(int(*)(struct breakpoint *, void *), void *)
void breakpoint_set_silent(struct breakpoint *b, int silent)
Definition: breakpoint.c:1276
void(* print_one)(struct breakpoint *, struct bp_location **)
Definition: breakpoint.h:554
void(* create_breakpoints_sal)(struct gdbarch *, struct linespec_result *, char *, char *, enum bptype, enum bpdisp, int, int, int, const struct breakpoint_ops *, int, int, int, unsigned)
Definition: breakpoint.h:593
struct breakpoint base
Definition: breakpoint.h:775
struct frame_id watchpoint_frame
Definition: breakpoint.h:809
void(* re_set)(struct breakpoint *self)
Definition: breakpoint.h:510
char needs_update
Definition: breakpoint.h:360
char * exp_string_reparse
Definition: breakpoint.h:781
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
long long LONGEST
Definition: common-types.h:52
struct expression * cond
Definition: breakpoint.h:333
void update_breakpoint_locations(struct breakpoint *b, struct symtabs_and_lines sals, struct symtabs_and_lines sals_end)
Definition: breakpoint.c:13939
char * filter
Definition: breakpoint.h:711
const struct breakpoint_ops * ops
Definition: breakpoint.h:665
const ULONGEST const LONGEST len
Definition: target.h:309
struct value * old_val
Definition: breakpoint.h:1101
enum bpstat_what_main_action main_action
Definition: breakpoint.h:989
struct breakpoint * next
Definition: breakpoint.h:667