1 /* Data structures associated with breakpoints in GDB.
2 Copyright (C) 1992-2023 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
19 #if !defined (BREAKPOINT_H)
20 #define BREAKPOINT_H 1
26 #include "gdbsupport/break-common.h"
30 #include "gdbsupport/array-view.h"
31 #include "gdbsupport/filtered-iterator.h"
32 #include "gdbsupport/function-view.h"
33 #include "gdbsupport/next-iterator.h"
34 #include "gdbsupport/iterator-range.h"
35 #include "gdbsupport/refcounted-object.h"
36 #include "gdbsupport/safe-iterator.h"
37 #include "cli/cli-script.h"
38 #include "target/waitstatus.h"
41 struct gdbpy_breakpoint_object
;
42 struct gdbscm_breakpoint_object
;
43 struct number_or_range_parser
;
47 struct linespec_result
;
51 /* Enum for exception-handling support in 'catch throw', 'catch rethrow',
52 'catch catch' and the MI equivalent. */
54 enum exception_event_kind
61 /* Why are we removing the breakpoint from the target? */
65 /* A regular remove. Remove the breakpoint and forget everything
69 /* Detach the breakpoints from a fork child. */
73 /* This is the maximum number of bytes a breakpoint instruction can
74 take. Feel free to increase it. It's just used in a few places to
75 size arrays that should be independent of the target
78 #define BREAKPOINT_MAX 16
81 /* Type of breakpoint. */
85 bp_none
= 0, /* Eventpoint has been deleted */
86 bp_breakpoint
, /* Normal breakpoint */
87 bp_hardware_breakpoint
, /* Hardware assisted breakpoint */
88 bp_single_step
, /* Software single-step */
89 bp_until
, /* used by until command */
90 bp_finish
, /* used by finish command */
91 bp_watchpoint
, /* Watchpoint */
92 bp_hardware_watchpoint
, /* Hardware assisted watchpoint */
93 bp_read_watchpoint
, /* read watchpoint, (hardware assisted) */
94 bp_access_watchpoint
, /* access watchpoint, (hardware assisted) */
95 bp_longjmp
, /* secret breakpoint to find longjmp() */
96 bp_longjmp_resume
, /* secret breakpoint to escape longjmp() */
98 /* Breakpoint placed to the same location(s) like bp_longjmp but used to
99 protect against stale DUMMY_FRAME. Multiple bp_longjmp_call_dummy and
100 one bp_call_dummy are chained together by related_breakpoint for each
102 bp_longjmp_call_dummy
,
104 /* An internal breakpoint that is installed on the unwinder's
107 /* An internal breakpoint that is set at the point where an
108 exception will land. */
111 /* Used by wait_for_inferior for stepping over subroutine calls,
112 and for skipping prologues. */
115 /* Used by wait_for_inferior for stepping over signal
119 /* Used to detect when a watchpoint expression has gone out of
120 scope. These breakpoints are usually not visible to the user.
122 This breakpoint has some interesting properties:
124 1) There's always a 1:1 mapping between watchpoints
125 on local variables and watchpoint_scope breakpoints.
127 2) It automatically deletes itself and the watchpoint it's
128 associated with when hit.
130 3) It can never be disabled. */
133 /* The breakpoint at the end of a call dummy. See bp_longjmp_call_dummy it
134 is chained with by related_breakpoint. */
137 /* A breakpoint set on std::terminate, that is used to catch
138 otherwise uncaught exceptions thrown during an inferior call. */
141 /* Some dynamic linkers (HP, maybe Solaris) can arrange for special
142 code in the inferior to run when significant events occur in the
143 dynamic linker (for example a library is loaded or unloaded).
145 By placing a breakpoint in this magic code GDB will get control
146 when these significant events occur. GDB can then re-examine
147 the dynamic linker's data structures to discover any newly loaded
148 dynamic libraries. */
151 /* Some multi-threaded systems can arrange for a location in the
152 inferior to be executed when certain thread-related events occur
153 (such as thread creation or thread death).
155 By placing a breakpoint at one of these locations, GDB will get
156 control when these events occur. GDB can then update its thread
161 /* On the same principal, an overlay manager can arrange to call a
162 magic location in the inferior whenever there is an interesting
163 change in overlay status. GDB can update its overlay tables
164 and fiddle with breakpoints in overlays when this breakpoint
169 /* Master copies of longjmp breakpoints. These are always installed
170 as soon as an objfile containing longjmp is loaded, but they are
171 always disabled. While necessary, temporary clones of bp_longjmp
172 type will be created and enabled. */
176 /* Master copies of std::terminate breakpoints. */
177 bp_std_terminate_master
,
179 /* Like bp_longjmp_master, but for exceptions. */
186 bp_static_tracepoint
,
187 /* Like bp_static_tracepoint but for static markers. */
188 bp_static_marker_tracepoint
,
190 /* A dynamic printf stops at the given location, does a formatted
191 print, then automatically continues. (Although this is sort of
192 like a macro packaging up standard breakpoint functionality,
193 GDB doesn't have a way to construct types of breakpoint from
194 elements of behavior.) */
197 /* Event for JIT compiled code generation or deletion. */
200 /* Breakpoint is placed at the STT_GNU_IFUNC resolver. When hit GDB
201 inserts new bp_gnu_ifunc_resolver_return at the caller.
202 bp_gnu_ifunc_resolver is still being kept here as a different thread
203 may still hit it before bp_gnu_ifunc_resolver_return is hit by the
205 bp_gnu_ifunc_resolver
,
207 /* On its hit GDB now know the resolved address of the target
208 STT_GNU_IFUNC function. Associated bp_gnu_ifunc_resolver can be
209 deleted now and the breakpoint moved to the target function entry
211 bp_gnu_ifunc_resolver_return
,
214 /* States of enablement of breakpoint. */
218 bp_disabled
, /* The eventpoint is inactive, and cannot
220 bp_enabled
, /* The eventpoint is active, and can
222 bp_call_disabled
, /* The eventpoint has been disabled while a
223 call into the inferior is "in flight",
224 because some eventpoints interfere with
225 the implementation of a call on some
226 targets. The eventpoint will be
227 automatically enabled and reset when the
228 call "lands" (either completes, or stops
229 at another eventpoint). */
233 /* Disposition of breakpoint. Ie: what to do after hitting it. */
237 disp_del
, /* Delete it */
238 disp_del_at_next_stop
, /* Delete at next stop,
239 whether hit or not */
240 disp_disable
, /* Disable it */
241 disp_donttouch
/* Leave it alone */
244 /* Status of breakpoint conditions used when synchronizing
245 conditions with the target. */
247 enum condition_status
249 condition_unchanged
= 0,
254 /* Information used by targets to insert and remove breakpoints. */
256 struct bp_target_info
258 /* Address space at which the breakpoint was placed. */
259 struct address_space
*placed_address_space
;
261 /* Address at which the breakpoint was placed. This is normally
262 the same as REQUESTED_ADDRESS, except when adjustment happens in
263 gdbarch_breakpoint_from_pc. The most common form of adjustment
264 is stripping an alternate ISA marker from the PC which is used
265 to determine the type of breakpoint to insert. */
266 CORE_ADDR placed_address
;
268 /* Address at which the breakpoint was requested. */
269 CORE_ADDR reqstd_address
;
271 /* If this is a ranged breakpoint, then this field contains the
272 length of the range that will be watched for execution. */
275 /* If the breakpoint lives in memory and reading that memory would
276 give back the breakpoint, instead of the original contents, then
277 the original contents are cached here. Only SHADOW_LEN bytes of
278 this buffer are valid, and only when the breakpoint is inserted. */
279 gdb_byte shadow_contents
[BREAKPOINT_MAX
];
281 /* The length of the data cached in SHADOW_CONTENTS. */
284 /* The breakpoint's kind. It is used in 'kind' parameter in Z
288 /* Conditions the target should evaluate if it supports target-side
289 breakpoint conditions. These are non-owning pointers. */
290 std::vector
<agent_expr
*> conditions
;
292 /* Commands the target should evaluate if it supports target-side
293 breakpoint commands. These are non-owning pointers. */
294 std::vector
<agent_expr
*> tcommands
;
296 /* Flag that is true if the breakpoint should be left in place even
297 when GDB is not connected. */
301 /* GDB maintains two types of information about each breakpoint (or
302 watchpoint, or other related event). The first type corresponds
303 to struct breakpoint; this is a relatively high-level structure
304 which contains the source location(s), stopping conditions, user
305 commands to execute when the breakpoint is hit, and so forth.
307 The second type of information corresponds to struct bp_location.
308 Each breakpoint has one or (eventually) more locations associated
309 with it, which represent target-specific and machine-specific
310 mechanisms for stopping the program. For instance, a watchpoint
311 expression may require multiple hardware watchpoints in order to
312 catch all changes in the value of the expression being watched. */
316 bp_loc_software_breakpoint
,
317 bp_loc_hardware_breakpoint
,
318 bp_loc_software_watchpoint
,
319 bp_loc_hardware_watchpoint
,
321 bp_loc_other
/* Miscellaneous... */
324 class bp_location
: public refcounted_object
, public intrusive_list_node
<bp_location
>
327 /* Construct a bp_location with the type inferred from OWNER's
329 explicit bp_location (breakpoint
*owner
);
331 /* Construct a bp_location with type TYPE. */
332 bp_location (breakpoint
*owner
, bp_loc_type type
);
334 virtual ~bp_location () = default;
336 /* Type of this breakpoint location. */
337 bp_loc_type loc_type
{};
339 /* Each breakpoint location must belong to exactly one higher-level
340 breakpoint. This pointer is NULL iff this bp_location is no
341 longer attached to a breakpoint. For example, when a breakpoint
342 is deleted, its locations may still be found in the
343 moribund_locations list, or if we had stopped for it, in
345 breakpoint
*owner
= NULL
;
347 /* Conditional. Break only if this expression's value is nonzero.
348 Unlike string form of condition, which is associated with
349 breakpoint, this is associated with location, since if breakpoint
350 has several locations, the evaluation of expression can be
351 different for different locations. Only valid for real
352 breakpoints; a watchpoint's conditional expression is stored in
353 the owner breakpoint object. */
356 /* Conditional expression in agent expression
357 bytecode form. This is used for stub-side breakpoint
358 condition evaluation. */
359 agent_expr_up cond_bytecode
;
361 /* Signals that the condition has changed since the last time
362 we updated the global location list. This means the condition
363 needs to be sent to the target again. This is used together
364 with target-side breakpoint conditions.
366 condition_unchanged: It means there has been no condition changes.
368 condition_modified: It means this location had its condition modified.
370 condition_updated: It means we already marked all the locations that are
371 duplicates of this location and thus we don't need to call
372 force_breakpoint_reinsertion (...) for this location. */
374 condition_status condition_changed
{};
376 agent_expr_up cmd_bytecode
;
378 /* Signals that breakpoint conditions and/or commands need to be
379 re-synced with the target. This has no use other than
380 target-side breakpoints. */
381 bool needs_update
= false;
383 /* This location's address is in an unloaded solib, and so this
384 location should not be inserted. It will be automatically
385 enabled when that solib is loaded. */
386 bool shlib_disabled
= false;
388 /* Is this particular location enabled. */
389 bool enabled
= false;
391 /* Is this particular location disabled because the condition
392 expression is invalid at this location. For a location to be
393 reported as enabled, the ENABLED field above has to be true *and*
394 the DISABLED_BY_COND field has to be false. */
395 bool disabled_by_cond
= false;
397 /* True if this breakpoint is now inserted. */
398 bool inserted
= false;
400 /* True if this is a permanent breakpoint. There is a breakpoint
401 instruction hard-wired into the target's code. Don't try to
402 write another breakpoint instruction on top of it, or restore its
403 value. Step over it using the architecture's
404 gdbarch_skip_permanent_breakpoint method. */
405 bool permanent
= false;
407 /* True if this is not the first breakpoint in the list
408 for the given address. location of tracepoint can _never_
409 be duplicated with other locations of tracepoints and other
410 kinds of breakpoints, because two locations at the same
411 address may have different actions, so both of these locations
412 should be downloaded and so that `tfind N' always works. */
413 bool duplicate
= false;
415 /* If we someday support real thread-specific breakpoints, then
416 the breakpoint location will need a thread identifier. */
418 /* Data for specific breakpoint types. These could be a union, but
419 simplicity is more important than memory usage for breakpoints. */
421 /* Architecture associated with this location's address. May be
422 different from the breakpoint architecture. */
423 struct gdbarch
*gdbarch
= NULL
;
425 /* The program space associated with this breakpoint location
426 address. Note that an address space may be represented in more
427 than one program space (e.g. each uClinux program will be given
428 its own program space, but there will only be one address space
429 for all of them), but we must not insert more than one location
430 at the same address in the same address space. */
431 program_space
*pspace
= NULL
;
433 /* Note that zero is a perfectly valid code address on some platforms
434 (for example, the mn10200 (OBSOLETE) and mn10300 simulators). NULL
435 is not a special value for this field. Valid for all types except
437 CORE_ADDR address
= 0;
439 /* For hardware watchpoints, the size of the memory region being
440 watched. For hardware ranged breakpoints, the size of the
444 /* Type of hardware watchpoint. */
445 target_hw_bp_type watchpoint_type
{};
447 /* For any breakpoint type with an address, this is the section
448 associated with the address. Used primarily for overlay
450 obj_section
*section
= NULL
;
452 /* Address at which breakpoint was requested, either by the user or
453 by GDB for internal breakpoints. This will usually be the same
454 as ``address'' (above) except for cases in which
455 ADJUST_BREAKPOINT_ADDRESS has computed a different address at
456 which to place the breakpoint in order to comply with a
457 processor's architectual constraints. */
458 CORE_ADDR requested_address
= 0;
460 /* An additional address assigned with this location. This is currently
461 only used by STT_GNU_IFUNC resolver breakpoints to hold the address
462 of the resolver function. */
463 CORE_ADDR related_address
= 0;
465 /* If the location comes from a probe point, this is the probe associated
467 bound_probe probe
{};
469 gdb::unique_xmalloc_ptr
<char> function_name
;
471 /* Details of the placed breakpoint, when inserted. */
472 bp_target_info target_info
{};
474 /* Similarly, for the breakpoint at an overlay's LMA, if necessary. */
475 bp_target_info overlay_target_info
{};
477 /* In a non-stop mode, it's possible that we delete a breakpoint,
478 but as we do that, some still running thread hits that breakpoint.
479 For that reason, we need to keep locations belonging to deleted
480 breakpoints for a bit, so that don't report unexpected SIGTRAP.
481 We can't keep such locations forever, so we use a heuristic --
482 after we process certain number of inferior events since
483 breakpoint was deleted, we retire all locations of that breakpoint.
484 This variable keeps a number of events still to go, when
485 it becomes 0 this location is retired. */
486 int events_till_retirement
= 0;
488 /* Line number which was used to place this location.
490 Breakpoint placed into a comment keeps it's user specified line number
491 despite ADDRESS resolves into a different line number. */
495 /* Symtab which was used to place this location. This is used
496 to find the corresponding source file name. */
498 struct symtab
*symtab
= NULL
;
500 /* The symbol found by the location parser, if any. This may be used to
501 ascertain when a location spec was set at a different location than
502 the one originally selected by parsing, e.g., inlined symbols. */
503 const struct symbol
*symbol
= NULL
;
505 /* Similarly, the minimal symbol found by the location parser, if
506 any. This may be used to ascertain if the location was
507 originally set on a GNU ifunc symbol. */
508 const minimal_symbol
*msymbol
= NULL
;
510 /* The objfile the symbol or minimal symbol were found in. */
511 const struct objfile
*objfile
= NULL
;
513 /* Return a string representation of the bp_location.
514 This is only meant to be used in debug messages. */
515 std::string
to_string () const;
518 /* A policy class for bp_location reference counting. */
519 struct bp_location_ref_policy
521 static void incref (bp_location
*loc
)
526 static void decref (bp_location
*loc
)
528 gdb_assert (loc
->refcount () > 0);
530 if (loc
->refcount () == 0)
535 /* A gdb::ref_ptr that has been specialized for bp_location. */
536 typedef gdb::ref_ptr
<bp_location
, bp_location_ref_policy
>
539 /* The possible return values for print_bpstat, print_it_normal,
540 print_it_done, print_it_noop. */
541 enum print_stop_action
543 /* We printed nothing or we need to do some more analysis. */
546 /* We printed something, and we *do* desire that something to be
547 followed by a location. */
550 /* We printed something, and we do *not* desire that something to be
551 followed by a location. */
554 /* We already printed all we needed to print, don't print anything
559 /* This structure is a collection of function pointers that, if available,
560 will be called instead of the performing the default action for this
563 struct breakpoint_ops
565 /* Create SALs from location spec, storing the result in
568 For an explanation about the arguments, see the function
569 `create_sals_from_location_spec_default'.
571 This function is called inside `create_breakpoint'. */
572 void (*create_sals_from_location_spec
) (location_spec
*locspec
,
573 struct linespec_result
*canonical
);
575 /* This method will be responsible for creating a breakpoint given its SALs.
576 Usually, it just calls `create_breakpoints_sal' (for ordinary
577 breakpoints). However, there may be some special cases where we might
578 need to do some tweaks, e.g., see
579 `strace_marker_create_breakpoints_sal'.
581 This function is called inside `create_breakpoint'. */
582 void (*create_breakpoints_sal
) (struct gdbarch
*,
583 struct linespec_result
*,
584 gdb::unique_xmalloc_ptr
<char>,
585 gdb::unique_xmalloc_ptr
<char>,
586 enum bptype
, enum bpdisp
, int, int, int,
587 int, int, int, int, unsigned);
590 enum watchpoint_triggered
592 /* This watchpoint definitely did not trigger. */
593 watch_triggered_no
= 0,
595 /* Some hardware watchpoint triggered, and it might have been this
596 one, but we do not know which it was. */
597 watch_triggered_unknown
,
599 /* This hardware watchpoint definitely did trigger. */
603 /* Some targets (e.g., embedded PowerPC) need two debug registers to set
604 a watchpoint over a memory region. If this flag is true, GDB will use
605 only one register per watchpoint, thus assuming that all accesses that
606 modify a memory location happen at its starting address. */
608 extern bool target_exact_watchpoints
;
610 using bp_location_list
= intrusive_list
<bp_location
>;
611 using bp_location_iterator
= bp_location_list::iterator
;
612 using bp_location_range
= iterator_range
<bp_location_iterator
>;
614 /* Note that the ->silent field is not currently used by any commands
615 (though the code is in there if it was to be, and set_raw_breakpoint
616 does set it to 0). I implemented it because I thought it would be
617 useful for a hack I had to put in; I'm going to leave it in because
618 I can see how there might be times when it would indeed be useful */
620 /* Abstract base class representing all kinds of breakpoints. */
622 struct breakpoint
: public intrusive_list_node
<breakpoint
>
624 breakpoint (struct gdbarch
*gdbarch_
, enum bptype bptype
,
625 bool temp
= true, const char *cond_string
= nullptr);
627 DISABLE_COPY_AND_ASSIGN (breakpoint
);
629 virtual ~breakpoint () = 0;
631 /* Allocate a location for this breakpoint. */
632 virtual struct bp_location
*allocate_location ();
634 /* Return a range of this breakpoint's locations. */
635 bp_location_range
locations () const;
637 /* Add LOC to the location list of this breakpoint, sorted by address
640 LOC must have this breakpoint as its owner. LOC must not already be linked
641 in a location list. */
642 void add_location (bp_location
&loc
);
644 /* Remove LOC from this breakpoint's location list. The name is a bit funny
645 because remove_location is already taken, and means something else.
647 LOC must be have this breakpoints as its owner. LOC must be linked in this
648 breakpoint's location list. */
649 void unadd_location (bp_location
&loc
);
651 /* Clear the location list of this breakpoint. */
652 void clear_locations ()
653 { m_locations
.clear (); }
655 /* Split all locations of this breakpoint that are bound to PSPACE out of its
656 location list to a separate list and return that list. If
657 PSPACE is nullptr, hoist out all locations. */
658 bp_location_list
steal_locations (program_space
*pspace
);
660 /* Return true if this breakpoint has a least one location. */
661 bool has_locations () const
662 { return !m_locations
.empty (); }
664 /* Return true if this breakpoint has a single location. */
665 bool has_single_location () const
667 if (!this->has_locations ())
670 return std::next (m_locations
.begin ()) == m_locations
.end ();
673 /* Return true if this breakpoint has multiple locations. */
674 bool has_multiple_locations () const
676 if (!this->has_locations ())
679 return std::next (m_locations
.begin ()) != m_locations
.end ();
682 /* Return a reference to the first location of this breakpoint. */
683 bp_location
&first_loc ()
685 gdb_assert (this->has_locations ());
686 return m_locations
.front ();
689 /* Return a reference to the first location of this breakpoint. */
690 const bp_location
&first_loc () const
692 gdb_assert (this->has_locations ());
693 return m_locations
.front ();
696 /* Return a reference to the last location of this breakpoint. */
697 const bp_location
&last_loc () const
699 gdb_assert (this->has_locations ());
700 return m_locations
.back ();
703 /* Reevaluate a breakpoint. This is necessary after symbols change
704 (e.g., an executable or DSO was loaded, or the inferior just
706 virtual void re_set ()
708 /* Nothing to re-set. */
711 /* Insert the breakpoint or watchpoint or activate the catchpoint.
712 Return 0 for success, 1 if the breakpoint, watchpoint or
713 catchpoint type is not supported, -1 for failure. */
714 virtual int insert_location (struct bp_location
*);
716 /* Remove the breakpoint/catchpoint that was previously inserted
717 with the "insert" method above. Return 0 for success, 1 if the
718 breakpoint, watchpoint or catchpoint type is not supported,
720 virtual int remove_location (struct bp_location
*,
721 enum remove_bp_reason reason
);
723 /* Return true if it the target has stopped due to hitting
724 breakpoint location BL. This function does not check if we
725 should stop, only if BL explains the stop. ASPACE is the address
726 space in which the event occurred, BP_ADDR is the address at
727 which the inferior stopped, and WS is the target_waitstatus
728 describing the event. */
729 virtual int breakpoint_hit (const struct bp_location
*bl
,
730 const address_space
*aspace
,
732 const target_waitstatus
&ws
);
734 /* Check internal conditions of the breakpoint referred to by BS.
735 If we should not stop for this breakpoint, set BS->stop to
737 virtual void check_status (struct bpstat
*bs
)
742 /* Tell how many hardware resources (debug registers) are needed
743 for this breakpoint. If this function is not provided, then
744 the breakpoint or watchpoint needs one debug register. */
745 virtual int resources_needed (const struct bp_location
*);
747 /* The normal print routine for this breakpoint, called when we
749 virtual enum print_stop_action
print_it (const bpstat
*bs
) const;
751 /* Display information about this breakpoint, for "info
752 breakpoints". Returns false if this method should use the
754 virtual bool print_one (const bp_location
**) const
759 /* Display extra information about this breakpoint, below the normal
760 breakpoint description in "info breakpoints".
762 In the example below, the "address range" line was printed
763 by ranged_breakpoint::print_one_detail.
765 (gdb) info breakpoints
766 Num Type Disp Enb Address What
767 2 hw breakpoint keep y in main at test-watch.c:70
768 address range: [0x10000458, 0x100004c7]
771 virtual void print_one_detail (struct ui_out
*) const
776 /* Display information about this breakpoint after setting it
777 (roughly speaking; this is called from "mention"). */
778 virtual void print_mention () const;
780 /* Print to FP the CLI command that recreates this breakpoint. */
781 virtual void print_recreate (struct ui_file
*fp
) const;
783 /* Return true if this breakpoint explains a signal. See
784 bpstat_explains_signal. */
785 virtual bool explains_signal (enum gdb_signal
)
790 /* Called after evaluating the breakpoint's condition,
791 and only if it evaluated true. */
792 virtual void after_condition_true (struct bpstat
*bs
)
797 /* Type of breakpoint. */
798 bptype type
= bp_none
;
799 /* Zero means disabled; remember the info but don't break here. */
800 enum enable_state enable_state
= bp_enabled
;
801 /* What to do with this breakpoint after we hit it. */
802 bpdisp disposition
= disp_del
;
803 /* Number assigned to distinguish breakpoints. */
806 /* True means a silent breakpoint (don't print frame info if we stop
809 /* True means display ADDR_STRING to the user verbatim. */
810 bool display_canonical
= false;
811 /* Number of stops at this breakpoint that should be continued
812 automatically before really stopping. */
813 int ignore_count
= 0;
815 /* Number of stops at this breakpoint before it will be
817 int enable_count
= 0;
819 /* Chain of command lines to execute when this breakpoint is
821 counted_command_line commands
;
822 /* Stack depth (address of frame). If nonzero, break only if fp
824 struct frame_id frame_id
= null_frame_id
;
826 /* The program space used to set the breakpoint. This is only set
827 for breakpoints which are specific to a program space; for
828 non-thread-specific ordinary breakpoints this is NULL. */
829 program_space
*pspace
= NULL
;
831 /* The location specification we used to set the breakpoint. */
832 location_spec_up locspec
;
834 /* The filter that should be passed to decode_line_full when
835 re-setting this breakpoint. This may be NULL. */
836 gdb::unique_xmalloc_ptr
<char> filter
;
838 /* For a ranged breakpoint, the location specification we used to
839 find the end of the range. */
840 location_spec_up locspec_range_end
;
842 /* Architecture we used to set the breakpoint. */
843 struct gdbarch
*gdbarch
;
844 /* Language we used to set the breakpoint. */
845 enum language language
;
846 /* Input radix we used to set the breakpoint. */
848 /* String form of the breakpoint condition (malloc'd), or NULL if
849 there is no condition. */
850 gdb::unique_xmalloc_ptr
<char> cond_string
;
852 /* String form of extra parameters, or NULL if there are none.
854 gdb::unique_xmalloc_ptr
<char> extra_string
;
856 /* Holds the address of the related watchpoint_scope breakpoint when
857 using watchpoints on local variables (might the concept of a
858 related breakpoint be useful elsewhere, if not just call it the
859 watchpoint_scope breakpoint or something like that. FIXME). */
860 breakpoint
*related_breakpoint
;
862 /* Thread number for thread-specific breakpoint, or -1 if don't
866 /* Inferior number for inferior-specific breakpoint, or -1 if this
867 breakpoint is for all inferiors. */
870 /* Ada task number for task-specific breakpoint, or -1 if don't
874 /* Count of the number of times this breakpoint was taken, dumped
875 with the info, but not used for anything else. Useful for seeing
876 how many times you hit a break prior to the program aborting, so
877 you can back up to just before the abort. */
880 /* Is breakpoint's condition not yet parsed because we found no
881 location initially so had no context to parse the condition
883 int condition_not_parsed
= 0;
885 /* With a Python scripting enabled GDB, store a reference to the
886 Python object that has been associated with this breakpoint.
887 This is always NULL for a GDB that is not script enabled. It can
888 sometimes be NULL for enabled GDBs as not all breakpoint types
889 are tracked by the scripting language API. */
890 gdbpy_breakpoint_object
*py_bp_object
= NULL
;
892 /* Same as py_bp_object, but for Scheme. */
893 gdbscm_breakpoint_object
*scm_bp_object
= NULL
;
897 /* Helper for breakpoint_ops->print_recreate implementations. Prints
898 the "thread" or "task" condition of B, and then a newline.
900 Necessary because most breakpoint implementations accept
901 thread/task conditions at the end of the spec line, like "break foo
902 thread 1", which needs outputting before any breakpoint-type
903 specific extra command necessary for B's recreation. */
904 void print_recreate_thread (struct ui_file
*fp
) const;
906 /* Location(s) associated with this high-level breakpoint. */
907 bp_location_list m_locations
;
910 /* Abstract base class representing code breakpoints. User "break"
911 breakpoints, internal and momentary breakpoints, etc. IOW, any
912 kind of breakpoint whose locations are created from SALs. */
913 struct code_breakpoint
: public breakpoint
915 using breakpoint::breakpoint
;
917 /* Create a breakpoint with SALS as locations. Use LOCATION as a
918 description of the location, and COND_STRING as condition
919 expression. If LOCATION is NULL then create an "address
920 location" from the address in the SAL. */
921 code_breakpoint (struct gdbarch
*gdbarch
, bptype type
,
922 gdb::array_view
<const symtab_and_line
> sals
,
923 location_spec_up
&&locspec
,
924 gdb::unique_xmalloc_ptr
<char> filter
,
925 gdb::unique_xmalloc_ptr
<char> cond_string
,
926 gdb::unique_xmalloc_ptr
<char> extra_string
,
927 enum bpdisp disposition
,
928 int thread
, int task
, int inferior
, int ignore_count
,
930 int enabled
, unsigned flags
,
931 int display_canonical
);
933 ~code_breakpoint () override
= 0;
935 /* Add a location for SAL to this breakpoint. */
936 bp_location
*add_location (const symtab_and_line
&sal
);
938 void re_set () override
;
939 int insert_location (struct bp_location
*) override
;
940 int remove_location (struct bp_location
*,
941 enum remove_bp_reason reason
) override
;
942 int breakpoint_hit (const struct bp_location
*bl
,
943 const address_space
*aspace
,
945 const target_waitstatus
&ws
) override
;
949 /* Given the location spec, this method decodes it and returns the
950 SAL locations related to it. For ordinary breakpoints, it calls
951 `decode_line_full'. If SEARCH_PSPACE is not NULL, symbol search
952 is restricted to just that program space.
954 This function is called inside `location_spec_to_sals'. */
955 virtual std::vector
<symtab_and_line
> decode_location_spec
956 (location_spec
*locspec
,
957 struct program_space
*search_pspace
);
959 /* Helper method that does the basic work of re_set. */
960 void re_set_default ();
962 /* Find the SaL locations corresponding to the given LOCATION.
963 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
965 std::vector
<symtab_and_line
> location_spec_to_sals
966 (location_spec
*locspec
,
967 struct program_space
*search_pspace
,
970 /* Helper for breakpoint and tracepoint breakpoint->mention
972 void say_where () const;
975 /* An instance of this type is used to represent a watchpoint,
976 a.k.a. a data breakpoint. */
978 struct watchpoint
: public breakpoint
980 using breakpoint::breakpoint
;
982 void re_set () override
;
983 int insert_location (struct bp_location
*) override
;
984 int remove_location (struct bp_location
*,
985 enum remove_bp_reason reason
) override
;
986 int breakpoint_hit (const struct bp_location
*bl
,
987 const address_space
*aspace
,
989 const target_waitstatus
&ws
) override
;
990 void check_status (struct bpstat
*bs
) override
;
991 int resources_needed (const struct bp_location
*) override
;
993 /* Tell whether we can downgrade from a hardware watchpoint to a software
994 one. If not, the user will not be able to enable the watchpoint when
995 there are not enough hardware resources available. */
996 virtual bool works_in_software_mode () const;
998 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
999 void print_mention () const override
;
1000 void print_recreate (struct ui_file
*fp
) const override
;
1001 bool explains_signal (enum gdb_signal
) override
;
1003 /* String form of exp to use for displaying to the user (malloc'd),
1005 gdb::unique_xmalloc_ptr
<char> exp_string
;
1006 /* String form to use for reparsing of EXP (malloc'd) or NULL. */
1007 gdb::unique_xmalloc_ptr
<char> exp_string_reparse
;
1009 /* The expression we are watching, or NULL if not a watchpoint. */
1011 /* The largest block within which it is valid, or NULL if it is
1012 valid anywhere (e.g. consists just of global symbols). */
1013 const struct block
*exp_valid_block
;
1014 /* The conditional expression if any. */
1015 expression_up cond_exp
;
1016 /* The largest block within which it is valid, or NULL if it is
1017 valid anywhere (e.g. consists just of global symbols). */
1018 const struct block
*cond_exp_valid_block
;
1019 /* Value of the watchpoint the last time we checked it, or NULL when
1020 we do not know the value yet or the value was not readable. VAL
1024 /* True if VAL is valid. If VAL_VALID is set but VAL is NULL,
1025 then an error occurred reading the value. */
1028 /* When watching the location of a bitfield, contains the offset and size of
1029 the bitfield. Otherwise contains 0. */
1033 /* Holds the frame address which identifies the frame this
1034 watchpoint should be evaluated in, or `null' if the watchpoint
1035 should be evaluated on the outermost frame. */
1036 struct frame_id watchpoint_frame
;
1038 /* Holds the thread which identifies the frame this watchpoint
1039 should be considered in scope for, or `null_ptid' if the
1040 watchpoint should be evaluated in all threads. */
1041 ptid_t watchpoint_thread
;
1043 /* For hardware watchpoints, the triggered status according to the
1045 enum watchpoint_triggered watchpoint_triggered
;
1047 /* Whether this watchpoint is exact (see
1048 target_exact_watchpoints). */
1051 /* The mask address for a masked hardware watchpoint. */
1052 CORE_ADDR hw_wp_mask
;
1055 /* Return true if BPT is either a software breakpoint or a hardware
1058 extern bool is_breakpoint (const struct breakpoint
*bpt
);
1060 /* Return true if BPT is of any watchpoint kind, hardware or
1063 extern bool is_watchpoint (const struct breakpoint
*bpt
);
1065 /* Return true if BPT is a C++ exception catchpoint (catch
1066 catch/throw/rethrow). */
1068 extern bool is_exception_catchpoint (breakpoint
*bp
);
1070 /* An instance of this type is used to represent all kinds of
1073 struct tracepoint
: public code_breakpoint
1075 using code_breakpoint::code_breakpoint
;
1077 int breakpoint_hit (const struct bp_location
*bl
,
1078 const address_space
*aspace
, CORE_ADDR bp_addr
,
1079 const target_waitstatus
&ws
) override
;
1080 void print_one_detail (struct ui_out
*uiout
) const override
;
1081 void print_mention () const override
;
1082 void print_recreate (struct ui_file
*fp
) const override
;
1084 /* Number of times this tracepoint should single-step and collect
1086 long step_count
= 0;
1088 /* Number of times this tracepoint should be hit before
1089 disabling/ending. */
1092 /* The number of the tracepoint on the target. */
1093 int number_on_target
= 0;
1095 /* The total space taken by all the trace frames for this
1097 ULONGEST traceframe_usage
= 0;
1099 /* The static tracepoint marker id, if known. */
1100 std::string static_trace_marker_id
;
1102 /* LTTng/UST allow more than one marker with the same ID string,
1103 although it unadvised because it confuses tools. When setting
1104 static tracepoints by marker ID, this will record the index in
1105 the array of markers we found for the given marker ID for which
1106 this static tracepoint corresponds. When resetting breakpoints,
1107 we will use this index to try to find the same marker again. */
1108 int static_trace_marker_id_idx
= 0;
1111 /* The abstract base class for catchpoints. */
1113 struct catchpoint
: public breakpoint
1115 /* If TEMP is true, then make the breakpoint temporary. If
1116 COND_STRING is not NULL, then store it in the breakpoint. */
1117 catchpoint (struct gdbarch
*gdbarch
, bool temp
, const char *cond_string
);
1119 ~catchpoint () override
= 0;
1123 /* The following stuff is an abstract data type "bpstat" ("breakpoint
1124 status"). This provides the ability to determine whether we have
1125 stopped at a breakpoint, and what we should do about it. */
1127 /* Clears a chain of bpstat, freeing storage
1129 extern void bpstat_clear (bpstat
**);
1131 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
1132 is part of the bpstat is copied as well. */
1133 extern bpstat
*bpstat_copy (bpstat
*);
1135 /* Build the (raw) bpstat chain for the stop information given by ASPACE,
1136 BP_ADDR, and WS. Returns the head of the bpstat chain. */
1138 extern bpstat
*build_bpstat_chain (const address_space
*aspace
,
1140 const target_waitstatus
&ws
);
1142 /* Get a bpstat associated with having just stopped at address
1143 BP_ADDR in thread PTID. STOP_CHAIN may be supplied as a previously
1144 computed stop chain or NULL, in which case the stop chain will be
1145 computed using build_bpstat_chain.
1147 Determine whether we stopped at a breakpoint, etc, or whether we
1148 don't understand this stop. Result is a chain of bpstat's such
1151 if we don't understand the stop, the result is a null pointer.
1153 if we understand why we stopped, the result is not null.
1155 Each element of the chain refers to a particular breakpoint or
1156 watchpoint at which we have stopped. (We may have stopped for
1157 several reasons concurrently.)
1159 Each element of the chain has valid next, breakpoint_at,
1160 commands, FIXME??? fields.
1162 watchpoints_triggered must be called beforehand to set up each
1163 watchpoint's watchpoint_triggered value.
1167 extern bpstat
*bpstat_stop_status (const address_space
*aspace
,
1168 CORE_ADDR pc
, thread_info
*thread
,
1169 const target_waitstatus
&ws
,
1170 bpstat
*stop_chain
= nullptr);
1172 /* Like bpstat_stop_status, but clears all watchpoints'
1173 watchpoint_triggered flag. Unlike with bpstat_stop_status, there's
1174 no need to call watchpoint_triggered beforehand. You'll typically
1175 use this variant when handling a known-non-watchpoint event, like a
1176 fork or exec event. */
1178 extern bpstat
*bpstat_stop_status_nowatch (const address_space
*aspace
,
1180 thread_info
*thread
,
1181 const target_waitstatus
&ws
);
1185 /* This bpstat_what stuff tells wait_for_inferior what to do with a
1186 breakpoint (a challenging task).
1188 The enum values order defines priority-like order of the actions.
1189 Once you've decided that some action is appropriate, you'll never
1190 go back and decide something of a lower priority is better. Each
1191 of these actions is mutually exclusive with the others. That
1192 means, that if you find yourself adding a new action class here and
1193 wanting to tell GDB that you have two simultaneous actions to
1194 handle, something is wrong, and you probably don't actually need a
1197 Note that a step resume breakpoint overrides another breakpoint of
1198 signal handling (see comment in wait_for_inferior at where we set
1199 the step_resume breakpoint). */
1201 enum bpstat_what_main_action
1203 /* Perform various other tests; that is, this bpstat does not
1204 say to perform any action (e.g. failed watchpoint and nothing
1206 BPSTAT_WHAT_KEEP_CHECKING
,
1208 /* Remove breakpoints, single step once, then put them back in and
1209 go back to what we were doing. It's possible that this should
1210 be removed from the main_action and put into a separate field,
1211 to more cleanly handle
1212 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE. */
1215 /* Set longjmp_resume breakpoint, remove all other breakpoints,
1216 and continue. The "remove all other breakpoints" part is
1217 required if we are also stepping over another breakpoint as
1218 well as doing the longjmp handling. */
1219 BPSTAT_WHAT_SET_LONGJMP_RESUME
,
1221 /* Clear longjmp_resume breakpoint, then handle as
1222 BPSTAT_WHAT_KEEP_CHECKING. */
1223 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
,
1225 /* Clear step resume breakpoint, and keep checking. */
1226 BPSTAT_WHAT_STEP_RESUME
,
1228 /* Rather than distinguish between noisy and silent stops here, it
1229 might be cleaner to have bpstat_print make that decision (also
1230 taking into account stop_print_frame and source_only). But the
1231 implications are a bit scary (interaction with auto-displays,
1232 etc.), so I won't try it. */
1234 /* Stop silently. */
1235 BPSTAT_WHAT_STOP_SILENT
,
1237 /* Stop and print. */
1238 BPSTAT_WHAT_STOP_NOISY
,
1240 /* Clear step resume breakpoint, and keep checking. High-priority
1241 step-resume breakpoints are used when even if there's a user
1242 breakpoint at the current PC when we set the step-resume
1243 breakpoint, we don't want to re-handle any breakpoint other
1244 than the step-resume when it's hit; instead we want to move
1245 past the breakpoint. This is used in the case of skipping
1247 BPSTAT_WHAT_HP_STEP_RESUME
,
1250 /* An enum indicating the kind of "stack dummy" stop. This is a bit
1251 of a misnomer because only one kind of truly a stack dummy. */
1252 enum stop_stack_kind
1254 /* We didn't stop at a stack dummy breakpoint. */
1257 /* Stopped at a stack dummy. */
1260 /* Stopped at std::terminate. */
1266 enum bpstat_what_main_action main_action
;
1268 /* Did we hit a call dummy breakpoint? This only goes with a
1269 main_action of BPSTAT_WHAT_STOP_SILENT or
1270 BPSTAT_WHAT_STOP_NOISY (the concept of continuing from a call
1271 dummy without popping the frame is not a useful one). */
1272 enum stop_stack_kind call_dummy
;
1274 /* Used for BPSTAT_WHAT_SET_LONGJMP_RESUME and
1275 BPSTAT_WHAT_CLEAR_LONGJMP_RESUME. True if we are handling a
1276 longjmp, false if we are handling an exception. */
1280 /* Tell what to do about this bpstat. */
1281 struct bpstat_what
bpstat_what (bpstat
*);
1283 /* Run breakpoint event callbacks associated with the breakpoints that
1285 extern void bpstat_run_callbacks (bpstat
*bs_head
);
1287 /* Find the bpstat associated with a breakpoint. NULL otherwise. */
1288 bpstat
*bpstat_find_breakpoint (bpstat
*, struct breakpoint
*);
1290 /* True if a signal that we got in target_wait() was due to
1291 circumstances explained by the bpstat; the signal is therefore not
1293 extern bool bpstat_explains_signal (bpstat
*, enum gdb_signal
);
1295 /* True if this bpstat causes a stop. */
1296 extern bool bpstat_causes_stop (bpstat
*);
1298 /* True if we should step constantly (e.g. watchpoints on machines
1299 without hardware support). This isn't related to a specific bpstat,
1300 just to things like whether watchpoints are set. */
1301 extern bool bpstat_should_step ();
1303 /* Print a message indicating what happened. */
1304 extern enum print_stop_action
bpstat_print (bpstat
*bs
, target_waitkind kind
);
1306 /* Put in *NUM the breakpoint number of the first breakpoint we are
1307 stopped at. *BSP upon return is a bpstat which points to the
1308 remaining breakpoints stopped at (but which is not guaranteed to be
1309 good for anything but further calls to bpstat_num).
1311 Return 0 if passed a bpstat which does not indicate any breakpoints.
1312 Return -1 if stopped at a breakpoint that has been deleted since
1314 Return 1 otherwise. */
1315 extern int bpstat_num (bpstat
**, int *);
1317 /* If BS indicates a breakpoint and this breakpoint has several code locations,
1318 return the location number of BS, otherwise return 0. */
1320 extern int bpstat_locno (const bpstat
*bs
);
1322 /* Print BS breakpoint number optionally followed by a . and breakpoint locno.
1324 For a breakpoint with only one code location, outputs the signed field
1325 "bkptno" breakpoint number of BS (as returned by bpstat_num).
1326 If BS has several code locations, outputs a '.' character followed by
1327 the signed field "locno" (as returned by bpstat_locno). */
1329 extern void print_num_locno (const bpstat
*bs
, struct ui_out
*);
1331 /* Perform actions associated with the stopped inferior. Actually, we
1332 just use this for breakpoint commands. Perhaps other actions will
1333 go here later, but this is executed at a late time (from the
1335 extern void bpstat_do_actions (void);
1337 /* Modify all entries of STOP_BPSTAT of INFERIOR_PTID so that the actions will
1338 not be performed. */
1339 extern void bpstat_clear_actions (void);
1341 /* Implementation: */
1343 /* Values used to tell the printing routine how to behave for this
1347 /* This is used when we want to do a normal printing of the reason
1348 for stopping. The output will depend on the type of eventpoint
1349 we are dealing with. This is the default value, most commonly
1352 /* This is used when nothing should be printed for this bpstat
1355 /* This is used when everything which needs to be printed has
1356 already been printed. But we still want to print the frame. */
1363 bpstat (struct bp_location
*bl
, bpstat
***bs_link_pointer
);
1365 bpstat (const bpstat
&);
1366 bpstat
&operator= (const bpstat
&) = delete;
1368 /* Linked list because there can be more than one breakpoint at
1369 the same place, and a bpstat reflects the fact that all have
1373 /* Location that caused the stop. Locations are refcounted, so
1374 this will never be NULL. Note that this location may end up
1375 detached from a breakpoint, but that does not necessary mean
1376 that the struct breakpoint is gone. E.g., consider a
1377 watchpoint with a condition that involves an inferior function
1378 call. Watchpoint locations are recreated often (on resumes,
1379 hence on infcalls too). Between creating the bpstat and after
1380 evaluating the watchpoint condition, this location may hence
1381 end up detached from its original owner watchpoint, even though
1382 the watchpoint is still listed. If it's condition evaluates as
1383 true, we still want this location to cause a stop, and we will
1384 still need to know which watchpoint it was originally attached.
1385 What this means is that we should not (in most cases) follow
1386 the `bpstat->bp_location->owner' link, but instead use the
1387 `breakpoint_at' field below. */
1388 bp_location_ref_ptr bp_location_at
;
1390 /* Breakpoint that caused the stop. This is nullified if the
1391 breakpoint ends up being deleted. See comments on
1392 `bp_location_at' above for why do we need this field instead of
1393 following the location's owner. */
1394 struct breakpoint
*breakpoint_at
;
1396 /* The associated command list. */
1397 counted_command_line commands
;
1399 /* Old value associated with a watchpoint. */
1400 value_ref_ptr old_val
;
1402 /* True if this breakpoint tells us to print the frame. */
1405 /* True if this breakpoint tells us to stop. */
1408 /* Tell bpstat_print and print_bp_stop_message how to print stuff
1409 associated with this element of the bpstat chain. */
1410 enum bp_print_how print_it
;
1421 /* The possible return values for breakpoint_here_p.
1422 We guarantee that zero always means "no breakpoint here". */
1423 enum breakpoint_here
1425 no_breakpoint_here
= 0,
1426 ordinary_breakpoint_here
,
1427 permanent_breakpoint_here
1431 /* Prototypes for breakpoint-related functions. */
1433 extern enum breakpoint_here
breakpoint_here_p (const address_space
*,
1436 /* Return true if an enabled breakpoint exists in the range defined by
1437 ADDR and LEN, in ASPACE. */
1438 extern int breakpoint_in_range_p (const address_space
*aspace
,
1439 CORE_ADDR addr
, ULONGEST len
);
1441 extern int moribund_breakpoint_here_p (const address_space
*, CORE_ADDR
);
1443 extern int breakpoint_inserted_here_p (const address_space
*,
1446 extern int software_breakpoint_inserted_here_p (const address_space
*,
1449 /* Return non-zero iff there is a hardware breakpoint inserted at
1451 extern int hardware_breakpoint_inserted_here_p (const address_space
*,
1454 /* Check whether any location of BP is inserted at PC. */
1456 extern int breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
1457 const address_space
*aspace
,
1460 extern int single_step_breakpoint_inserted_here_p (const address_space
*,
1463 /* Returns true if there's a hardware watchpoint or access watchpoint
1464 inserted in the range defined by ADDR and LEN. */
1465 extern int hardware_watchpoint_inserted_in_range (const address_space
*,
1469 /* Returns true if {ASPACE1,ADDR1} and {ASPACE2,ADDR2} represent the
1470 same breakpoint location. In most targets, this can only be true
1471 if ASPACE1 matches ASPACE2. On targets that have global
1472 breakpoints, the address space doesn't really matter. */
1474 extern int breakpoint_address_match (const address_space
*aspace1
,
1476 const address_space
*aspace2
,
1479 extern void until_break_command (const char *, int, int);
1481 /* Initialize a struct bp_location. */
1483 extern void update_breakpoint_locations
1484 (code_breakpoint
*b
,
1485 struct program_space
*filter_pspace
,
1486 gdb::array_view
<const symtab_and_line
> sals
,
1487 gdb::array_view
<const symtab_and_line
> sals_end
);
1489 extern void breakpoint_re_set (void);
1491 extern void breakpoint_re_set_thread (struct breakpoint
*);
1493 extern void delete_breakpoint (struct breakpoint
*);
1495 struct breakpoint_deleter
1497 void operator() (struct breakpoint
*b
) const
1499 delete_breakpoint (b
);
1503 typedef std::unique_ptr
<struct breakpoint
, breakpoint_deleter
> breakpoint_up
;
1505 extern breakpoint_up set_momentary_breakpoint
1506 (struct gdbarch
*, struct symtab_and_line
, struct frame_id
, enum bptype
);
1508 extern breakpoint_up set_momentary_breakpoint_at_pc
1509 (struct gdbarch
*, CORE_ADDR pc
, enum bptype type
);
1511 extern struct breakpoint
*clone_momentary_breakpoint (struct breakpoint
*bpkt
);
1513 extern void set_ignore_count (int, int, int);
1515 extern void breakpoint_init_inferior (enum inf_context
);
1517 extern void breakpoint_auto_delete (bpstat
*);
1519 /* Return the chain of command lines to execute when this breakpoint
1521 extern struct command_line
*breakpoint_commands (struct breakpoint
*b
);
1523 /* Return a string image of DISP. The string is static, and thus should
1524 NOT be deallocated after use. */
1525 const char *bpdisp_text (enum bpdisp disp
);
1527 extern void break_command (const char *, int);
1529 extern void watch_command_wrapper (const char *, int, bool);
1530 extern void awatch_command_wrapper (const char *, int, bool);
1531 extern void rwatch_command_wrapper (const char *, int, bool);
1532 extern void tbreak_command (const char *, int);
1534 extern const struct breakpoint_ops code_breakpoint_ops
;
1536 /* Arguments to pass as context to some catch command handlers. */
1537 #define CATCH_PERMANENT ((void *) (uintptr_t) 0)
1538 #define CATCH_TEMPORARY ((void *) (uintptr_t) 1)
1540 /* Like add_cmd, but add the command to both the "catch" and "tcatch"
1541 lists, and pass some additional user data to the command
1545 add_catch_command (const char *name
, const char *docstring
,
1546 cmd_func_ftype
*func
,
1547 completer_ftype
*completer
,
1548 void *user_data_catch
,
1549 void *user_data_tcatch
);
1551 /* Add breakpoint B on the breakpoint list, and notify the user, the
1552 target and breakpoint_created observers of its existence. If
1553 INTERNAL is non-zero, the breakpoint number will be allocated from
1554 the internal breakpoint count. If UPDATE_GLL is non-zero,
1555 update_global_location_list will be called.
1557 Takes ownership of B, and returns a non-owning reference to it. */
1559 extern breakpoint
*install_breakpoint
1560 (int internal
, std::unique_ptr
<breakpoint
> &&b
, int update_gll
);
1562 /* Returns the breakpoint ops appropriate for use with with LOCSPEC
1563 and according to IS_TRACEPOINT. Use this to ensure, for example,
1564 that you pass the correct ops to create_breakpoint for probe
1565 location specs. If LOCSPEC is NULL, returns
1566 code_breakpoint_ops. */
1568 extern const struct breakpoint_ops
*breakpoint_ops_for_location_spec
1569 (const location_spec
*locspec
, bool is_tracepoint
);
1571 /* Flags that can be passed down to create_breakpoint, etc., to affect
1572 breakpoint creation in several ways. */
1574 enum breakpoint_create_flags
1576 /* We're adding a breakpoint to our tables that is already
1577 inserted in the target. */
1578 CREATE_BREAKPOINT_FLAGS_INSERTED
= 1 << 0
1581 /* Set a breakpoint. This function is shared between CLI and MI
1582 functions for setting a breakpoint at LOCSPEC.
1584 This function has two major modes of operations, selected by the
1585 PARSE_EXTRA parameter.
1587 If PARSE_EXTRA is zero, LOCSPEC is just the breakpoint's location
1588 spec, with condition, thread, and extra string specified by the
1589 COND_STRING, THREAD, and EXTRA_STRING parameters.
1591 If PARSE_EXTRA is non-zero, this function will attempt to extract
1592 the condition, thread, and extra string from EXTRA_STRING, ignoring
1593 the similarly named parameters.
1595 If FORCE_CONDITION is true, the condition is accepted even when it is
1596 invalid at all of the locations. However, if PARSE_EXTRA is non-zero,
1597 the FORCE_CONDITION parameter is ignored and the corresponding argument
1598 is parsed from EXTRA_STRING.
1600 If INTERNAL is non-zero, the breakpoint number will be allocated
1601 from the internal breakpoint count.
1603 Returns true if any breakpoint was created; false otherwise. */
1605 extern int create_breakpoint (struct gdbarch
*gdbarch
,
1606 struct location_spec
*locspec
,
1607 const char *cond_string
, int thread
,
1609 const char *extra_string
,
1610 bool force_condition
,
1612 int tempflag
, enum bptype wanted_type
,
1614 enum auto_boolean pending_break_support
,
1615 const struct breakpoint_ops
*ops
,
1618 int internal
, unsigned flags
);
1620 extern void insert_breakpoints (void);
1622 extern int remove_breakpoints (void);
1624 /* Remove breakpoints of inferior INF. */
1626 extern void remove_breakpoints_inf (inferior
*inf
);
1628 /* This function can be used to update the breakpoint package's state
1629 after an exec() system call has been executed.
1631 This function causes the following:
1633 - All eventpoints are marked "not inserted".
1634 - All eventpoints with a symbolic address are reset such that
1635 the symbolic address must be reevaluated before the eventpoints
1637 - The solib breakpoints are explicitly removed from the breakpoint
1639 - A step-resume breakpoint, if any, is explicitly removed from the
1641 - All eventpoints without a symbolic address are removed from the
1643 extern void update_breakpoints_after_exec (void);
1645 /* This function can be used to physically remove hardware breakpoints
1646 and watchpoints from the specified traced inferior process, without
1647 modifying the breakpoint package's state. This can be useful for
1648 those targets which support following the processes of a fork() or
1649 vfork() system call, when one of the resulting two processes is to
1650 be detached and allowed to run free.
1652 It is an error to use this function on the process whose id is
1654 extern int detach_breakpoints (ptid_t ptid
);
1656 /* This function is called when program space PSPACE is about to be
1657 deleted. It takes care of updating breakpoints to not reference
1658 this PSPACE anymore. */
1659 extern void breakpoint_program_space_exit (struct program_space
*pspace
);
1661 extern void set_longjmp_breakpoint (struct thread_info
*tp
,
1662 struct frame_id frame
);
1663 extern void delete_longjmp_breakpoint (int thread
);
1665 /* Mark all longjmp breakpoints from THREAD for later deletion. */
1666 extern void delete_longjmp_breakpoint_at_next_stop (int thread
);
1668 extern struct breakpoint
*set_longjmp_breakpoint_for_call_dummy (void);
1669 extern void check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
);
1671 extern void enable_overlay_breakpoints (void);
1672 extern void disable_overlay_breakpoints (void);
1674 extern void set_std_terminate_breakpoint (void);
1675 extern void delete_std_terminate_breakpoint (void);
1677 /* These functions respectively disable or reenable all currently
1678 enabled watchpoints. When disabled, the watchpoints are marked
1679 call_disabled. When re-enabled, they are marked enabled.
1681 The intended client of these functions is call_function_by_hand.
1683 The inferior must be stopped, and all breakpoints removed, when
1684 these functions are used.
1686 The need for these functions is that on some targets (e.g., HP-UX),
1687 gdb is unable to unwind through the dummy frame that is pushed as
1688 part of the implementation of a call command. Watchpoints can
1689 cause the inferior to stop in places where this frame is visible,
1690 and that can cause execution control to become very confused.
1692 Note that if a user sets breakpoints in an interactively called
1693 function, the call_disabled watchpoints will have been re-enabled
1694 when the first such breakpoint is reached. However, on targets
1695 that are unable to unwind through the call dummy frame, watches
1696 of stack-based storage may then be deleted, because gdb will
1697 believe that their watched storage is out of scope. (Sigh.) */
1698 extern void disable_watchpoints_before_interactive_call_start (void);
1700 extern void enable_watchpoints_after_interactive_call_stop (void);
1702 /* These functions disable and re-enable all breakpoints during
1703 inferior startup. They are intended to be called from solib
1704 code where necessary. This is needed on platforms where the
1705 main executable is relocated at some point during startup
1706 processing, making breakpoint addresses invalid.
1708 If additional breakpoints are created after the routine
1709 disable_breakpoints_before_startup but before the routine
1710 enable_breakpoints_after_startup was called, they will also
1711 be marked as disabled. */
1712 extern void disable_breakpoints_before_startup (void);
1713 extern void enable_breakpoints_after_startup (void);
1715 /* For script interpreters that need to define breakpoint commands
1716 after they've already read the commands into a struct
1718 extern enum command_control_type commands_from_control_command
1719 (const char *arg
, struct command_line
*cmd
);
1721 extern void clear_breakpoint_hit_counts (void);
1723 extern struct breakpoint
*get_breakpoint (int num
);
1725 /* The following are for displays, which aren't really breakpoints,
1726 but here is as good a place as any for them. */
1728 extern void disable_current_display (void);
1730 extern void do_displays (void);
1732 extern void disable_display (int);
1734 extern void clear_displays (void);
1736 extern void disable_breakpoint (struct breakpoint
*);
1738 extern void enable_breakpoint (struct breakpoint
*);
1740 extern void breakpoint_set_commands (struct breakpoint
*b
,
1741 counted_command_line
&&commands
);
1743 extern void breakpoint_set_silent (struct breakpoint
*b
, int silent
);
1745 /* Set the thread for this breakpoint. If THREAD is -1, make the
1746 breakpoint work for any thread. Passing a value other than -1 for
1747 THREAD should only be done if b->task is 0; it is not valid to try and
1748 set both a thread and task restriction on a breakpoint. */
1750 extern void breakpoint_set_thread (struct breakpoint
*b
, int thread
);
1752 /* Set the inferior for breakpoint B to INFERIOR. If INFERIOR is -1, make
1753 the breakpoint work for any inferior. */
1755 extern void breakpoint_set_inferior (struct breakpoint
*b
, int inferior
);
1757 /* Set the task for this breakpoint. If TASK is -1, make the breakpoint
1758 work for any task. Passing a value other than -1 for TASK should only
1759 be done if b->thread is -1; it is not valid to try and set both a thread
1760 and task restriction on a breakpoint. */
1762 extern void breakpoint_set_task (struct breakpoint
*b
, int task
);
1764 /* Clear the "inserted" flag in all breakpoints. */
1765 extern void mark_breakpoints_out (void);
1767 extern struct breakpoint
*create_jit_event_breakpoint (struct gdbarch
*,
1770 extern struct breakpoint
*create_solib_event_breakpoint (struct gdbarch
*,
1773 /* Create an solib event breakpoint at ADDRESS in the current program
1774 space, and immediately try to insert it. Returns a pointer to the
1775 breakpoint on success. Deletes the new breakpoint and returns NULL
1776 if inserting the breakpoint fails. */
1777 extern struct breakpoint
*create_and_insert_solib_event_breakpoint
1778 (struct gdbarch
*gdbarch
, CORE_ADDR address
);
1780 extern struct breakpoint
*create_thread_event_breakpoint (struct gdbarch
*,
1783 extern void remove_jit_event_breakpoints (void);
1785 extern void remove_solib_event_breakpoints (void);
1787 /* Mark solib event breakpoints of the current program space with
1788 delete at next stop disposition. */
1789 extern void remove_solib_event_breakpoints_at_next_stop (void);
1791 extern void disable_breakpoints_in_shlibs (void);
1793 /* This function returns true if B is a catchpoint. */
1795 extern bool is_catchpoint (struct breakpoint
*b
);
1797 /* Shared helper function (MI and CLI) for creating and installing
1798 a shared object event catchpoint. If IS_LOAD is true then
1799 the events to be caught are load events, otherwise they are
1800 unload events. If IS_TEMP is true the catchpoint is a
1801 temporary one. If ENABLED is true the catchpoint is
1802 created in an enabled state. */
1804 extern void add_solib_catchpoint (const char *arg
, bool is_load
, bool is_temp
,
1807 /* Create and insert a new software single step breakpoint for the
1808 current thread. May be called multiple times; each time will add a
1809 new location to the set of potential addresses the next instruction
1811 extern void insert_single_step_breakpoint (struct gdbarch
*,
1812 const address_space
*,
1815 /* Insert all software single step breakpoints for the current frame.
1816 Return true if any software single step breakpoints are inserted,
1817 otherwise, return false. */
1818 extern int insert_single_step_breakpoints (struct gdbarch
*);
1820 /* Check whether any hardware watchpoints have triggered or not,
1821 according to the target, and record it in each watchpoint's
1822 'watchpoint_triggered' field. */
1823 int watchpoints_triggered (const target_waitstatus
&);
1825 /* Helper for transparent breakpoint hiding for memory read and write
1828 Update one of READBUF or WRITEBUF with either the shadows
1829 (READBUF), or the breakpoint instructions (WRITEBUF) of inserted
1830 breakpoints at the memory range defined by MEMADDR and extending
1831 for LEN bytes. If writing, then WRITEBUF is a copy of WRITEBUF_ORG
1833 extern void breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1834 const gdb_byte
*writebuf_org
,
1835 ULONGEST memaddr
, LONGEST len
);
1837 /* Return true if breakpoints should be inserted now. That'll be the
1840 - the target has global breakpoints.
1842 - "breakpoint always-inserted" is on, and the target has
1845 - threads are executing.
1847 extern int breakpoints_should_be_inserted_now (void);
1849 /* Called each time new event from target is processed.
1850 Retires previously deleted breakpoint locations that
1851 in our opinion won't ever trigger. */
1852 extern void breakpoint_retire_moribund (void);
1854 /* Set break condition of breakpoint B to EXP.
1855 If FORCE, define the condition even if it is invalid in
1856 all of the breakpoint locations. */
1857 extern void set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
1858 int from_tty
, bool force
);
1860 /* Set break condition for the breakpoint with number BPNUM to EXP.
1861 Raise an error if no breakpoint with the given number is found.
1862 Also raise an error if the breakpoint already has stop conditions.
1863 If FORCE, define the condition even if it is invalid in
1864 all of the breakpoint locations. */
1865 extern void set_breakpoint_condition (int bpnum
, const char *exp
,
1866 int from_tty
, bool force
);
1868 /* Checks if we are catching syscalls or not.
1869 Returns 0 if not, greater than 0 if we are. */
1870 extern int catch_syscall_enabled (void);
1872 /* Checks if we are catching syscalls with the specific
1873 syscall_number. Used for "filtering" the catchpoints.
1874 Returns false if not, true if we are. */
1875 extern bool catching_syscall_number (int syscall_number
);
1877 /* Return a tracepoint with the given number if found. */
1878 extern struct tracepoint
*get_tracepoint (int num
);
1880 extern struct tracepoint
*get_tracepoint_by_number_on_target (int num
);
1882 /* Find a tracepoint by parsing a number in the supplied string. */
1883 extern struct tracepoint
*
1884 get_tracepoint_by_number (const char **arg
,
1885 number_or_range_parser
*parser
);
1887 /* Return true if B is of tracepoint kind. */
1889 extern bool is_tracepoint (const struct breakpoint
*b
);
1891 /* Return a vector of all static tracepoints defined at ADDR. */
1892 extern std::vector
<breakpoint
*> static_tracepoints_here (CORE_ADDR addr
);
1894 /* Create an instance of this to start registering breakpoint numbers
1895 for a later "commands" command. */
1897 class scoped_rbreak_breakpoints
1901 scoped_rbreak_breakpoints ();
1902 ~scoped_rbreak_breakpoints ();
1904 DISABLE_COPY_AND_ASSIGN (scoped_rbreak_breakpoints
);
1907 /* Breakpoint linked list iterator. */
1909 using breakpoint_list
= intrusive_list
<breakpoint
>;
1911 using breakpoint_iterator
= breakpoint_list::iterator
;
1913 /* Breakpoint linked list range. */
1915 using breakpoint_range
= iterator_range
<breakpoint_iterator
>;
1917 /* Return a range to iterate over all breakpoints. */
1919 breakpoint_range
all_breakpoints ();
1921 /* Breakpoint linked list range, safe against deletion of the current
1922 breakpoint while iterating. */
1924 using breakpoint_safe_range
= basic_safe_range
<breakpoint_range
>;
1926 /* Return a range to iterate over all breakpoints. This range is safe against
1927 deletion of the current breakpoint while iterating. */
1929 breakpoint_safe_range
all_breakpoints_safe ();
1931 /* Breakpoint filter to only keep tracepoints. */
1933 struct tracepoint_filter
1935 bool operator() (breakpoint
&b
)
1936 { return is_tracepoint (&b
); }
1939 /* Breakpoint linked list iterator, filtering to only keep tracepoints. */
1941 using tracepoint_iterator
1942 = filtered_iterator
<breakpoint_iterator
, tracepoint_filter
>;
1944 /* Breakpoint linked list range, filtering to only keep tracepoints. */
1946 using tracepoint_range
= iterator_range
<tracepoint_iterator
>;
1948 /* Return a range to iterate over all tracepoints. */
1950 tracepoint_range
all_tracepoints ();
1952 /* Return a range to iterate over all breakpoint locations. */
1954 const std::vector
<bp_location
*> &all_bp_locations ();
1956 /* Nonzero if the specified PC cannot be a location where functions
1957 have been inlined. */
1959 extern int pc_at_non_inline_function (const address_space
*aspace
,
1961 const target_waitstatus
&ws
);
1963 extern int user_breakpoint_p (struct breakpoint
*);
1965 /* Return true if this breakpoint is pending, false if not. */
1966 extern int pending_breakpoint_p (struct breakpoint
*);
1968 /* Attempt to determine architecture of location identified by SAL. */
1969 extern struct gdbarch
*get_sal_arch (struct symtab_and_line sal
);
1971 extern void breakpoint_free_objfile (struct objfile
*objfile
);
1973 extern const char *ep_parse_optional_if_clause (const char **arg
);
1975 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" to
1976 UIOUT iff debugging multiple threads. */
1977 extern void maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
);
1979 /* Print the specified breakpoint. */
1980 extern void print_breakpoint (breakpoint
*bp
);
1982 /* Command element for the 'commands' command. */
1983 extern cmd_list_element
*commands_cmd_element
;
1985 /* Whether to use the fixed output when printing information about a
1986 multi-location breakpoint (see PR 9659). */
1988 extern bool fix_multi_location_breakpoint_output_globally
;
1990 /* Whether to use the fixed output when printing information about
1991 commands attached to a breakpoint. */
1993 extern bool fix_breakpoint_script_output_globally
;
1995 /* Deal with "catch catch", "catch throw", and "catch rethrow" commands and
1996 the MI equivalents. Sets up to catch events of type EX_EVENT. When
1997 TEMPFLAG is true only the next matching event is caught after which the
1998 catch-point is deleted. If REGEX is not NULL then only exceptions whose
1999 type name matches REGEX will trigger the event. */
2001 extern void catch_exception_event (enum exception_event_kind ex_event
,
2002 const char *regex
, bool tempflag
,
2005 /* A helper function that prints a shared library stopped event.
2006 IS_CATCHPOINT is true if the event is due to a "catch load"
2007 catchpoint, false otherwise. */
2009 extern void print_solib_event (bool is_catchpoint
);
2011 /* Print a message describing any user-breakpoints set at PC. This
2012 concerns with logical breakpoints, so we match program spaces, not
2015 extern void describe_other_breakpoints (struct gdbarch
*,
2016 struct program_space
*, CORE_ADDR
,
2017 struct obj_section
*, int);
2019 /* Enable or disable a breakpoint location LOC. ENABLE
2020 specifies whether to enable or disable. */
2022 extern void enable_disable_bp_location (bp_location
*loc
, bool enable
);
2025 /* Notify interpreters and observers that breakpoint B was modified. */
2027 extern void notify_breakpoint_modified (breakpoint
*b
);
2029 #endif /* !defined (BREAKPOINT_H) */