1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
26 #include "breakpoint.h"
27 #include "tracepoint.h"
29 #include "expression.h"
36 #include "gdbthread.h"
39 #include "gdb-demangle.h"
40 #include "filenames.h"
46 #include "completer.h"
48 #include "cli/cli-script.h"
52 #include "observable.h"
58 #include "parser-defs.h"
59 #include "gdbsupport/gdb_regex.h"
61 #include "cli/cli-utils.h"
64 #include "dummy-frame.h"
66 #include "gdbsupport/format.h"
67 #include "thread-fsm.h"
68 #include "tid-parse.h"
69 #include "cli/cli-style.h"
70 #include "cli/cli-decode.h"
72 /* readline include files */
73 #include "readline/tilde.h"
75 /* readline defines this. */
78 #include "mi/mi-common.h"
79 #include "extension.h"
81 #include "progspace-and-thread.h"
82 #include "gdbsupport/array-view.h"
83 #include "gdbsupport/gdb_optional.h"
85 /* Prototypes for local functions. */
87 static void map_breakpoint_numbers (const char *,
88 gdb::function_view
<void (breakpoint
*)>);
91 create_sals_from_location_spec_default (location_spec
*locspec
,
92 linespec_result
*canonical
);
94 static void create_breakpoints_sal (struct gdbarch
*,
95 struct linespec_result
*,
96 gdb::unique_xmalloc_ptr
<char>,
97 gdb::unique_xmalloc_ptr
<char>,
99 enum bpdisp
, int, int,
101 int, int, int, unsigned);
103 static int can_use_hardware_watchpoint
104 (const std::vector
<value_ref_ptr
> &vals
);
106 static void mention (const breakpoint
*);
108 static breakpoint
*add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
);
110 static breakpoint
*add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
);
112 static struct breakpoint
*
113 momentary_breakpoint_from_master (struct breakpoint
*orig
,
115 int loc_enabled
, int thread
);
117 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, bool);
119 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
122 struct program_space
*pspace
);
124 static bool watchpoint_locations_match (const struct bp_location
*loc1
,
125 const struct bp_location
*loc2
);
127 static bool breakpoint_locations_match (const struct bp_location
*loc1
,
128 const struct bp_location
*loc2
,
129 bool sw_hw_bps_match
= false);
131 static bool breakpoint_location_address_match (struct bp_location
*bl
,
132 const struct address_space
*aspace
,
135 static bool breakpoint_location_address_range_overlap (struct bp_location
*,
136 const address_space
*,
139 static int remove_breakpoint (struct bp_location
*);
140 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
142 static enum print_stop_action
print_bp_stop_message (bpstat
*bs
);
144 static int hw_breakpoint_used_count (void);
146 static int hw_watchpoint_use_count (struct breakpoint
*);
148 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
150 int *other_type_used
);
152 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
155 static void decref_bp_location (struct bp_location
**loc
);
157 static std::vector
<symtab_and_line
> bkpt_probe_decode_location_spec
158 (struct breakpoint
*b
,
159 location_spec
*locspec
,
160 struct program_space
*search_pspace
);
162 static bool bl_address_is_meaningful (bp_location
*loc
);
164 static int find_loc_num_by_location (const bp_location
*loc
);
166 /* update_global_location_list's modes of operation wrt to whether to
167 insert locations now. */
168 enum ugll_insert_mode
170 /* Don't insert any breakpoint locations into the inferior, only
171 remove already-inserted locations that no longer should be
172 inserted. Functions that delete a breakpoint or breakpoints
173 should specify this mode, so that deleting a breakpoint doesn't
174 have the side effect of inserting the locations of other
175 breakpoints that are marked not-inserted, but should_be_inserted
176 returns true on them.
178 This behavior is useful is situations close to tear-down -- e.g.,
179 after an exec, while the target still has execution, but
180 breakpoint shadows of the previous executable image should *NOT*
181 be restored to the new image; or before detaching, where the
182 target still has execution and wants to delete breakpoints from
183 GDB's lists, and all breakpoints had already been removed from
187 /* May insert breakpoints iff breakpoints_should_be_inserted_now
188 claims breakpoints should be inserted now. */
191 /* Insert locations now, irrespective of
192 breakpoints_should_be_inserted_now. E.g., say all threads are
193 stopped right now, and the user did "continue". We need to
194 insert breakpoints _before_ resuming the target, but
195 UGLL_MAY_INSERT wouldn't insert them, because
196 breakpoints_should_be_inserted_now returns false at that point,
197 as no thread is running yet. */
201 static void update_global_location_list (enum ugll_insert_mode
);
203 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
205 static void insert_breakpoint_locations (void);
207 static void trace_pass_command (const char *, int);
209 static void set_tracepoint_count (int num
);
211 static bool is_masked_watchpoint (const struct breakpoint
*b
);
213 /* Return true if B refers to a static tracepoint set by marker ("-m"),
216 static bool strace_marker_p (struct breakpoint
*b
);
218 static void bkpt_probe_create_sals_from_location_spec
219 (location_spec
*locspec
,
220 struct linespec_result
*canonical
);
221 static void tracepoint_probe_create_sals_from_location_spec
222 (location_spec
*locspec
,
223 struct linespec_result
*canonical
);
225 const struct breakpoint_ops code_breakpoint_ops
=
227 create_sals_from_location_spec_default
,
228 create_breakpoints_sal
,
231 /* Breakpoints set on probes. */
232 static const struct breakpoint_ops bkpt_probe_breakpoint_ops
=
234 bkpt_probe_create_sals_from_location_spec
,
235 create_breakpoints_sal
,
238 /* Tracepoints set on probes. */
239 static const struct breakpoint_ops tracepoint_probe_breakpoint_ops
=
241 tracepoint_probe_create_sals_from_location_spec
,
242 create_breakpoints_sal
,
245 /* Implementation of abstract dtors. These must exist to satisfy the
248 breakpoint::~breakpoint ()
252 code_breakpoint::~code_breakpoint ()
256 catchpoint::~catchpoint ()
260 /* The structure to be used in regular breakpoints. */
261 struct ordinary_breakpoint
: public code_breakpoint
263 using code_breakpoint::code_breakpoint
;
265 int resources_needed (const struct bp_location
*) override
;
266 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
267 void print_mention () const override
;
268 void print_recreate (struct ui_file
*fp
) const override
;
271 /* Internal breakpoints. These typically have a lifetime the same as
272 the program, and they end up installed on the breakpoint chain with
273 a negative breakpoint number. They're visible in "maint info
274 breakpoints", but not "info breakpoints". */
275 struct internal_breakpoint
: public code_breakpoint
277 internal_breakpoint (struct gdbarch
*gdbarch
,
278 enum bptype type
, CORE_ADDR address
)
279 : code_breakpoint (gdbarch
, type
)
283 sal
.section
= find_pc_overlay (sal
.pc
);
284 sal
.pspace
= current_program_space
;
287 pspace
= current_program_space
;
288 disposition
= disp_donttouch
;
291 void re_set () override
;
292 void check_status (struct bpstat
*bs
) override
;
293 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
294 void print_mention () const override
;
297 /* Momentary breakpoints. These typically have a lifetime of some run
298 control command only, are always thread-specific, and have 0 for
299 breakpoint number. I.e., there can be many momentary breakpoints
300 on the breakpoint chain and they all same the same number (zero).
301 They're visible in "maint info breakpoints", but not "info
303 struct momentary_breakpoint
: public code_breakpoint
305 momentary_breakpoint (struct gdbarch
*gdbarch_
, enum bptype bptype
,
306 program_space
*pspace_
,
307 const struct frame_id
&frame_id_
,
309 : code_breakpoint (gdbarch_
, bptype
)
311 /* If FRAME_ID is valid, it should be a real frame, not an inlined
312 or tail-called one. */
313 gdb_assert (!frame_id_artificial_p (frame_id
));
315 /* Momentary breakpoints are always thread-specific. */
316 gdb_assert (thread_
> 0);
319 enable_state
= bp_enabled
;
320 disposition
= disp_donttouch
;
321 frame_id
= frame_id_
;
325 void re_set () override
;
326 void check_status (struct bpstat
*bs
) override
;
327 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
328 void print_mention () const override
;
331 /* DPrintf breakpoints. */
332 struct dprintf_breakpoint
: public ordinary_breakpoint
334 using ordinary_breakpoint::ordinary_breakpoint
;
336 void re_set () override
;
337 int breakpoint_hit (const struct bp_location
*bl
,
338 const address_space
*aspace
,
340 const target_waitstatus
&ws
) override
;
341 void print_recreate (struct ui_file
*fp
) const override
;
342 void after_condition_true (struct bpstat
*bs
) override
;
345 /* Ranged breakpoints. */
346 struct ranged_breakpoint
: public ordinary_breakpoint
348 explicit ranged_breakpoint (struct gdbarch
*gdbarch
,
349 const symtab_and_line
&sal_start
,
351 location_spec_up start_locspec
,
352 location_spec_up end_locspec
)
353 : ordinary_breakpoint (gdbarch
, bp_hardware_breakpoint
)
355 bp_location
*bl
= add_location (sal_start
);
358 disposition
= disp_donttouch
;
360 locspec
= std::move (start_locspec
);
361 locspec_range_end
= std::move (end_locspec
);
364 int breakpoint_hit (const struct bp_location
*bl
,
365 const address_space
*aspace
,
367 const target_waitstatus
&ws
) override
;
368 int resources_needed (const struct bp_location
*) override
;
369 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
370 bool print_one (bp_location
**) const override
;
371 void print_one_detail (struct ui_out
*) const override
;
372 void print_mention () const override
;
373 void print_recreate (struct ui_file
*fp
) const override
;
376 /* Static tracepoints with marker (`-m'). */
377 struct static_marker_tracepoint
: public tracepoint
379 using tracepoint::tracepoint
;
381 std::vector
<symtab_and_line
> decode_location_spec
382 (struct location_spec
*locspec
,
383 struct program_space
*search_pspace
) override
;
386 /* The style in which to perform a dynamic printf. This is a user
387 option because different output options have different tradeoffs;
388 if GDB does the printing, there is better error handling if there
389 is a problem with any of the arguments, but using an inferior
390 function lets you have special-purpose printers and sending of
391 output to the same place as compiled-in print functions. */
393 static const char dprintf_style_gdb
[] = "gdb";
394 static const char dprintf_style_call
[] = "call";
395 static const char dprintf_style_agent
[] = "agent";
396 static const char *const dprintf_style_enums
[] = {
402 static const char *dprintf_style
= dprintf_style_gdb
;
404 /* The function to use for dynamic printf if the preferred style is to
405 call into the inferior. The value is simply a string that is
406 copied into the command, so it can be anything that GDB can
407 evaluate to a callable address, not necessarily a function name. */
409 static std::string dprintf_function
= "printf";
411 /* The channel to use for dynamic printf if the preferred style is to
412 call into the inferior; if a nonempty string, it will be passed to
413 the call as the first argument, with the format string as the
414 second. As with the dprintf function, this can be anything that
415 GDB knows how to evaluate, so in addition to common choices like
416 "stderr", this could be an app-specific expression like
417 "mystreams[curlogger]". */
419 static std::string dprintf_channel
;
421 /* True if dprintf commands should continue to operate even if GDB
423 static bool disconnected_dprintf
= true;
425 struct command_line
*
426 breakpoint_commands (struct breakpoint
*b
)
428 return b
->commands
? b
->commands
.get () : NULL
;
431 /* Flag indicating that a command has proceeded the inferior past the
432 current breakpoint. */
434 static bool breakpoint_proceeded
;
437 bpdisp_text (enum bpdisp disp
)
439 /* NOTE: the following values are a part of MI protocol and
440 represent values of 'disp' field returned when inferior stops at
442 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
444 return bpdisps
[(int) disp
];
447 /* Prototypes for exported functions. */
448 /* If FALSE, gdb will not use hardware support for watchpoints, even
449 if such is available. */
450 static int can_use_hw_watchpoints
;
453 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
454 struct cmd_list_element
*c
,
458 _("Debugger's willingness to use "
459 "watchpoint hardware is %s.\n"),
463 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
464 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
465 for unrecognized breakpoint locations.
466 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
467 static enum auto_boolean pending_break_support
;
469 show_pending_break_support (struct ui_file
*file
, int from_tty
,
470 struct cmd_list_element
*c
,
474 _("Debugger's behavior regarding "
475 "pending breakpoints is %s.\n"),
479 /* If true, gdb will automatically use hardware breakpoints for breakpoints
480 set with "break" but falling in read-only memory.
481 If false, gdb will warn about such breakpoints, but won't automatically
482 use hardware breakpoints. */
483 static bool automatic_hardware_breakpoints
;
485 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
486 struct cmd_list_element
*c
,
490 _("Automatic usage of hardware breakpoints is %s.\n"),
494 /* If on, GDB keeps breakpoints inserted even if the inferior is
495 stopped, and immediately inserts any new breakpoints as soon as
496 they're created. If off (default), GDB keeps breakpoints off of
497 the target as long as possible. That is, it delays inserting
498 breakpoints until the next resume, and removes them again when the
499 target fully stops. This is a bit safer in case GDB crashes while
500 processing user input. */
501 static bool always_inserted_mode
= false;
504 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
505 struct cmd_list_element
*c
, const char *value
)
507 gdb_printf (file
, _("Always inserted breakpoint mode is %s.\n"),
511 /* See breakpoint.h. */
514 breakpoints_should_be_inserted_now (void)
516 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
518 /* If breakpoints are global, they should be inserted even if no
519 thread under gdb's control is running, or even if there are
520 no threads under GDB's control yet. */
525 if (always_inserted_mode
)
527 /* The user wants breakpoints inserted even if all threads
532 for (inferior
*inf
: all_inferiors ())
533 if (inf
->has_execution ()
534 && threads_are_executing (inf
->process_target ()))
537 /* Don't remove breakpoints yet if, even though all threads are
538 stopped, we still have events to process. */
539 for (thread_info
*tp
: all_non_exited_threads ())
540 if (tp
->resumed () && tp
->has_pending_waitstatus ())
546 static const char condition_evaluation_both
[] = "host or target";
548 /* Modes for breakpoint condition evaluation. */
549 static const char condition_evaluation_auto
[] = "auto";
550 static const char condition_evaluation_host
[] = "host";
551 static const char condition_evaluation_target
[] = "target";
552 static const char *const condition_evaluation_enums
[] = {
553 condition_evaluation_auto
,
554 condition_evaluation_host
,
555 condition_evaluation_target
,
559 /* Global that holds the current mode for breakpoint condition evaluation. */
560 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
562 /* Global that we use to display information to the user (gets its value from
563 condition_evaluation_mode_1. */
564 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
566 /* Translate a condition evaluation mode MODE into either "host"
567 or "target". This is used mostly to translate from "auto" to the
568 real setting that is being used. It returns the translated
572 translate_condition_evaluation_mode (const char *mode
)
574 if (mode
== condition_evaluation_auto
)
576 if (target_supports_evaluation_of_breakpoint_conditions ())
577 return condition_evaluation_target
;
579 return condition_evaluation_host
;
585 /* Discovers what condition_evaluation_auto translates to. */
588 breakpoint_condition_evaluation_mode (void)
590 return translate_condition_evaluation_mode (condition_evaluation_mode
);
593 /* Return true if GDB should evaluate breakpoint conditions or false
597 gdb_evaluates_breakpoint_condition_p (void)
599 const char *mode
= breakpoint_condition_evaluation_mode ();
601 return (mode
== condition_evaluation_host
);
604 /* Are we executing breakpoint commands? */
605 static int executing_breakpoint_commands
;
607 /* Are overlay event breakpoints enabled? */
608 static int overlay_events_enabled
;
610 /* See description in breakpoint.h. */
611 bool target_exact_watchpoints
= false;
613 /* Walk the following statement or block through all breakpoints.
614 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
615 current breakpoint. */
617 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
618 for (B = breakpoint_chain; \
619 B ? (TMP=B->next, 1): 0; \
622 /* Chains of all breakpoints defined. */
624 static struct breakpoint
*breakpoint_chain
;
626 /* See breakpoint.h. */
631 return breakpoint_range (breakpoint_chain
);
634 /* See breakpoint.h. */
636 breakpoint_safe_range
637 all_breakpoints_safe ()
639 return breakpoint_safe_range (all_breakpoints ());
642 /* See breakpoint.h. */
647 return tracepoint_range (breakpoint_chain
);
650 /* Array is sorted by bp_location_is_less_than - primarily by the ADDRESS. */
652 static std::vector
<bp_location
*> bp_locations
;
654 /* See breakpoint.h. */
656 const std::vector
<bp_location
*> &
662 /* Range to iterate over breakpoint locations at a given address. */
664 struct bp_locations_at_addr_range
666 using iterator
= std::vector
<bp_location
*>::iterator
;
668 bp_locations_at_addr_range (CORE_ADDR addr
)
672 bool operator() (const bp_location
*loc
, CORE_ADDR addr_
) const
673 { return loc
->address
< addr_
; }
675 bool operator() (CORE_ADDR addr_
, const bp_location
*loc
) const
676 { return addr_
< loc
->address
; }
679 auto it_pair
= std::equal_range (bp_locations
.begin (), bp_locations
.end (),
682 m_begin
= it_pair
.first
;
683 m_end
= it_pair
.second
;
686 iterator
begin () const
689 iterator
end () const
697 /* Return a range to iterate over all breakpoint locations exactly at address
700 If it's needed to iterate multiple times on the same range, it's possible
701 to save the range in a local variable and use it multiple times:
703 auto range = all_bp_locations_at_addr (addr);
705 for (bp_location *loc : range)
708 for (bp_location *loc : range)
711 This saves a bit of time, as it avoids re-doing the binary searches to find
712 the range's boundaries. Just remember not to change the bp_locations vector
713 in the mean time, as it could make the range's iterators stale. */
715 static bp_locations_at_addr_range
716 all_bp_locations_at_addr (CORE_ADDR addr
)
718 return bp_locations_at_addr_range (addr
);
721 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
722 ADDRESS for the current elements of BP_LOCATIONS which get a valid
723 result from bp_location_has_shadow. You can use it for roughly
724 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
725 an address you need to read. */
727 static CORE_ADDR bp_locations_placed_address_before_address_max
;
729 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
730 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
731 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
732 You can use it for roughly limiting the subrange of BP_LOCATIONS to
733 scan for shadow bytes for an address you need to read. */
735 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
737 /* The locations that no longer correspond to any breakpoint, unlinked
738 from the bp_locations array, but for which a hit may still be
739 reported by a target. */
740 static std::vector
<bp_location
*> moribund_locations
;
742 /* Number of last breakpoint made. */
744 static int breakpoint_count
;
746 /* The value of `breakpoint_count' before the last command that
747 created breakpoints. If the last (break-like) command created more
748 than one breakpoint, then the difference between BREAKPOINT_COUNT
749 and PREV_BREAKPOINT_COUNT is more than one. */
750 static int prev_breakpoint_count
;
752 /* Number of last tracepoint made. */
754 static int tracepoint_count
;
756 static struct cmd_list_element
*breakpoint_set_cmdlist
;
757 static struct cmd_list_element
*breakpoint_show_cmdlist
;
758 struct cmd_list_element
*save_cmdlist
;
760 /* Return whether a breakpoint is an active enabled breakpoint. */
762 breakpoint_enabled (struct breakpoint
*b
)
764 return (b
->enable_state
== bp_enabled
);
767 /* Set breakpoint count to NUM. */
770 set_breakpoint_count (int num
)
772 prev_breakpoint_count
= breakpoint_count
;
773 breakpoint_count
= num
;
774 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
777 /* Used by `start_rbreak_breakpoints' below, to record the current
778 breakpoint count before "rbreak" creates any breakpoint. */
779 static int rbreak_start_breakpoint_count
;
781 /* Called at the start an "rbreak" command to record the first
784 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
786 rbreak_start_breakpoint_count
= breakpoint_count
;
789 /* Called at the end of an "rbreak" command to record the last
792 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
794 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
797 /* Used in run_command to zero the hit count when a new run starts. */
800 clear_breakpoint_hit_counts (void)
802 for (breakpoint
*b
: all_breakpoints ())
807 /* Return the breakpoint with the specified number, or NULL
808 if the number does not refer to an existing breakpoint. */
811 get_breakpoint (int num
)
813 for (breakpoint
*b
: all_breakpoints ())
814 if (b
->number
== num
)
820 /* Return TRUE if NUM refer to an existing breakpoint that has
821 multiple code locations. */
824 has_multiple_locations (int num
)
826 for (breakpoint
*b
: all_breakpoints ())
827 if (b
->number
== num
)
828 return b
->loc
!= nullptr && b
->loc
->next
!= nullptr;
835 /* Mark locations as "conditions have changed" in case the target supports
836 evaluating conditions on its side. */
839 mark_breakpoint_modified (struct breakpoint
*b
)
841 /* This is only meaningful if the target is
842 evaluating conditions and if the user has
843 opted for condition evaluation on the target's
845 if (gdb_evaluates_breakpoint_condition_p ()
846 || !target_supports_evaluation_of_breakpoint_conditions ())
849 if (!is_breakpoint (b
))
852 for (bp_location
*loc
: b
->locations ())
853 loc
->condition_changed
= condition_modified
;
856 /* Mark location as "conditions have changed" in case the target supports
857 evaluating conditions on its side. */
860 mark_breakpoint_location_modified (struct bp_location
*loc
)
862 /* This is only meaningful if the target is
863 evaluating conditions and if the user has
864 opted for condition evaluation on the target's
866 if (gdb_evaluates_breakpoint_condition_p ()
867 || !target_supports_evaluation_of_breakpoint_conditions ())
871 if (!is_breakpoint (loc
->owner
))
874 loc
->condition_changed
= condition_modified
;
877 /* Sets the condition-evaluation mode using the static global
878 condition_evaluation_mode. */
881 set_condition_evaluation_mode (const char *args
, int from_tty
,
882 struct cmd_list_element
*c
)
884 const char *old_mode
, *new_mode
;
886 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
887 && !target_supports_evaluation_of_breakpoint_conditions ())
889 condition_evaluation_mode_1
= condition_evaluation_mode
;
890 warning (_("Target does not support breakpoint condition evaluation.\n"
891 "Using host evaluation mode instead."));
895 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
896 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
898 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
899 settings was "auto". */
900 condition_evaluation_mode
= condition_evaluation_mode_1
;
902 /* Only update the mode if the user picked a different one. */
903 if (new_mode
!= old_mode
)
905 /* If the user switched to a different evaluation mode, we
906 need to synch the changes with the target as follows:
908 "host" -> "target": Send all (valid) conditions to the target.
909 "target" -> "host": Remove all the conditions from the target.
912 if (new_mode
== condition_evaluation_target
)
914 /* Mark everything modified and synch conditions with the
916 for (bp_location
*loc
: all_bp_locations ())
917 mark_breakpoint_location_modified (loc
);
921 /* Manually mark non-duplicate locations to synch conditions
922 with the target. We do this to remove all the conditions the
923 target knows about. */
924 for (bp_location
*loc
: all_bp_locations ())
925 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
926 loc
->needs_update
= 1;
930 update_global_location_list (UGLL_MAY_INSERT
);
936 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
937 what "auto" is translating to. */
940 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
941 struct cmd_list_element
*c
, const char *value
)
943 if (condition_evaluation_mode
== condition_evaluation_auto
)
945 _("Breakpoint condition evaluation "
946 "mode is %s (currently %s).\n"),
948 breakpoint_condition_evaluation_mode ());
950 gdb_printf (file
, _("Breakpoint condition evaluation mode is %s.\n"),
954 /* Parse COND_STRING in the context of LOC and set as the condition
955 expression of LOC. BP_NUM is the number of LOC's owner, LOC_NUM is
956 the number of LOC within its owner. In case of parsing error, mark
957 LOC as DISABLED_BY_COND. In case of success, unset DISABLED_BY_COND. */
960 set_breakpoint_location_condition (const char *cond_string
, bp_location
*loc
,
961 int bp_num
, int loc_num
)
963 bool has_junk
= false;
966 expression_up new_exp
= parse_exp_1 (&cond_string
, loc
->address
,
967 block_for_pc (loc
->address
), 0);
968 if (*cond_string
!= 0)
972 loc
->cond
= std::move (new_exp
);
973 if (loc
->disabled_by_cond
&& loc
->enabled
)
974 gdb_printf (_("Breakpoint %d's condition is now valid at "
975 "location %d, enabling.\n"),
978 loc
->disabled_by_cond
= false;
981 catch (const gdb_exception_error
&e
)
985 /* Warn if a user-enabled location is now becoming disabled-by-cond.
986 BP_NUM is 0 if the breakpoint is being defined for the first
987 time using the "break ... if ..." command, and non-zero if
990 warning (_("failed to validate condition at location %d.%d, "
991 "disabling:\n %s"), bp_num
, loc_num
, e
.what ());
993 warning (_("failed to validate condition at location %d, "
994 "disabling:\n %s"), loc_num
, e
.what ());
997 loc
->disabled_by_cond
= true;
1001 error (_("Garbage '%s' follows condition"), cond_string
);
1005 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
1006 int from_tty
, bool force
)
1010 b
->cond_string
.reset ();
1012 if (is_watchpoint (b
))
1013 gdb::checked_static_cast
<watchpoint
*> (b
)->cond_exp
.reset ();
1017 for (bp_location
*loc
: b
->locations ())
1020 if (loc
->disabled_by_cond
&& loc
->enabled
)
1021 gdb_printf (_("Breakpoint %d's condition is now valid at "
1022 "location %d, enabling.\n"),
1023 b
->number
, loc_num
);
1024 loc
->disabled_by_cond
= false;
1027 /* No need to free the condition agent expression
1028 bytecode (if we have one). We will handle this
1029 when we go through update_global_location_list. */
1034 gdb_printf (_("Breakpoint %d now unconditional.\n"), b
->number
);
1038 if (is_watchpoint (b
))
1040 innermost_block_tracker tracker
;
1041 const char *arg
= exp
;
1042 expression_up new_exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
1044 error (_("Junk at end of expression"));
1045 watchpoint
*w
= gdb::checked_static_cast
<watchpoint
*> (b
);
1046 w
->cond_exp
= std::move (new_exp
);
1047 w
->cond_exp_valid_block
= tracker
.block ();
1051 /* Parse and set condition expressions. We make two passes.
1052 In the first, we parse the condition string to see if it
1053 is valid in at least one location. If so, the condition
1054 would be accepted. So we go ahead and set the locations'
1055 conditions. In case no valid case is found, we throw
1056 the error and the condition string will be rejected.
1057 This two-pass approach is taken to avoid setting the
1058 state of locations in case of a reject. */
1059 for (bp_location
*loc
: b
->locations ())
1063 const char *arg
= exp
;
1064 parse_exp_1 (&arg
, loc
->address
,
1065 block_for_pc (loc
->address
), 0);
1067 error (_("Junk at end of expression"));
1070 catch (const gdb_exception_error
&e
)
1072 /* Condition string is invalid. If this happens to
1073 be the last loc, abandon (if not forced) or continue
1075 if (loc
->next
== nullptr && !force
)
1080 /* If we reach here, the condition is valid at some locations. */
1082 for (bp_location
*loc
: b
->locations ())
1084 set_breakpoint_location_condition (exp
, loc
, b
->number
, loc_num
);
1089 /* We know that the new condition parsed successfully. The
1090 condition string of the breakpoint can be safely updated. */
1091 b
->cond_string
= make_unique_xstrdup (exp
);
1092 b
->condition_not_parsed
= 0;
1094 mark_breakpoint_modified (b
);
1096 gdb::observers::breakpoint_modified
.notify (b
);
1099 /* See breakpoint.h. */
1102 set_breakpoint_condition (int bpnum
, const char *exp
, int from_tty
,
1105 for (breakpoint
*b
: all_breakpoints ())
1106 if (b
->number
== bpnum
)
1108 /* Check if this breakpoint has a "stop" method implemented in an
1109 extension language. This method and conditions entered into GDB
1110 from the CLI are mutually exclusive. */
1111 const struct extension_language_defn
*extlang
1112 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
1114 if (extlang
!= NULL
)
1116 error (_("Only one stop condition allowed. There is currently"
1117 " a %s stop condition defined for this breakpoint."),
1118 ext_lang_capitalized_name (extlang
));
1120 set_breakpoint_condition (b
, exp
, from_tty
, force
);
1122 if (is_breakpoint (b
))
1123 update_global_location_list (UGLL_MAY_INSERT
);
1128 error (_("No breakpoint number %d."), bpnum
);
1131 /* The options for the "condition" command. */
1133 struct condition_command_opts
1136 bool force_condition
= false;
1139 static const gdb::option::option_def condition_command_option_defs
[] = {
1141 gdb::option::flag_option_def
<condition_command_opts
> {
1143 [] (condition_command_opts
*opts
) { return &opts
->force_condition
; },
1144 N_("Set the condition even if it is invalid for all current locations."),
1149 /* Create an option_def_group for the "condition" options, with
1150 CC_OPTS as context. */
1152 static inline gdb::option::option_def_group
1153 make_condition_command_options_def_group (condition_command_opts
*cc_opts
)
1155 return {{condition_command_option_defs
}, cc_opts
};
1158 /* Completion for the "condition" command. */
1161 condition_completer (struct cmd_list_element
*cmd
,
1162 completion_tracker
&tracker
,
1163 const char *text
, const char * /*word*/)
1165 bool has_no_arguments
= (*text
== '\0');
1166 condition_command_opts cc_opts
;
1167 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1168 if (gdb::option::complete_options
1169 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
1172 text
= skip_spaces (text
);
1173 const char *space
= skip_to_space (text
);
1180 tracker
.advance_custom_word_point_by (1);
1181 /* We don't support completion of history indices. */
1182 if (!isdigit (text
[1]))
1183 complete_internalvar (tracker
, &text
[1]);
1187 /* Suggest the "-force" flag if no arguments are given. If
1188 arguments were passed, they either already include the flag,
1189 or we are beyond the point of suggesting it because it's
1190 positionally the first argument. */
1191 if (has_no_arguments
)
1192 gdb::option::complete_on_all_options (tracker
, group
);
1194 /* We're completing the breakpoint number. */
1195 len
= strlen (text
);
1197 for (breakpoint
*b
: all_breakpoints ())
1201 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1203 if (strncmp (number
, text
, len
) == 0)
1204 tracker
.add_completion (make_unique_xstrdup (number
));
1210 /* We're completing the expression part. Skip the breakpoint num. */
1211 const char *exp_start
= skip_spaces (space
);
1212 tracker
.advance_custom_word_point_by (exp_start
- text
);
1214 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1215 expression_completer (cmd
, tracker
, text
, word
);
1218 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1221 condition_command (const char *arg
, int from_tty
)
1227 error_no_arg (_("breakpoint number"));
1231 /* Check if the "-force" flag was passed. */
1232 condition_command_opts cc_opts
;
1233 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1234 gdb::option::process_options
1235 (&p
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
1237 bnum
= get_number (&p
);
1239 error (_("Bad breakpoint argument: '%s'"), arg
);
1241 set_breakpoint_condition (bnum
, p
, from_tty
, cc_opts
.force_condition
);
1244 /* Check that COMMAND do not contain commands that are suitable
1245 only for tracepoints and not suitable for ordinary breakpoints.
1246 Throw if any such commands is found. */
1249 check_no_tracepoint_commands (struct command_line
*commands
)
1251 struct command_line
*c
;
1253 for (c
= commands
; c
; c
= c
->next
)
1255 if (c
->control_type
== while_stepping_control
)
1256 error (_("The 'while-stepping' command can "
1257 "only be used for tracepoints"));
1259 check_no_tracepoint_commands (c
->body_list_0
.get ());
1260 check_no_tracepoint_commands (c
->body_list_1
.get ());
1262 /* Not that command parsing removes leading whitespace and comment
1263 lines and also empty lines. So, we only need to check for
1264 command directly. */
1265 if (strstr (c
->line
, "collect ") == c
->line
)
1266 error (_("The 'collect' command can only be used for tracepoints"));
1268 if (strstr (c
->line
, "teval ") == c
->line
)
1269 error (_("The 'teval' command can only be used for tracepoints"));
1273 struct longjmp_breakpoint
: public momentary_breakpoint
1275 using momentary_breakpoint::momentary_breakpoint
;
1277 ~longjmp_breakpoint () override
;
1280 /* Encapsulate tests for different types of tracepoints. */
1283 is_tracepoint_type (bptype type
)
1285 return (type
== bp_tracepoint
1286 || type
== bp_fast_tracepoint
1287 || type
== bp_static_tracepoint
1288 || type
== bp_static_marker_tracepoint
);
1291 /* See breakpoint.h. */
1294 is_tracepoint (const struct breakpoint
*b
)
1296 return is_tracepoint_type (b
->type
);
1299 /* Factory function to create an appropriate instance of breakpoint given
1302 template<typename
... Arg
>
1303 static std::unique_ptr
<code_breakpoint
>
1304 new_breakpoint_from_type (struct gdbarch
*gdbarch
, bptype type
,
1312 case bp_hardware_breakpoint
:
1313 b
= new ordinary_breakpoint (gdbarch
, type
,
1314 std::forward
<Arg
> (args
)...);
1317 case bp_fast_tracepoint
:
1318 case bp_static_tracepoint
:
1320 b
= new tracepoint (gdbarch
, type
,
1321 std::forward
<Arg
> (args
)...);
1324 case bp_static_marker_tracepoint
:
1325 b
= new static_marker_tracepoint (gdbarch
, type
,
1326 std::forward
<Arg
> (args
)...);
1330 b
= new dprintf_breakpoint (gdbarch
, type
,
1331 std::forward
<Arg
> (args
)...);
1335 gdb_assert_not_reached ("invalid type");
1338 return std::unique_ptr
<code_breakpoint
> (b
);
1341 /* A helper function that validates that COMMANDS are valid for a
1342 breakpoint. This function will throw an exception if a problem is
1346 validate_commands_for_breakpoint (struct breakpoint
*b
,
1347 struct command_line
*commands
)
1349 if (is_tracepoint (b
))
1351 struct tracepoint
*t
= (struct tracepoint
*) b
;
1352 struct command_line
*c
;
1353 struct command_line
*while_stepping
= 0;
1355 /* Reset the while-stepping step count. The previous commands
1356 might have included a while-stepping action, while the new
1360 /* We need to verify that each top-level element of commands is
1361 valid for tracepoints, that there's at most one
1362 while-stepping element, and that the while-stepping's body
1363 has valid tracing commands excluding nested while-stepping.
1364 We also need to validate the tracepoint action line in the
1365 context of the tracepoint --- validate_actionline actually
1366 has side effects, like setting the tracepoint's
1367 while-stepping STEP_COUNT, in addition to checking if the
1368 collect/teval actions parse and make sense in the
1369 tracepoint's context. */
1370 for (c
= commands
; c
; c
= c
->next
)
1372 if (c
->control_type
== while_stepping_control
)
1374 if (b
->type
== bp_fast_tracepoint
)
1375 error (_("The 'while-stepping' command "
1376 "cannot be used for fast tracepoint"));
1377 else if (b
->type
== bp_static_tracepoint
1378 || b
->type
== bp_static_marker_tracepoint
)
1379 error (_("The 'while-stepping' command "
1380 "cannot be used for static tracepoint"));
1383 error (_("The 'while-stepping' command "
1384 "can be used only once"));
1389 validate_actionline (c
->line
, b
);
1393 struct command_line
*c2
;
1395 gdb_assert (while_stepping
->body_list_1
== nullptr);
1396 c2
= while_stepping
->body_list_0
.get ();
1397 for (; c2
; c2
= c2
->next
)
1399 if (c2
->control_type
== while_stepping_control
)
1400 error (_("The 'while-stepping' command cannot be nested"));
1406 check_no_tracepoint_commands (commands
);
1410 /* Return a vector of all the static tracepoints set at ADDR. The
1411 caller is responsible for releasing the vector. */
1413 std::vector
<breakpoint
*>
1414 static_tracepoints_here (CORE_ADDR addr
)
1416 std::vector
<breakpoint
*> found
;
1418 for (breakpoint
*b
: all_breakpoints ())
1419 if (b
->type
== bp_static_tracepoint
1420 || b
->type
== bp_static_marker_tracepoint
)
1422 for (bp_location
*loc
: b
->locations ())
1423 if (loc
->address
== addr
)
1424 found
.push_back (b
);
1430 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1431 validate that only allowed commands are included. */
1434 breakpoint_set_commands (struct breakpoint
*b
,
1435 counted_command_line
&&commands
)
1437 validate_commands_for_breakpoint (b
, commands
.get ());
1439 b
->commands
= std::move (commands
);
1440 gdb::observers::breakpoint_modified
.notify (b
);
1443 /* Set the internal `silent' flag on the breakpoint. Note that this
1444 is not the same as the "silent" that may appear in the breakpoint's
1448 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1450 int old_silent
= b
->silent
;
1453 if (old_silent
!= silent
)
1454 gdb::observers::breakpoint_modified
.notify (b
);
1457 /* See breakpoint.h. */
1460 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1462 /* It is invalid to set the thread field to anything other than -1 (which
1463 means no thread restriction) if a task restriction is already in
1465 gdb_assert (thread
== -1 || b
->task
== -1);
1467 int old_thread
= b
->thread
;
1470 if (old_thread
!= thread
)
1471 gdb::observers::breakpoint_modified
.notify (b
);
1474 /* See breakpoint.h. */
1477 breakpoint_set_task (struct breakpoint
*b
, int task
)
1479 /* It is invalid to set the task field to anything other than -1 (which
1480 means no task restriction) if a thread restriction is already in
1482 gdb_assert (task
== -1 || b
->thread
== -1);
1484 int old_task
= b
->task
;
1487 if (old_task
!= task
)
1488 gdb::observers::breakpoint_modified
.notify (b
);
1492 commands_command_1 (const char *arg
, int from_tty
,
1493 struct command_line
*control
)
1495 counted_command_line cmd
;
1496 /* cmd_read will be true once we have read cmd. Note that cmd might still be
1497 NULL after the call to read_command_lines if the user provides an empty
1498 list of command by just typing "end". */
1499 bool cmd_read
= false;
1501 std::string new_arg
;
1503 if (arg
== NULL
|| !*arg
)
1505 /* Argument not explicitly given. Synthesize it. */
1506 if (breakpoint_count
- prev_breakpoint_count
> 1)
1507 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1509 else if (breakpoint_count
> 0)
1510 new_arg
= string_printf ("%d", breakpoint_count
);
1514 /* Create a copy of ARG. This is needed because the "commands"
1515 command may be coming from a script. In that case, the read
1516 line buffer is going to be overwritten in the lambda of
1517 'map_breakpoint_numbers' below when reading the next line
1518 before we are are done parsing the breakpoint numbers. */
1521 arg
= new_arg
.c_str ();
1523 map_breakpoint_numbers
1524 (arg
, [&] (breakpoint
*b
)
1528 gdb_assert (cmd
== NULL
);
1529 if (control
!= NULL
)
1530 cmd
= control
->body_list_0
;
1534 = string_printf (_("Type commands for breakpoint(s) "
1535 "%s, one per line."),
1538 auto do_validate
= [=] (const char *line
)
1540 validate_actionline (line
, b
);
1542 gdb::function_view
<void (const char *)> validator
;
1543 if (is_tracepoint (b
))
1544 validator
= do_validate
;
1546 cmd
= read_command_lines (str
.c_str (), from_tty
, 1, validator
);
1551 /* If a breakpoint was on the list more than once, we don't need to
1553 if (b
->commands
!= cmd
)
1555 validate_commands_for_breakpoint (b
, cmd
.get ());
1557 gdb::observers::breakpoint_modified
.notify (b
);
1563 commands_command (const char *arg
, int from_tty
)
1565 commands_command_1 (arg
, from_tty
, NULL
);
1568 /* Like commands_command, but instead of reading the commands from
1569 input stream, takes them from an already parsed command structure.
1571 This is used by cli-script.c to DTRT with breakpoint commands
1572 that are part of if and while bodies. */
1573 enum command_control_type
1574 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1576 commands_command_1 (arg
, 0, cmd
);
1577 return simple_control
;
1580 /* Return true if BL->TARGET_INFO contains valid information. */
1583 bp_location_has_shadow (struct bp_location
*bl
)
1585 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1589 if (bl
->target_info
.shadow_len
== 0)
1590 /* BL isn't valid, or doesn't shadow memory. */
1595 /* Update BUF, which is LEN bytes read from the target address
1596 MEMADDR, by replacing a memory breakpoint with its shadowed
1599 If READBUF is not NULL, this buffer must not overlap with the of
1600 the breakpoint location's shadow_contents buffer. Otherwise, a
1601 failed assertion internal error will be raised. */
1604 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1605 const gdb_byte
*writebuf_org
,
1606 ULONGEST memaddr
, LONGEST len
,
1607 struct bp_target_info
*target_info
,
1608 struct gdbarch
*gdbarch
)
1610 /* Now do full processing of the found relevant range of elements. */
1611 CORE_ADDR bp_addr
= 0;
1615 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1616 current_program_space
->aspace
, 0))
1618 /* The breakpoint is inserted in a different address space. */
1622 /* Addresses and length of the part of the breakpoint that
1624 bp_addr
= target_info
->placed_address
;
1625 bp_size
= target_info
->shadow_len
;
1627 if (bp_addr
+ bp_size
<= memaddr
)
1629 /* The breakpoint is entirely before the chunk of memory we are
1634 if (bp_addr
>= memaddr
+ len
)
1636 /* The breakpoint is entirely after the chunk of memory we are
1641 /* Offset within shadow_contents. */
1642 if (bp_addr
< memaddr
)
1644 /* Only copy the second part of the breakpoint. */
1645 bp_size
-= memaddr
- bp_addr
;
1646 bptoffset
= memaddr
- bp_addr
;
1650 if (bp_addr
+ bp_size
> memaddr
+ len
)
1652 /* Only copy the first part of the breakpoint. */
1653 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1656 if (readbuf
!= NULL
)
1658 /* Verify that the readbuf buffer does not overlap with the
1659 shadow_contents buffer. */
1660 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1661 || readbuf
>= (target_info
->shadow_contents
1662 + target_info
->shadow_len
));
1664 /* Update the read buffer with this inserted breakpoint's
1666 memcpy (readbuf
+ bp_addr
- memaddr
,
1667 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1671 const unsigned char *bp
;
1672 CORE_ADDR addr
= target_info
->reqstd_address
;
1675 /* Update the shadow with what we want to write to memory. */
1676 memcpy (target_info
->shadow_contents
+ bptoffset
,
1677 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1679 /* Determine appropriate breakpoint contents and size for this
1681 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1683 /* Update the final write buffer with this inserted
1684 breakpoint's INSN. */
1685 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1689 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1690 by replacing any memory breakpoints with their shadowed contents.
1692 If READBUF is not NULL, this buffer must not overlap with any of
1693 the breakpoint location's shadow_contents buffers. Otherwise,
1694 a failed assertion internal error will be raised.
1696 The range of shadowed area by each bp_location is:
1697 bl->address - bp_locations_placed_address_before_address_max
1698 up to bl->address + bp_locations_shadow_len_after_address_max
1699 The range we were requested to resolve shadows for is:
1700 memaddr ... memaddr + len
1701 Thus the safe cutoff boundaries for performance optimization are
1702 memaddr + len <= (bl->address
1703 - bp_locations_placed_address_before_address_max)
1705 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1708 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1709 const gdb_byte
*writebuf_org
,
1710 ULONGEST memaddr
, LONGEST len
)
1712 /* Left boundary, right boundary and median element of our binary
1714 unsigned bc_l
, bc_r
, bc
;
1716 /* Find BC_L which is a leftmost element which may affect BUF
1717 content. It is safe to report lower value but a failure to
1718 report higher one. */
1721 bc_r
= bp_locations
.size ();
1722 while (bc_l
+ 1 < bc_r
)
1724 struct bp_location
*bl
;
1726 bc
= (bc_l
+ bc_r
) / 2;
1727 bl
= bp_locations
[bc
];
1729 /* Check first BL->ADDRESS will not overflow due to the added
1730 constant. Then advance the left boundary only if we are sure
1731 the BC element can in no way affect the BUF content (MEMADDR
1732 to MEMADDR + LEN range).
1734 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1735 offset so that we cannot miss a breakpoint with its shadow
1736 range tail still reaching MEMADDR. */
1738 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1740 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1747 /* Due to the binary search above, we need to make sure we pick the
1748 first location that's at BC_L's address. E.g., if there are
1749 multiple locations at the same address, BC_L may end up pointing
1750 at a duplicate location, and miss the "master"/"inserted"
1751 location. Say, given locations L1, L2 and L3 at addresses A and
1754 L1@A, L2@A, L3@B, ...
1756 BC_L could end up pointing at location L2, while the "master"
1757 location could be L1. Since the `loc->inserted' flag is only set
1758 on "master" locations, we'd forget to restore the shadow of L1
1761 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1764 /* Now do full processing of the found relevant range of elements. */
1766 for (bc
= bc_l
; bc
< bp_locations
.size (); bc
++)
1768 struct bp_location
*bl
= bp_locations
[bc
];
1770 /* bp_location array has BL->OWNER always non-NULL. */
1771 if (bl
->owner
->type
== bp_none
)
1772 warning (_("reading through apparently deleted breakpoint #%d?"),
1775 /* Performance optimization: any further element can no longer affect BUF
1778 if (bl
->address
>= bp_locations_placed_address_before_address_max
1781 - bp_locations_placed_address_before_address_max
)))
1784 if (!bp_location_has_shadow (bl
))
1787 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1788 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1792 /* See breakpoint.h. */
1795 is_breakpoint (const struct breakpoint
*bpt
)
1797 return (bpt
->type
== bp_breakpoint
1798 || bpt
->type
== bp_hardware_breakpoint
1799 || bpt
->type
== bp_dprintf
);
1802 /* Return true if BPT is of any hardware watchpoint kind. */
1805 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1807 return (bpt
->type
== bp_hardware_watchpoint
1808 || bpt
->type
== bp_read_watchpoint
1809 || bpt
->type
== bp_access_watchpoint
);
1812 /* See breakpoint.h. */
1815 is_watchpoint (const struct breakpoint
*bpt
)
1817 return (is_hardware_watchpoint (bpt
)
1818 || bpt
->type
== bp_watchpoint
);
1821 /* Returns true if the current thread and its running state are safe
1822 to evaluate or update watchpoint B. Watchpoints on local
1823 expressions need to be evaluated in the context of the thread that
1824 was current when the watchpoint was created, and, that thread needs
1825 to be stopped to be able to select the correct frame context.
1826 Watchpoints on global expressions can be evaluated on any thread,
1827 and in any state. It is presently left to the target allowing
1828 memory accesses when threads are running. */
1831 watchpoint_in_thread_scope (struct watchpoint
*b
)
1833 return (b
->pspace
== current_program_space
1834 && (b
->watchpoint_thread
== null_ptid
1835 || (inferior_ptid
== b
->watchpoint_thread
1836 && !inferior_thread ()->executing ())));
1839 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1840 associated bp_watchpoint_scope breakpoint. */
1843 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1845 if (w
->related_breakpoint
!= w
)
1847 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1848 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1849 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1850 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1851 w
->related_breakpoint
= w
;
1853 w
->disposition
= disp_del_at_next_stop
;
1856 /* Extract a bitfield value from value VAL using the bit parameters contained in
1859 static struct value
*
1860 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1862 struct value
*bit_val
;
1867 bit_val
= allocate_value (val
->type ());
1869 unpack_value_bitfield (bit_val
,
1872 value_contents_for_printing (val
).data (),
1879 /* Allocate a dummy location and add it to B. This is required
1880 because bpstat_stop_status requires a location to be able to report
1884 add_dummy_location (struct breakpoint
*b
,
1885 struct program_space
*pspace
)
1887 gdb_assert (b
->loc
== NULL
);
1889 b
->loc
= new bp_location (b
, bp_loc_other
);
1890 b
->loc
->pspace
= pspace
;
1893 /* Assuming that B is a watchpoint:
1894 - Reparse watchpoint expression, if REPARSE is true
1895 - Evaluate expression and store the result in B->val
1896 - Evaluate the condition if there is one, and store the result
1898 - Update the list of values that must be watched in B->loc.
1900 If the watchpoint disposition is disp_del_at_next_stop, then do
1901 nothing. If this is local watchpoint that is out of scope, delete
1904 Even with `set breakpoint always-inserted on' the watchpoints are
1905 removed + inserted on each stop here. Normal breakpoints must
1906 never be removed because they might be missed by a running thread
1907 when debugging in non-stop mode. On the other hand, hardware
1908 watchpoints (is_hardware_watchpoint; processed here) are specific
1909 to each LWP since they are stored in each LWP's hardware debug
1910 registers. Therefore, such LWP must be stopped first in order to
1911 be able to modify its hardware watchpoints.
1913 Hardware watchpoints must be reset exactly once after being
1914 presented to the user. It cannot be done sooner, because it would
1915 reset the data used to present the watchpoint hit to the user. And
1916 it must not be done later because it could display the same single
1917 watchpoint hit during multiple GDB stops. Note that the latter is
1918 relevant only to the hardware watchpoint types bp_read_watchpoint
1919 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1920 not user-visible - its hit is suppressed if the memory content has
1923 The following constraints influence the location where we can reset
1924 hardware watchpoints:
1926 * target_stopped_by_watchpoint and target_stopped_data_address are
1927 called several times when GDB stops.
1930 * Multiple hardware watchpoints can be hit at the same time,
1931 causing GDB to stop. GDB only presents one hardware watchpoint
1932 hit at a time as the reason for stopping, and all the other hits
1933 are presented later, one after the other, each time the user
1934 requests the execution to be resumed. Execution is not resumed
1935 for the threads still having pending hit event stored in
1936 LWP_INFO->STATUS. While the watchpoint is already removed from
1937 the inferior on the first stop the thread hit event is kept being
1938 reported from its cached value by linux_nat_stopped_data_address
1939 until the real thread resume happens after the watchpoint gets
1940 presented and thus its LWP_INFO->STATUS gets reset.
1942 Therefore the hardware watchpoint hit can get safely reset on the
1943 watchpoint removal from inferior. */
1946 update_watchpoint (struct watchpoint
*b
, bool reparse
)
1948 bool within_current_scope
;
1950 /* If this is a local watchpoint, we only want to check if the
1951 watchpoint frame is in scope if the current thread is the thread
1952 that was used to create the watchpoint. */
1953 if (!watchpoint_in_thread_scope (b
))
1956 if (b
->disposition
== disp_del_at_next_stop
)
1959 gdb::optional
<scoped_restore_selected_frame
> restore_frame
;
1961 /* Determine if the watchpoint is within scope. */
1962 if (b
->exp_valid_block
== NULL
)
1963 within_current_scope
= true;
1966 frame_info_ptr fi
= get_current_frame ();
1967 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1968 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1970 /* If we're at a point where the stack has been destroyed
1971 (e.g. in a function epilogue), unwinding may not work
1972 properly. Do not attempt to recreate locations at this
1973 point. See similar comments in watchpoint_check. */
1974 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1977 /* Save the current frame's ID so we can restore it after
1978 evaluating the watchpoint expression on its own frame. */
1979 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1980 took a frame parameter, so that we didn't have to change the
1982 restore_frame
.emplace ();
1984 fi
= frame_find_by_id (b
->watchpoint_frame
);
1985 within_current_scope
= (fi
!= NULL
);
1986 if (within_current_scope
)
1990 /* We don't free locations. They are stored in the bp_location array
1991 and update_global_location_list will eventually delete them and
1992 remove breakpoints if needed. */
1995 if (within_current_scope
&& reparse
)
2000 s
= (b
->exp_string_reparse
2001 ? b
->exp_string_reparse
.get ()
2002 : b
->exp_string
.get ());
2003 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
2004 /* If the meaning of expression itself changed, the old value is
2005 no longer relevant. We don't want to report a watchpoint hit
2006 to the user when the old value and the new value may actually
2007 be completely different objects. */
2009 b
->val_valid
= false;
2011 /* Note that unlike with breakpoints, the watchpoint's condition
2012 expression is stored in the breakpoint object, not in the
2013 locations (re)created below. */
2014 if (b
->cond_string
!= NULL
)
2016 b
->cond_exp
.reset ();
2018 s
= b
->cond_string
.get ();
2019 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
2023 /* If we failed to parse the expression, for example because
2024 it refers to a global variable in a not-yet-loaded shared library,
2025 don't try to insert watchpoint. We don't automatically delete
2026 such watchpoint, though, since failure to parse expression
2027 is different from out-of-scope watchpoint. */
2028 if (!target_has_execution ())
2030 /* Without execution, memory can't change. No use to try and
2031 set watchpoint locations. The watchpoint will be reset when
2032 the target gains execution, through breakpoint_re_set. */
2033 if (!can_use_hw_watchpoints
)
2035 if (b
->works_in_software_mode ())
2036 b
->type
= bp_watchpoint
;
2038 error (_("Can't set read/access watchpoint when "
2039 "hardware watchpoints are disabled."));
2042 else if (within_current_scope
&& b
->exp
)
2044 std::vector
<value_ref_ptr
> val_chain
;
2045 struct value
*v
, *result
;
2046 struct program_space
*frame_pspace
;
2048 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &v
, &result
,
2051 /* Avoid setting b->val if it's already set. The meaning of
2052 b->val is 'the last value' user saw, and we should update
2053 it only if we reported that last value to user. As it
2054 happens, the code that reports it updates b->val directly.
2055 We don't keep track of the memory value for masked
2057 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
2059 if (b
->val_bitsize
!= 0)
2060 v
= extract_bitfield_from_watchpoint_value (b
, v
);
2061 b
->val
= release_value (v
);
2062 b
->val_valid
= true;
2065 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
2067 /* Look at each value on the value chain. */
2068 gdb_assert (!val_chain
.empty ());
2069 for (const value_ref_ptr
&iter
: val_chain
)
2073 /* If it's a memory location, and GDB actually needed
2074 its contents to evaluate the expression, then we
2075 must watch it. If the first value returned is
2076 still lazy, that means an error occurred reading it;
2077 watch it anyway in case it becomes readable. */
2078 if (VALUE_LVAL (v
) == lval_memory
2079 && (v
== val_chain
[0] || ! value_lazy (v
)))
2081 struct type
*vtype
= check_typedef (v
->type ());
2083 /* We only watch structs and arrays if user asked
2084 for it explicitly, never if they just happen to
2085 appear in the middle of some value chain. */
2087 || (vtype
->code () != TYPE_CODE_STRUCT
2088 && vtype
->code () != TYPE_CODE_ARRAY
))
2091 enum target_hw_bp_type type
;
2092 struct bp_location
*loc
, **tmp
;
2093 int bitpos
= 0, bitsize
= 0;
2095 if (v
->bitsize () != 0)
2097 /* Extract the bit parameters out from the bitfield
2099 bitpos
= v
->bitpos ();
2100 bitsize
= v
->bitsize ();
2102 else if (v
== result
&& b
->val_bitsize
!= 0)
2104 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
2105 lvalue whose bit parameters are saved in the fields
2106 VAL_BITPOS and VAL_BITSIZE. */
2107 bitpos
= b
->val_bitpos
;
2108 bitsize
= b
->val_bitsize
;
2111 addr
= value_address (v
);
2114 /* Skip the bytes that don't contain the bitfield. */
2119 if (b
->type
== bp_read_watchpoint
)
2121 else if (b
->type
== bp_access_watchpoint
)
2124 loc
= b
->allocate_location ();
2125 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2128 loc
->gdbarch
= v
->type ()->arch ();
2130 loc
->pspace
= frame_pspace
;
2132 = gdbarch_remove_non_address_bits (loc
->gdbarch
, addr
);
2136 /* Just cover the bytes that make up the bitfield. */
2137 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2140 loc
->length
= v
->type ()->length ();
2142 loc
->watchpoint_type
= type
;
2147 /* Change the type of breakpoint between hardware assisted or
2148 an ordinary watchpoint depending on the hardware support and
2149 free hardware slots. Recheck the number of free hardware slots
2150 as the value chain may have changed. */
2153 enum bp_loc_type loc_type
;
2155 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2159 int i
, target_resources_ok
, other_type_used
;
2162 /* Use an exact watchpoint when there's only one memory region to be
2163 watched, and only one debug register is needed to watch it. */
2164 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2166 /* We need to determine how many resources are already
2167 used for all other hardware watchpoints plus this one
2168 to see if we still have enough resources to also fit
2169 this watchpoint in as well. */
2171 /* If this is a software watchpoint, we try to turn it
2172 to a hardware one -- count resources as if B was of
2173 hardware watchpoint type. */
2175 if (type
== bp_watchpoint
)
2176 type
= bp_hardware_watchpoint
;
2178 /* This watchpoint may or may not have been placed on
2179 the list yet at this point (it won't be in the list
2180 if we're trying to create it for the first time,
2181 through watch_command), so always account for it
2184 /* Count resources used by all watchpoints except B. */
2185 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
2187 /* Add in the resources needed for B. */
2188 i
+= hw_watchpoint_use_count (b
);
2191 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2192 if (target_resources_ok
<= 0)
2194 bool sw_mode
= b
->works_in_software_mode ();
2196 if (target_resources_ok
== 0 && !sw_mode
)
2197 error (_("Target does not support this type of "
2198 "hardware watchpoint."));
2199 else if (target_resources_ok
< 0 && !sw_mode
)
2200 error (_("There are not enough available hardware "
2201 "resources for this watchpoint."));
2203 /* Downgrade to software watchpoint. */
2204 b
->type
= bp_watchpoint
;
2208 /* If this was a software watchpoint, we've just
2209 found we have enough resources to turn it to a
2210 hardware watchpoint. Otherwise, this is a
2215 else if (!b
->works_in_software_mode ())
2217 if (!can_use_hw_watchpoints
)
2218 error (_("Can't set read/access watchpoint when "
2219 "hardware watchpoints are disabled."));
2221 error (_("Expression cannot be implemented with "
2222 "read/access watchpoint."));
2225 b
->type
= bp_watchpoint
;
2227 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_software_watchpoint
2228 : bp_loc_hardware_watchpoint
);
2229 for (bp_location
*bl
: b
->locations ())
2230 bl
->loc_type
= loc_type
;
2233 /* If a software watchpoint is not watching any memory, then the
2234 above left it without any location set up. But,
2235 bpstat_stop_status requires a location to be able to report
2236 stops, so make sure there's at least a dummy one. */
2237 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2238 add_dummy_location (b
, frame_pspace
);
2240 else if (!within_current_scope
)
2243 Watchpoint %d deleted because the program has left the block\n\
2244 in which its expression is valid.\n"),
2246 watchpoint_del_at_next_stop (b
);
2250 /* Returns true iff breakpoint location should be
2251 inserted in the inferior. We don't differentiate the type of BL's owner
2252 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2253 breakpoint_ops is not defined, because in insert_bp_location,
2254 tracepoint's insert_location will not be called. */
2257 should_be_inserted (struct bp_location
*bl
)
2259 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2262 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2265 if (!bl
->enabled
|| bl
->disabled_by_cond
2266 || bl
->shlib_disabled
|| bl
->duplicate
)
2269 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2272 /* This is set for example, when we're attached to the parent of a
2273 vfork, and have detached from the child. The child is running
2274 free, and we expect it to do an exec or exit, at which point the
2275 OS makes the parent schedulable again (and the target reports
2276 that the vfork is done). Until the child is done with the shared
2277 memory region, do not insert breakpoints in the parent, otherwise
2278 the child could still trip on the parent's breakpoints. Since
2279 the parent is blocked anyway, it won't miss any breakpoint. */
2280 if (bl
->pspace
->breakpoints_not_allowed
)
2283 /* Don't insert a breakpoint if we're trying to step past its
2284 location, except if the breakpoint is a single-step breakpoint,
2285 and the breakpoint's thread is the thread which is stepping past
2287 if ((bl
->loc_type
== bp_loc_software_breakpoint
2288 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2289 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2291 /* The single-step breakpoint may be inserted at the location
2292 we're trying to step if the instruction branches to itself.
2293 However, the instruction won't be executed at all and it may
2294 break the semantics of the instruction, for example, the
2295 instruction is a conditional branch or updates some flags.
2296 We can't fix it unless GDB is able to emulate the instruction
2297 or switch to displaced stepping. */
2298 && !(bl
->owner
->type
== bp_single_step
2299 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2301 infrun_debug_printf ("skipping breakpoint: stepping past insn at: %s",
2302 paddress (bl
->gdbarch
, bl
->address
));
2306 /* Don't insert watchpoints if we're trying to step past the
2307 instruction that triggered one. */
2308 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2309 && stepping_past_nonsteppable_watchpoint ())
2311 infrun_debug_printf ("stepping past non-steppable watchpoint. "
2312 "skipping watchpoint at %s:%d",
2313 paddress (bl
->gdbarch
, bl
->address
), bl
->length
);
2320 /* Same as should_be_inserted but does the check assuming
2321 that the location is not duplicated. */
2324 unduplicated_should_be_inserted (struct bp_location
*bl
)
2326 scoped_restore restore_bl_duplicate
2327 = make_scoped_restore (&bl
->duplicate
, 0);
2329 return should_be_inserted (bl
);
2332 /* Parses a conditional described by an expression COND into an
2333 agent expression bytecode suitable for evaluation
2334 by the bytecode interpreter. Return NULL if there was
2335 any error during parsing. */
2337 static agent_expr_up
2338 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2343 agent_expr_up aexpr
;
2345 /* We don't want to stop processing, so catch any errors
2346 that may show up. */
2349 aexpr
= gen_eval_for_expr (scope
, cond
);
2352 catch (const gdb_exception_error
&ex
)
2354 /* If we got here, it means the condition could not be parsed to a valid
2355 bytecode expression and thus can't be evaluated on the target's side.
2356 It's no use iterating through the conditions. */
2359 /* We have a valid agent expression. */
2363 /* Based on location BL, create a list of breakpoint conditions to be
2364 passed on to the target. If we have duplicated locations with different
2365 conditions, we will add such conditions to the list. The idea is that the
2366 target will evaluate the list of conditions and will only notify GDB when
2367 one of them is true. */
2370 build_target_condition_list (struct bp_location
*bl
)
2372 bool null_condition_or_parse_error
= false;
2373 int modified
= bl
->needs_update
;
2375 /* Release conditions left over from a previous insert. */
2376 bl
->target_info
.conditions
.clear ();
2378 /* This is only meaningful if the target is
2379 evaluating conditions and if the user has
2380 opted for condition evaluation on the target's
2382 if (gdb_evaluates_breakpoint_condition_p ()
2383 || !target_supports_evaluation_of_breakpoint_conditions ())
2386 auto loc_range
= all_bp_locations_at_addr (bl
->address
);
2388 /* Do a first pass to check for locations with no assigned
2389 conditions or conditions that fail to parse to a valid agent
2390 expression bytecode. If any of these happen, then it's no use to
2391 send conditions to the target since this location will always
2392 trigger and generate a response back to GDB. Note we consider
2393 all locations at the same address irrespective of type, i.e.,
2394 even if the locations aren't considered duplicates (e.g.,
2395 software breakpoint and hardware breakpoint at the same
2397 for (bp_location
*loc
: loc_range
)
2399 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2403 /* Re-parse the conditions since something changed. In that
2404 case we already freed the condition bytecodes (see
2405 force_breakpoint_reinsertion). We just
2406 need to parse the condition to bytecodes again. */
2407 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2411 /* If we have a NULL bytecode expression, it means something
2412 went wrong or we have a null condition expression. */
2413 if (!loc
->cond_bytecode
)
2415 null_condition_or_parse_error
= true;
2421 /* If any of these happened, it means we will have to evaluate the conditions
2422 for the location's address on gdb's side. It is no use keeping bytecodes
2423 for all the other duplicate locations, thus we free all of them here.
2425 This is so we have a finer control over which locations' conditions are
2426 being evaluated by GDB or the remote stub. */
2427 if (null_condition_or_parse_error
)
2429 for (bp_location
*loc
: loc_range
)
2431 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2433 /* Only go as far as the first NULL bytecode is
2435 if (!loc
->cond_bytecode
)
2438 loc
->cond_bytecode
.reset ();
2443 /* No NULL conditions or failed bytecode generation. Build a
2444 condition list for this location's address. If we have software
2445 and hardware locations at the same address, they aren't
2446 considered duplicates, but we still marge all the conditions
2447 anyway, as it's simpler, and doesn't really make a practical
2449 for (bp_location
*loc
: loc_range
)
2451 && is_breakpoint (loc
->owner
)
2452 && loc
->pspace
->num
== bl
->pspace
->num
2453 && loc
->owner
->enable_state
== bp_enabled
2455 && !loc
->disabled_by_cond
)
2457 /* Add the condition to the vector. This will be used later
2458 to send the conditions to the target. */
2459 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2465 /* Parses a command described by string CMD into an agent expression
2466 bytecode suitable for evaluation by the bytecode interpreter.
2467 Return NULL if there was any error during parsing. */
2469 static agent_expr_up
2470 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2472 const char *cmdrest
;
2473 const char *format_start
, *format_end
;
2474 struct gdbarch
*gdbarch
= get_current_arch ();
2481 if (*cmdrest
== ',')
2483 cmdrest
= skip_spaces (cmdrest
);
2485 if (*cmdrest
++ != '"')
2486 error (_("No format string following the location"));
2488 format_start
= cmdrest
;
2490 format_pieces
fpieces (&cmdrest
);
2492 format_end
= cmdrest
;
2494 if (*cmdrest
++ != '"')
2495 error (_("Bad format string, non-terminated '\"'."));
2497 cmdrest
= skip_spaces (cmdrest
);
2499 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2500 error (_("Invalid argument syntax"));
2502 if (*cmdrest
== ',')
2504 cmdrest
= skip_spaces (cmdrest
);
2506 /* For each argument, make an expression. */
2508 std::vector
<struct expression
*> argvec
;
2509 while (*cmdrest
!= '\0')
2514 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2515 argvec
.push_back (expr
.release ());
2517 if (*cmdrest
== ',')
2521 agent_expr_up aexpr
;
2523 /* We don't want to stop processing, so catch any errors
2524 that may show up. */
2527 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2528 format_start
, format_end
- format_start
,
2529 argvec
.size (), argvec
.data ());
2531 catch (const gdb_exception_error
&ex
)
2533 /* If we got here, it means the command could not be parsed to a valid
2534 bytecode expression and thus can't be evaluated on the target's side.
2535 It's no use iterating through the other commands. */
2538 /* We have a valid agent expression, return it. */
2542 /* Based on location BL, create a list of breakpoint commands to be
2543 passed on to the target. If we have duplicated locations with
2544 different commands, we will add any such to the list. */
2547 build_target_command_list (struct bp_location
*bl
)
2549 bool null_command_or_parse_error
= false;
2550 int modified
= bl
->needs_update
;
2552 /* Clear commands left over from a previous insert. */
2553 bl
->target_info
.tcommands
.clear ();
2555 if (!target_can_run_breakpoint_commands ())
2558 /* For now, limit to agent-style dprintf breakpoints. */
2559 if (dprintf_style
!= dprintf_style_agent
)
2562 auto loc_range
= all_bp_locations_at_addr (bl
->address
);
2564 /* For now, if we have any location at the same address that isn't a
2565 dprintf, don't install the target-side commands, as that would
2566 make the breakpoint not be reported to the core, and we'd lose
2568 for (bp_location
*loc
: loc_range
)
2569 if (is_breakpoint (loc
->owner
)
2570 && loc
->pspace
->num
== bl
->pspace
->num
2571 && loc
->owner
->type
!= bp_dprintf
)
2574 /* Do a first pass to check for locations with no assigned
2575 conditions or conditions that fail to parse to a valid agent expression
2576 bytecode. If any of these happen, then it's no use to send conditions
2577 to the target since this location will always trigger and generate a
2578 response back to GDB. */
2579 for (bp_location
*loc
: loc_range
)
2581 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2585 /* Re-parse the commands since something changed. In that
2586 case we already freed the command bytecodes (see
2587 force_breakpoint_reinsertion). We just
2588 need to parse the command to bytecodes again. */
2590 = parse_cmd_to_aexpr (bl
->address
,
2591 loc
->owner
->extra_string
.get ());
2594 /* If we have a NULL bytecode expression, it means something
2595 went wrong or we have a null command expression. */
2596 if (!loc
->cmd_bytecode
)
2598 null_command_or_parse_error
= true;
2604 /* If anything failed, then we're not doing target-side commands,
2606 if (null_command_or_parse_error
)
2608 for (bp_location
*loc
: loc_range
)
2609 if (is_breakpoint (loc
->owner
)
2610 && loc
->pspace
->num
== bl
->pspace
->num
)
2612 /* Only go as far as the first NULL bytecode is
2614 if (loc
->cmd_bytecode
== NULL
)
2617 loc
->cmd_bytecode
.reset ();
2621 /* No NULL commands or failed bytecode generation. Build a command
2622 list for all duplicate locations at this location's address.
2623 Note that here we must care for whether the breakpoint location
2624 types are considered duplicates, otherwise, say, if we have a
2625 software and hardware location at the same address, the target
2626 could end up running the commands twice. For the moment, we only
2627 support targets-side commands with dprintf, but it doesn't hurt
2628 to be pedantically correct in case that changes. */
2629 for (bp_location
*loc
: loc_range
)
2630 if (breakpoint_locations_match (bl
, loc
)
2631 && loc
->owner
->extra_string
2632 && is_breakpoint (loc
->owner
)
2633 && loc
->pspace
->num
== bl
->pspace
->num
2634 && loc
->owner
->enable_state
== bp_enabled
2636 && !loc
->disabled_by_cond
)
2638 /* Add the command to the vector. This will be used later
2639 to send the commands to the target. */
2640 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2643 bl
->target_info
.persist
= 0;
2644 /* Maybe flag this location as persistent. */
2645 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2646 bl
->target_info
.persist
= 1;
2649 /* Return the kind of breakpoint on address *ADDR. Get the kind
2650 of breakpoint according to ADDR except single-step breakpoint.
2651 Get the kind of single-step breakpoint according to the current
2655 breakpoint_kind (const struct bp_location
*bl
, CORE_ADDR
*addr
)
2657 if (bl
->owner
->type
== bp_single_step
)
2659 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2660 struct regcache
*regcache
;
2662 regcache
= get_thread_regcache (thr
);
2664 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2668 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2671 /* Rethrow the currently handled exception, if it's a TARGET_CLOSE_ERROR.
2672 E is either the currently handled exception, or a copy, or a sliced copy,
2673 so we can't rethrow that one, but we can use it to inspect the properties
2674 of the currently handled exception. */
2677 rethrow_on_target_close_error (const gdb_exception
&e
)
2681 /* Can't set the breakpoint. */
2683 if (e
.error
!= TARGET_CLOSE_ERROR
)
2686 /* If the target has closed then it will have deleted any breakpoints
2687 inserted within the target inferior, as a result any further attempts
2688 to interact with the breakpoint objects is not possible. Just rethrow
2689 the error. Don't use e to rethrow, to prevent object slicing of the
2694 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2695 location. Any error messages are printed to TMP_ERROR_STREAM; and
2696 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2697 Returns 0 for success, 1 if the bp_location type is not supported or
2700 NOTE drow/2003-09-09: This routine could be broken down to an
2701 object-style method for each breakpoint or catchpoint type. */
2703 insert_bp_location (struct bp_location
*bl
,
2704 struct ui_file
*tmp_error_stream
,
2705 int *disabled_breaks
,
2706 int *hw_breakpoint_error
,
2707 int *hw_bp_error_explained_already
)
2709 gdb_exception bp_excpt
;
2711 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2714 /* Note we don't initialize bl->target_info, as that wipes out
2715 the breakpoint location's shadow_contents if the breakpoint
2716 is still inserted at that location. This in turn breaks
2717 target_read_memory which depends on these buffers when
2718 a memory read is requested at the breakpoint location:
2719 Once the target_info has been wiped, we fail to see that
2720 we have a breakpoint inserted at that address and thus
2721 read the breakpoint instead of returning the data saved in
2722 the breakpoint location's shadow contents. */
2723 bl
->target_info
.reqstd_address
= bl
->address
;
2724 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2725 bl
->target_info
.length
= bl
->length
;
2727 /* When working with target-side conditions, we must pass all the conditions
2728 for the same breakpoint address down to the target since GDB will not
2729 insert those locations. With a list of breakpoint conditions, the target
2730 can decide when to stop and notify GDB. */
2732 if (is_breakpoint (bl
->owner
))
2734 build_target_condition_list (bl
);
2735 build_target_command_list (bl
);
2736 /* Reset the modification marker. */
2737 bl
->needs_update
= 0;
2740 /* If "set breakpoint auto-hw" is "on" and a software breakpoint was
2741 set at a read-only address, then a breakpoint location will have
2742 been changed to hardware breakpoint before we get here. If it is
2743 "off" however, error out before actually trying to insert the
2744 breakpoint, with a nicer error message. */
2745 if (bl
->loc_type
== bp_loc_software_breakpoint
2746 && !automatic_hardware_breakpoints
)
2748 mem_region
*mr
= lookup_mem_region (bl
->address
);
2750 if (mr
!= nullptr && mr
->attrib
.mode
!= MEM_RW
)
2752 gdb_printf (tmp_error_stream
,
2753 _("Cannot insert breakpoint %d.\n"
2754 "Cannot set software breakpoint "
2755 "at read-only address %s\n"),
2757 paddress (bl
->gdbarch
, bl
->address
));
2762 if (bl
->loc_type
== bp_loc_software_breakpoint
2763 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2765 /* First check to see if we have to handle an overlay. */
2766 if (overlay_debugging
== ovly_off
2767 || bl
->section
== NULL
2768 || !(section_is_overlay (bl
->section
)))
2770 /* No overlay handling: just set the breakpoint. */
2775 val
= bl
->owner
->insert_location (bl
);
2777 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2779 catch (gdb_exception
&e
)
2781 rethrow_on_target_close_error (e
);
2782 bp_excpt
= std::move (e
);
2787 /* This breakpoint is in an overlay section.
2788 Shall we set a breakpoint at the LMA? */
2789 if (!overlay_events_enabled
)
2791 /* Yes -- overlay event support is not active,
2792 so we must try to set a breakpoint at the LMA.
2793 This will not work for a hardware breakpoint. */
2794 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2795 warning (_("hardware breakpoint %d not supported in overlay!"),
2799 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2801 /* Set a software (trap) breakpoint at the LMA. */
2802 bl
->overlay_target_info
= bl
->target_info
;
2803 bl
->overlay_target_info
.reqstd_address
= addr
;
2805 /* No overlay handling: just set the breakpoint. */
2810 bl
->overlay_target_info
.kind
2811 = breakpoint_kind (bl
, &addr
);
2812 bl
->overlay_target_info
.placed_address
= addr
;
2813 val
= target_insert_breakpoint (bl
->gdbarch
,
2814 &bl
->overlay_target_info
);
2817 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2819 catch (gdb_exception
&e
)
2821 rethrow_on_target_close_error (e
);
2822 bp_excpt
= std::move (e
);
2825 if (bp_excpt
.reason
!= 0)
2826 gdb_printf (tmp_error_stream
,
2827 "Overlay breakpoint %d "
2828 "failed: in ROM?\n",
2832 /* Shall we set a breakpoint at the VMA? */
2833 if (section_is_mapped (bl
->section
))
2835 /* Yes. This overlay section is mapped into memory. */
2840 val
= bl
->owner
->insert_location (bl
);
2842 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2844 catch (gdb_exception
&e
)
2846 rethrow_on_target_close_error (e
);
2847 bp_excpt
= std::move (e
);
2852 /* No. This breakpoint will not be inserted.
2853 No error, but do not mark the bp as 'inserted'. */
2858 if (bp_excpt
.reason
!= 0)
2860 /* Can't set the breakpoint. */
2861 gdb_assert (bl
->owner
!= nullptr);
2863 /* In some cases, we might not be able to insert a
2864 breakpoint in a shared library that has already been
2865 removed, but we have not yet processed the shlib unload
2866 event. Unfortunately, some targets that implement
2867 breakpoint insertion themselves can't tell why the
2868 breakpoint insertion failed (e.g., the remote target
2869 doesn't define error codes), so we must treat generic
2870 errors as memory errors. */
2871 if (bp_excpt
.reason
== RETURN_ERROR
2872 && (bp_excpt
.error
== GENERIC_ERROR
2873 || bp_excpt
.error
== MEMORY_ERROR
)
2874 && bl
->loc_type
== bp_loc_software_breakpoint
2875 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2876 || shared_objfile_contains_address_p (bl
->pspace
,
2879 /* See also: disable_breakpoints_in_shlibs. */
2880 bl
->shlib_disabled
= 1;
2881 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2882 if (!*disabled_breaks
)
2884 gdb_printf (tmp_error_stream
,
2885 "Cannot insert breakpoint %d.\n",
2887 gdb_printf (tmp_error_stream
,
2888 "Temporarily disabling shared "
2889 "library breakpoints:\n");
2891 *disabled_breaks
= 1;
2892 gdb_printf (tmp_error_stream
,
2893 "breakpoint #%d\n", bl
->owner
->number
);
2898 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2900 *hw_breakpoint_error
= 1;
2901 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2902 gdb_printf (tmp_error_stream
,
2903 "Cannot insert hardware breakpoint %d%s",
2905 bp_excpt
.message
? ":" : ".\n");
2906 if (bp_excpt
.message
!= NULL
)
2907 gdb_printf (tmp_error_stream
, "%s.\n",
2912 if (bp_excpt
.message
== NULL
)
2915 = memory_error_message (TARGET_XFER_E_IO
,
2916 bl
->gdbarch
, bl
->address
);
2918 gdb_printf (tmp_error_stream
,
2919 "Cannot insert breakpoint %d.\n"
2921 bl
->owner
->number
, message
.c_str ());
2925 gdb_printf (tmp_error_stream
,
2926 "Cannot insert breakpoint %d: %s\n",
2941 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2942 /* NOTE drow/2003-09-08: This state only exists for removing
2943 watchpoints. It's not clear that it's necessary... */
2944 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2948 val
= bl
->owner
->insert_location (bl
);
2950 /* If trying to set a read-watchpoint, and it turns out it's not
2951 supported, try emulating one with an access watchpoint. */
2952 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2954 /* But don't try to insert it, if there's already another
2955 hw_access location that would be considered a duplicate
2957 for (bp_location
*loc
: all_bp_locations ())
2959 && loc
->watchpoint_type
== hw_access
2960 && watchpoint_locations_match (bl
, loc
))
2964 bl
->target_info
= loc
->target_info
;
2965 bl
->watchpoint_type
= hw_access
;
2972 bl
->watchpoint_type
= hw_access
;
2973 val
= bl
->owner
->insert_location (bl
);
2976 /* Back to the original value. */
2977 bl
->watchpoint_type
= hw_read
;
2981 bl
->inserted
= (val
== 0);
2984 else if (bl
->owner
->type
== bp_catchpoint
)
2988 val
= bl
->owner
->insert_location (bl
);
2991 bl
->owner
->enable_state
= bp_disabled
;
2995 Error inserting catchpoint %d: Your system does not support this type\n\
2996 of catchpoint."), bl
->owner
->number
);
2998 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
3001 bl
->inserted
= (val
== 0);
3003 /* We've already printed an error message if there was a problem
3004 inserting this catchpoint, and we've disabled the catchpoint,
3005 so just return success. */
3012 /* This function is called when program space PSPACE is about to be
3013 deleted. It takes care of updating breakpoints to not reference
3017 breakpoint_program_space_exit (struct program_space
*pspace
)
3019 /* Remove any breakpoint that was set through this program space. */
3020 for (breakpoint
*b
: all_breakpoints_safe ())
3021 if (b
->pspace
== pspace
)
3022 delete_breakpoint (b
);
3024 /* Breakpoints set through other program spaces could have locations
3025 bound to PSPACE as well. Remove those. */
3026 for (bp_location
*loc
: all_bp_locations ())
3028 struct bp_location
*tmp
;
3030 if (loc
->pspace
== pspace
)
3032 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
3033 if (loc
->owner
->loc
== loc
)
3034 loc
->owner
->loc
= loc
->next
;
3036 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
3037 if (tmp
->next
== loc
)
3039 tmp
->next
= loc
->next
;
3045 /* Now update the global location list to permanently delete the
3046 removed locations above. */
3047 update_global_location_list (UGLL_DONT_INSERT
);
3050 /* Make sure all breakpoints are inserted in inferior.
3051 Throws exception on any error.
3052 A breakpoint that is already inserted won't be inserted
3053 again, so calling this function twice is safe. */
3055 insert_breakpoints (void)
3057 for (breakpoint
*bpt
: all_breakpoints ())
3058 if (is_hardware_watchpoint (bpt
))
3060 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
3062 update_watchpoint (w
, false /* don't reparse. */);
3065 /* Updating watchpoints creates new locations, so update the global
3066 location list. Explicitly tell ugll to insert locations and
3067 ignore breakpoints_always_inserted_mode. Also,
3068 update_global_location_list tries to "upgrade" software
3069 breakpoints to hardware breakpoints to handle "set breakpoint
3070 auto-hw", so we need to call it even if we don't have new
3072 update_global_location_list (UGLL_INSERT
);
3075 /* This is used when we need to synch breakpoint conditions between GDB and the
3076 target. It is the case with deleting and disabling of breakpoints when using
3077 always-inserted mode. */
3080 update_inserted_breakpoint_locations (void)
3084 int disabled_breaks
= 0;
3085 int hw_breakpoint_error
= 0;
3086 int hw_bp_details_reported
= 0;
3088 string_file tmp_error_stream
;
3090 /* Explicitly mark the warning -- this will only be printed if
3091 there was an error. */
3092 tmp_error_stream
.puts ("Warning:\n");
3094 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3096 for (bp_location
*bl
: all_bp_locations ())
3098 /* We only want to update software breakpoints and hardware
3100 if (!is_breakpoint (bl
->owner
))
3103 /* We only want to update locations that are already inserted
3104 and need updating. This is to avoid unwanted insertion during
3105 deletion of breakpoints. */
3106 if (!bl
->inserted
|| !bl
->needs_update
)
3109 switch_to_program_space_and_thread (bl
->pspace
);
3111 /* For targets that support global breakpoints, there's no need
3112 to select an inferior to insert breakpoint to. In fact, even
3113 if we aren't attached to any process yet, we should still
3114 insert breakpoints. */
3115 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3116 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3119 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3120 &hw_breakpoint_error
, &hw_bp_details_reported
);
3127 target_terminal::ours_for_output ();
3128 error_stream (tmp_error_stream
);
3132 /* Used when starting or continuing the program. */
3135 insert_breakpoint_locations (void)
3139 int disabled_breaks
= 0;
3140 int hw_breakpoint_error
= 0;
3141 int hw_bp_error_explained_already
= 0;
3143 string_file tmp_error_stream
;
3145 /* Explicitly mark the warning -- this will only be printed if
3146 there was an error. */
3147 tmp_error_stream
.puts ("Warning:\n");
3149 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3151 for (bp_location
*bl
: all_bp_locations ())
3153 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3156 /* There is no point inserting thread-specific breakpoints if
3157 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3158 has BL->OWNER always non-NULL. */
3159 if (bl
->owner
->thread
!= -1
3160 && !valid_global_thread_id (bl
->owner
->thread
))
3163 switch_to_program_space_and_thread (bl
->pspace
);
3165 /* For targets that support global breakpoints, there's no need
3166 to select an inferior to insert breakpoint to. In fact, even
3167 if we aren't attached to any process yet, we should still
3168 insert breakpoints. */
3169 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3170 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3173 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3174 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3179 /* If we failed to insert all locations of a watchpoint, remove
3180 them, as half-inserted watchpoint is of limited use. */
3181 for (breakpoint
*bpt
: all_breakpoints ())
3183 bool some_failed
= false;
3185 if (!is_hardware_watchpoint (bpt
))
3188 if (!breakpoint_enabled (bpt
))
3191 if (bpt
->disposition
== disp_del_at_next_stop
)
3194 for (bp_location
*loc
: bpt
->locations ())
3195 if (!loc
->inserted
&& should_be_inserted (loc
))
3203 for (bp_location
*loc
: bpt
->locations ())
3205 remove_breakpoint (loc
);
3207 hw_breakpoint_error
= 1;
3208 tmp_error_stream
.printf ("Could not insert "
3209 "hardware watchpoint %d.\n",
3217 /* If a hardware breakpoint or watchpoint was inserted, add a
3218 message about possibly exhausted resources. */
3219 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3221 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3222 You may have requested too many hardware breakpoints/watchpoints.\n");
3224 target_terminal::ours_for_output ();
3225 error_stream (tmp_error_stream
);
3229 /* Used when the program stops.
3230 Returns zero if successful, or non-zero if there was a problem
3231 removing a breakpoint location. */
3234 remove_breakpoints (void)
3238 for (bp_location
*bl
: all_bp_locations ())
3239 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3240 val
|= remove_breakpoint (bl
);
3245 /* When a thread exits, remove breakpoints that are related to
3249 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3251 for (breakpoint
*b
: all_breakpoints_safe ())
3253 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3255 b
->disposition
= disp_del_at_next_stop
;
3258 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3259 b
->number
, print_thread_id (tp
));
3261 /* Hide it from the user. */
3267 /* See breakpoint.h. */
3270 remove_breakpoints_inf (inferior
*inf
)
3274 for (bp_location
*bl
: all_bp_locations ())
3276 if (bl
->pspace
!= inf
->pspace
)
3279 if (bl
->inserted
&& !bl
->target_info
.persist
)
3281 val
= remove_breakpoint (bl
);
3288 static int internal_breakpoint_number
= -1;
3290 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3291 If INTERNAL is non-zero, the breakpoint number will be populated
3292 from internal_breakpoint_number and that variable decremented.
3293 Otherwise the breakpoint number will be populated from
3294 breakpoint_count and that value incremented. Internal breakpoints
3295 do not set the internal var bpnum. */
3297 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3300 b
->number
= internal_breakpoint_number
--;
3303 set_breakpoint_count (breakpoint_count
+ 1);
3304 b
->number
= breakpoint_count
;
3308 /* Create a TYPE breakpoint on ADDRESS from an object file with GDBARCH. */
3310 static struct breakpoint
*
3311 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3312 CORE_ADDR address
, enum bptype type
)
3314 std::unique_ptr
<internal_breakpoint
> b
3315 (new internal_breakpoint (gdbarch
, type
, address
));
3317 b
->number
= internal_breakpoint_number
--;
3319 return add_to_breakpoint_chain (std::move (b
));
3322 /* Create a TYPE breakpoint on minimal symbol MSYM from an object file with
3325 static struct breakpoint
*
3326 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3327 struct bound_minimal_symbol
&msym
, enum bptype type
)
3331 address
= msym
.value_address ();
3333 address
= gdbarch_convert_from_func_ptr_addr
3334 (gdbarch
, address
, current_inferior ()->top_target ());
3336 /* Note that we're not using gdbarch_addr_bits_remove here, because that's
3337 related to addresses in $pc. We're getting the address from the
3338 minimal symbol table. */
3340 /* Is gdbarch_deprecated_function_start_offset needed here? Or is that dealt
3341 with elsewhere? Needs testing on vax. */
3343 if (gdbarch_skip_entrypoint_p (gdbarch
))
3344 address
= gdbarch_skip_entrypoint (gdbarch
, address
);
3346 return create_internal_breakpoint (gdbarch
, address
, type
);
3349 static const char *const longjmp_names
[] =
3351 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3353 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3355 /* Per-objfile data private to breakpoint.c. */
3356 struct breakpoint_objfile_data
3358 /* Minimal symbol for "_ovly_debug_event" (if any). */
3359 struct bound_minimal_symbol overlay_msym
;
3361 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3362 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3364 /* True if we have looked for longjmp probes. */
3365 int longjmp_searched
= 0;
3367 /* SystemTap probe points for longjmp (if any). These are non-owning
3369 std::vector
<probe
*> longjmp_probes
;
3371 /* Minimal symbol for "std::terminate()" (if any). */
3372 struct bound_minimal_symbol terminate_msym
;
3374 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3375 struct bound_minimal_symbol exception_msym
;
3377 /* True if we have looked for exception probes. */
3378 int exception_searched
= 0;
3380 /* SystemTap probe points for unwinding (if any). These are non-owning
3382 std::vector
<probe
*> exception_probes
;
3385 static const registry
<objfile
>::key
<breakpoint_objfile_data
>
3386 breakpoint_objfile_key
;
3388 /* Minimal symbol not found sentinel. */
3389 static struct minimal_symbol msym_not_found
;
3391 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3394 msym_not_found_p (const struct minimal_symbol
*msym
)
3396 return msym
== &msym_not_found
;
3399 /* Return per-objfile data needed by breakpoint.c.
3400 Allocate the data if necessary. */
3402 static struct breakpoint_objfile_data
*
3403 get_breakpoint_objfile_data (struct objfile
*objfile
)
3405 struct breakpoint_objfile_data
*bp_objfile_data
;
3407 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3408 if (bp_objfile_data
== NULL
)
3409 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3410 return bp_objfile_data
;
3414 create_overlay_event_breakpoint (void)
3416 const char *const func_name
= "_ovly_debug_event";
3418 for (objfile
*objfile
: current_program_space
->objfiles ())
3420 struct breakpoint
*b
;
3421 struct breakpoint_objfile_data
*bp_objfile_data
;
3424 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3426 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3429 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3431 struct bound_minimal_symbol m
;
3433 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3434 if (m
.minsym
== NULL
)
3436 /* Avoid future lookups in this objfile. */
3437 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3440 bp_objfile_data
->overlay_msym
= m
;
3443 addr
= bp_objfile_data
->overlay_msym
.value_address ();
3444 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3446 b
->locspec
= new_explicit_location_spec_function (func_name
);
3448 if (overlay_debugging
== ovly_auto
)
3450 b
->enable_state
= bp_enabled
;
3451 overlay_events_enabled
= 1;
3455 b
->enable_state
= bp_disabled
;
3456 overlay_events_enabled
= 0;
3461 /* Install a master longjmp breakpoint for OBJFILE using a probe. Return
3462 true if a breakpoint was installed. */
3465 create_longjmp_master_breakpoint_probe (objfile
*objfile
)
3467 struct gdbarch
*gdbarch
= objfile
->arch ();
3468 struct breakpoint_objfile_data
*bp_objfile_data
3469 = get_breakpoint_objfile_data (objfile
);
3471 if (!bp_objfile_data
->longjmp_searched
)
3473 std::vector
<probe
*> ret
3474 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3478 /* We are only interested in checking one element. */
3481 if (!p
->can_evaluate_arguments ())
3483 /* We cannot use the probe interface here,
3484 because it does not know how to evaluate
3489 bp_objfile_data
->longjmp_probes
= ret
;
3490 bp_objfile_data
->longjmp_searched
= 1;
3493 if (bp_objfile_data
->longjmp_probes
.empty ())
3496 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3498 struct breakpoint
*b
;
3500 b
= create_internal_breakpoint (gdbarch
,
3501 p
->get_relocated_address (objfile
),
3503 b
->locspec
= new_probe_location_spec ("-probe-stap libc:longjmp");
3504 b
->enable_state
= bp_disabled
;
3510 /* Install master longjmp breakpoints for OBJFILE using longjmp_names.
3511 Return true if at least one breakpoint was installed. */
3514 create_longjmp_master_breakpoint_names (objfile
*objfile
)
3516 struct gdbarch
*gdbarch
= objfile
->arch ();
3517 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3520 struct breakpoint_objfile_data
*bp_objfile_data
3521 = get_breakpoint_objfile_data (objfile
);
3522 unsigned int installed_bp
= 0;
3524 for (int i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3526 struct breakpoint
*b
;
3527 const char *func_name
;
3530 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3533 func_name
= longjmp_names
[i
];
3534 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3536 struct bound_minimal_symbol m
;
3538 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3539 if (m
.minsym
== NULL
)
3541 /* Prevent future lookups in this objfile. */
3542 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3545 bp_objfile_data
->longjmp_msym
[i
] = m
;
3548 addr
= bp_objfile_data
->longjmp_msym
[i
].value_address ();
3549 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
);
3550 b
->locspec
= new_explicit_location_spec_function (func_name
);
3551 b
->enable_state
= bp_disabled
;
3555 return installed_bp
> 0;
3558 /* Create a master longjmp breakpoint. */
3561 create_longjmp_master_breakpoint (void)
3563 scoped_restore_current_program_space restore_pspace
;
3565 for (struct program_space
*pspace
: program_spaces
)
3567 set_current_program_space (pspace
);
3569 for (objfile
*obj
: current_program_space
->objfiles ())
3571 /* Skip separate debug object, it's handled in the loop below. */
3572 if (obj
->separate_debug_objfile_backlink
!= nullptr)
3575 /* Try a probe kind breakpoint on main objfile. */
3576 if (create_longjmp_master_breakpoint_probe (obj
))
3579 /* Try longjmp_names kind breakpoints on main and separate_debug
3581 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3582 if (create_longjmp_master_breakpoint_names (debug_objfile
))
3588 /* Create a master std::terminate breakpoint. */
3590 create_std_terminate_master_breakpoint (void)
3592 const char *const func_name
= "std::terminate()";
3594 scoped_restore_current_program_space restore_pspace
;
3596 for (struct program_space
*pspace
: program_spaces
)
3598 set_current_program_space (pspace
);
3600 for (objfile
*objfile
: current_program_space
->objfiles ())
3602 struct breakpoint
*b
;
3603 struct breakpoint_objfile_data
*bp_objfile_data
;
3605 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3607 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3610 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3612 struct bound_minimal_symbol m
;
3614 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3615 if (m
.minsym
== NULL
|| (m
.minsym
->type () != mst_text
3616 && m
.minsym
->type () != mst_file_text
))
3618 /* Prevent future lookups in this objfile. */
3619 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3622 bp_objfile_data
->terminate_msym
= m
;
3625 b
= create_internal_breakpoint (objfile
->arch (),
3626 bp_objfile_data
->terminate_msym
,
3627 bp_std_terminate_master
);
3628 b
->locspec
= new_explicit_location_spec_function (func_name
);
3629 b
->enable_state
= bp_disabled
;
3634 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using a
3635 probe. Return true if a breakpoint was installed. */
3638 create_exception_master_breakpoint_probe (objfile
*objfile
)
3640 struct breakpoint
*b
;
3641 struct gdbarch
*gdbarch
;
3642 struct breakpoint_objfile_data
*bp_objfile_data
;
3644 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3646 /* We prefer the SystemTap probe point if it exists. */
3647 if (!bp_objfile_data
->exception_searched
)
3649 std::vector
<probe
*> ret
3650 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3654 /* We are only interested in checking one element. */
3657 if (!p
->can_evaluate_arguments ())
3659 /* We cannot use the probe interface here, because it does
3660 not know how to evaluate arguments. */
3664 bp_objfile_data
->exception_probes
= ret
;
3665 bp_objfile_data
->exception_searched
= 1;
3668 if (bp_objfile_data
->exception_probes
.empty ())
3671 gdbarch
= objfile
->arch ();
3673 for (probe
*p
: bp_objfile_data
->exception_probes
)
3675 b
= create_internal_breakpoint (gdbarch
,
3676 p
->get_relocated_address (objfile
),
3677 bp_exception_master
);
3678 b
->locspec
= new_probe_location_spec ("-probe-stap libgcc:unwind");
3679 b
->enable_state
= bp_disabled
;
3685 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using
3686 _Unwind_DebugHook. Return true if a breakpoint was installed. */
3689 create_exception_master_breakpoint_hook (objfile
*objfile
)
3691 const char *const func_name
= "_Unwind_DebugHook";
3692 struct breakpoint
*b
;
3693 struct gdbarch
*gdbarch
;
3694 struct breakpoint_objfile_data
*bp_objfile_data
;
3696 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3698 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3701 gdbarch
= objfile
->arch ();
3703 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3705 struct bound_minimal_symbol debug_hook
;
3707 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3708 if (debug_hook
.minsym
== NULL
)
3710 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3714 bp_objfile_data
->exception_msym
= debug_hook
;
3717 b
= create_internal_breakpoint (gdbarch
, bp_objfile_data
->exception_msym
,
3718 bp_exception_master
);
3719 b
->locspec
= new_explicit_location_spec_function (func_name
);
3720 b
->enable_state
= bp_disabled
;
3725 /* Install a master breakpoint on the unwinder's debug hook. */
3728 create_exception_master_breakpoint (void)
3730 for (objfile
*obj
: current_program_space
->objfiles ())
3732 /* Skip separate debug object. */
3733 if (obj
->separate_debug_objfile_backlink
)
3736 /* Try a probe kind breakpoint. */
3737 if (create_exception_master_breakpoint_probe (obj
))
3740 /* Iterate over main and separate debug objects and try an
3741 _Unwind_DebugHook kind breakpoint. */
3742 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3743 if (create_exception_master_breakpoint_hook (debug_objfile
))
3748 /* Does B have a location spec? */
3751 breakpoint_location_spec_empty_p (const struct breakpoint
*b
)
3753 return (b
->locspec
!= nullptr && b
->locspec
->empty_p ());
3757 update_breakpoints_after_exec (void)
3759 /* We're about to delete breakpoints from GDB's lists. If the
3760 INSERTED flag is true, GDB will try to lift the breakpoints by
3761 writing the breakpoints' "shadow contents" back into memory. The
3762 "shadow contents" are NOT valid after an exec, so GDB should not
3763 do that. Instead, the target is responsible from marking
3764 breakpoints out as soon as it detects an exec. We don't do that
3765 here instead, because there may be other attempts to delete
3766 breakpoints after detecting an exec and before reaching here. */
3767 for (bp_location
*bploc
: all_bp_locations ())
3768 if (bploc
->pspace
== current_program_space
)
3769 gdb_assert (!bploc
->inserted
);
3771 for (breakpoint
*b
: all_breakpoints_safe ())
3773 if (b
->pspace
!= current_program_space
)
3776 /* Solib breakpoints must be explicitly reset after an exec(). */
3777 if (b
->type
== bp_shlib_event
)
3779 delete_breakpoint (b
);
3783 /* JIT breakpoints must be explicitly reset after an exec(). */
3784 if (b
->type
== bp_jit_event
)
3786 delete_breakpoint (b
);
3790 /* Thread event breakpoints must be set anew after an exec(),
3791 as must overlay event and longjmp master breakpoints. */
3792 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3793 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3794 || b
->type
== bp_exception_master
)
3796 delete_breakpoint (b
);
3800 /* Step-resume breakpoints are meaningless after an exec(). */
3801 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3803 delete_breakpoint (b
);
3807 /* Just like single-step breakpoints. */
3808 if (b
->type
== bp_single_step
)
3810 delete_breakpoint (b
);
3814 /* Longjmp and longjmp-resume breakpoints are also meaningless
3816 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3817 || b
->type
== bp_longjmp_call_dummy
3818 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3820 delete_breakpoint (b
);
3824 if (b
->type
== bp_catchpoint
)
3826 /* For now, none of the bp_catchpoint breakpoints need to
3827 do anything at this point. In the future, if some of
3828 the catchpoints need to something, we will need to add
3829 a new method, and call this method from here. */
3833 /* bp_finish is a special case. The only way we ought to be able
3834 to see one of these when an exec() has happened, is if the user
3835 caught a vfork, and then said "finish". Ordinarily a finish just
3836 carries them to the call-site of the current callee, by setting
3837 a temporary bp there and resuming. But in this case, the finish
3838 will carry them entirely through the vfork & exec.
3840 We don't want to allow a bp_finish to remain inserted now. But
3841 we can't safely delete it, 'cause finish_command has a handle to
3842 the bp on a bpstat, and will later want to delete it. There's a
3843 chance (and I've seen it happen) that if we delete the bp_finish
3844 here, that its storage will get reused by the time finish_command
3845 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3846 We really must allow finish_command to delete a bp_finish.
3848 In the absence of a general solution for the "how do we know
3849 it's safe to delete something others may have handles to?"
3850 problem, what we'll do here is just uninsert the bp_finish, and
3851 let finish_command delete it.
3853 (We know the bp_finish is "doomed" in the sense that it's
3854 momentary, and will be deleted as soon as finish_command sees
3855 the inferior stopped. So it doesn't matter that the bp's
3856 address is probably bogus in the new a.out, unlike e.g., the
3857 solib breakpoints.) */
3859 if (b
->type
== bp_finish
)
3864 /* Without a symbolic address, we have little hope of the
3865 pre-exec() address meaning the same thing in the post-exec()
3867 if (breakpoint_location_spec_empty_p (b
))
3869 delete_breakpoint (b
);
3876 detach_breakpoints (ptid_t ptid
)
3879 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3880 struct inferior
*inf
= current_inferior ();
3882 if (ptid
.pid () == inferior_ptid
.pid ())
3883 error (_("Cannot detach breakpoints of inferior_ptid"));
3885 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3886 inferior_ptid
= ptid
;
3887 for (bp_location
*bl
: all_bp_locations ())
3889 if (bl
->pspace
!= inf
->pspace
)
3892 /* This function must physically remove breakpoints locations
3893 from the specified ptid, without modifying the breakpoint
3894 package's state. Locations of type bp_loc_other and
3895 bp_loc_software_watchpoint are only maintained at GDB side,
3896 so there is no need to remove them. Moreover, removing these
3897 would modify the breakpoint package's state. */
3898 if (bl
->loc_type
== bp_loc_other
3899 || bl
->loc_type
== bp_loc_software_watchpoint
)
3903 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3909 /* Remove the breakpoint location BL from the current address space.
3910 Note that this is used to detach breakpoints from a child fork.
3911 When we get here, the child isn't in the inferior list, and neither
3912 do we have objects to represent its address space --- we should
3913 *not* look at bl->pspace->aspace here. */
3916 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3920 /* BL is never in moribund_locations by our callers. */
3921 gdb_assert (bl
->owner
!= NULL
);
3923 /* The type of none suggests that owner is actually deleted.
3924 This should not ever happen. */
3925 gdb_assert (bl
->owner
->type
!= bp_none
);
3927 if (bl
->loc_type
== bp_loc_software_breakpoint
3928 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3930 /* "Normal" instruction breakpoint: either the standard
3931 trap-instruction bp (bp_breakpoint), or a
3932 bp_hardware_breakpoint. */
3934 /* First check to see if we have to handle an overlay. */
3935 if (overlay_debugging
== ovly_off
3936 || bl
->section
== NULL
3937 || !(section_is_overlay (bl
->section
)))
3939 /* No overlay handling: just remove the breakpoint. */
3941 /* If we're trying to uninsert a memory breakpoint that we
3942 know is set in a dynamic object that is marked
3943 shlib_disabled, then either the dynamic object was
3944 removed with "remove-symbol-file" or with
3945 "nosharedlibrary". In the former case, we don't know
3946 whether another dynamic object might have loaded over the
3947 breakpoint's address -- the user might well let us know
3948 about it next with add-symbol-file (the whole point of
3949 add-symbol-file is letting the user manually maintain a
3950 list of dynamically loaded objects). If we have the
3951 breakpoint's shadow memory, that is, this is a software
3952 breakpoint managed by GDB, check whether the breakpoint
3953 is still inserted in memory, to avoid overwriting wrong
3954 code with stale saved shadow contents. Note that HW
3955 breakpoints don't have shadow memory, as they're
3956 implemented using a mechanism that is not dependent on
3957 being able to modify the target's memory, and as such
3958 they should always be removed. */
3959 if (bl
->shlib_disabled
3960 && bl
->target_info
.shadow_len
!= 0
3961 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3964 val
= bl
->owner
->remove_location (bl
, reason
);
3968 /* This breakpoint is in an overlay section.
3969 Did we set a breakpoint at the LMA? */
3970 if (!overlay_events_enabled
)
3972 /* Yes -- overlay event support is not active, so we
3973 should have set a breakpoint at the LMA. Remove it.
3975 /* Ignore any failures: if the LMA is in ROM, we will
3976 have already warned when we failed to insert it. */
3977 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3978 target_remove_hw_breakpoint (bl
->gdbarch
,
3979 &bl
->overlay_target_info
);
3981 target_remove_breakpoint (bl
->gdbarch
,
3982 &bl
->overlay_target_info
,
3985 /* Did we set a breakpoint at the VMA?
3986 If so, we will have marked the breakpoint 'inserted'. */
3989 /* Yes -- remove it. Previously we did not bother to
3990 remove the breakpoint if the section had been
3991 unmapped, but let's not rely on that being safe. We
3992 don't know what the overlay manager might do. */
3994 /* However, we should remove *software* breakpoints only
3995 if the section is still mapped, or else we overwrite
3996 wrong code with the saved shadow contents. */
3997 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3998 || section_is_mapped (bl
->section
))
3999 val
= bl
->owner
->remove_location (bl
, reason
);
4005 /* No -- not inserted, so no need to remove. No error. */
4010 /* In some cases, we might not be able to remove a breakpoint in
4011 a shared library that has already been removed, but we have
4012 not yet processed the shlib unload event. Similarly for an
4013 unloaded add-symbol-file object - the user might not yet have
4014 had the chance to remove-symbol-file it. shlib_disabled will
4015 be set if the library/object has already been removed, but
4016 the breakpoint hasn't been uninserted yet, e.g., after
4017 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4018 always-inserted mode. */
4020 && (bl
->loc_type
== bp_loc_software_breakpoint
4021 && (bl
->shlib_disabled
4022 || solib_name_from_address (bl
->pspace
, bl
->address
)
4023 || shared_objfile_contains_address_p (bl
->pspace
,
4029 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4031 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
4033 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4034 bl
->owner
->remove_location (bl
, reason
);
4036 /* Failure to remove any of the hardware watchpoints comes here. */
4037 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
4038 warning (_("Could not remove hardware watchpoint %d."),
4041 else if (bl
->owner
->type
== bp_catchpoint
4042 && breakpoint_enabled (bl
->owner
)
4045 val
= bl
->owner
->remove_location (bl
, reason
);
4049 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4056 remove_breakpoint (struct bp_location
*bl
)
4058 /* BL is never in moribund_locations by our callers. */
4059 gdb_assert (bl
->owner
!= NULL
);
4061 /* The type of none suggests that owner is actually deleted.
4062 This should not ever happen. */
4063 gdb_assert (bl
->owner
->type
!= bp_none
);
4065 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
4067 switch_to_program_space_and_thread (bl
->pspace
);
4069 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
4072 /* Clear the "inserted" flag in all breakpoints. */
4075 mark_breakpoints_out (void)
4077 for (bp_location
*bl
: all_bp_locations ())
4078 if (bl
->pspace
== current_program_space
)
4082 /* Clear the "inserted" flag in all breakpoints and delete any
4083 breakpoints which should go away between runs of the program.
4085 Plus other such housekeeping that has to be done for breakpoints
4088 Note: this function gets called at the end of a run (by
4089 generic_mourn_inferior) and when a run begins (by
4090 init_wait_for_inferior). */
4095 breakpoint_init_inferior (enum inf_context context
)
4097 struct program_space
*pspace
= current_program_space
;
4099 /* If breakpoint locations are shared across processes, then there's
4101 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4104 mark_breakpoints_out ();
4106 for (breakpoint
*b
: all_breakpoints_safe ())
4108 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4114 case bp_longjmp_call_dummy
:
4116 /* If the call dummy breakpoint is at the entry point it will
4117 cause problems when the inferior is rerun, so we better get
4120 case bp_watchpoint_scope
:
4122 /* Also get rid of scope breakpoints. */
4124 case bp_shlib_event
:
4126 /* Also remove solib event breakpoints. Their addresses may
4127 have changed since the last time we ran the program.
4128 Actually we may now be debugging against different target;
4129 and so the solib backend that installed this breakpoint may
4130 not be used in by the target. E.g.,
4132 (gdb) file prog-linux
4133 (gdb) run # native linux target
4136 (gdb) file prog-win.exe
4137 (gdb) tar rem :9999 # remote Windows gdbserver.
4140 case bp_step_resume
:
4142 /* Also remove step-resume breakpoints. */
4144 case bp_single_step
:
4146 /* Also remove single-step breakpoints. */
4148 delete_breakpoint (b
);
4152 case bp_hardware_watchpoint
:
4153 case bp_read_watchpoint
:
4154 case bp_access_watchpoint
:
4156 struct watchpoint
*w
= (struct watchpoint
*) b
;
4158 /* Likewise for watchpoints on local expressions. */
4159 if (w
->exp_valid_block
!= NULL
)
4160 delete_breakpoint (b
);
4163 /* Get rid of existing locations, which are no longer
4164 valid. New ones will be created in
4165 update_watchpoint, when the inferior is restarted.
4166 The next update_global_location_list call will
4167 garbage collect them. */
4170 if (context
== inf_starting
)
4172 /* Reset val field to force reread of starting value in
4173 insert_breakpoints. */
4174 w
->val
.reset (nullptr);
4175 w
->val_valid
= false;
4185 /* Get rid of the moribund locations. */
4186 for (bp_location
*bl
: moribund_locations
)
4187 decref_bp_location (&bl
);
4188 moribund_locations
.clear ();
4191 /* These functions concern about actual breakpoints inserted in the
4192 target --- to e.g. check if we need to do decr_pc adjustment or if
4193 we need to hop over the bkpt --- so we check for address space
4194 match, not program space. */
4196 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4197 exists at PC. It returns ordinary_breakpoint_here if it's an
4198 ordinary breakpoint, or permanent_breakpoint_here if it's a
4199 permanent breakpoint.
4200 - When continuing from a location with an ordinary breakpoint, we
4201 actually single step once before calling insert_breakpoints.
4202 - When continuing from a location with a permanent breakpoint, we
4203 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4204 the target, to advance the PC past the breakpoint. */
4206 enum breakpoint_here
4207 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4209 bool any_breakpoint_here
= false;
4211 for (bp_location
*bl
: all_bp_locations ())
4213 if (bl
->loc_type
!= bp_loc_software_breakpoint
4214 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4217 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4218 if ((breakpoint_enabled (bl
->owner
)
4220 && breakpoint_location_address_match (bl
, aspace
, pc
))
4222 if (overlay_debugging
4223 && section_is_overlay (bl
->section
)
4224 && !section_is_mapped (bl
->section
))
4225 continue; /* unmapped overlay -- can't be a match */
4226 else if (bl
->permanent
)
4227 return permanent_breakpoint_here
;
4229 any_breakpoint_here
= true;
4233 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4236 /* See breakpoint.h. */
4239 breakpoint_in_range_p (const address_space
*aspace
,
4240 CORE_ADDR addr
, ULONGEST len
)
4242 for (bp_location
*bl
: all_bp_locations ())
4244 if (bl
->loc_type
!= bp_loc_software_breakpoint
4245 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4248 if ((breakpoint_enabled (bl
->owner
)
4250 && breakpoint_location_address_range_overlap (bl
, aspace
,
4253 if (overlay_debugging
4254 && section_is_overlay (bl
->section
)
4255 && !section_is_mapped (bl
->section
))
4257 /* Unmapped overlay -- can't be a match. */
4268 /* Return true if there's a moribund breakpoint at PC. */
4271 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4273 for (bp_location
*loc
: moribund_locations
)
4274 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4280 /* Returns true iff BL is inserted at PC, in address space ASPACE. */
4283 bp_location_inserted_here_p (const struct bp_location
*bl
,
4284 const address_space
*aspace
, CORE_ADDR pc
)
4287 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4290 /* An unmapped overlay can't be a match. */
4291 return !(overlay_debugging
4292 && section_is_overlay (bl
->section
)
4293 && !section_is_mapped (bl
->section
));
4298 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4301 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4303 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4305 if (bl
->loc_type
!= bp_loc_software_breakpoint
4306 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4309 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4315 /* This function returns non-zero iff there is a software breakpoint
4319 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4322 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4324 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4327 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4334 /* See breakpoint.h. */
4337 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4340 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4342 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4345 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4353 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4354 CORE_ADDR addr
, ULONGEST len
)
4356 for (breakpoint
*bpt
: all_breakpoints ())
4358 if (bpt
->type
!= bp_hardware_watchpoint
4359 && bpt
->type
!= bp_access_watchpoint
)
4362 if (!breakpoint_enabled (bpt
))
4365 for (bp_location
*loc
: bpt
->locations ())
4366 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4370 /* Check for intersection. */
4371 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4372 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4380 /* See breakpoint.h. */
4383 is_catchpoint (struct breakpoint
*b
)
4385 return (b
->type
== bp_catchpoint
);
4388 /* Clear a bpstat so that it says we are not at any breakpoint.
4389 Also free any storage that is part of a bpstat. */
4392 bpstat_clear (bpstat
**bsp
)
4409 bpstat::bpstat (const bpstat
&other
)
4411 bp_location_at (other
.bp_location_at
),
4412 breakpoint_at (other
.breakpoint_at
),
4413 commands (other
.commands
),
4414 print (other
.print
),
4416 print_it (other
.print_it
)
4418 if (other
.old_val
!= NULL
)
4419 old_val
= release_value (value_copy (other
.old_val
.get ()));
4422 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4423 is part of the bpstat is copied as well. */
4426 bpstat_copy (bpstat
*bs
)
4428 bpstat
*p
= nullptr;
4430 bpstat
*retval
= nullptr;
4435 for (; bs
!= NULL
; bs
= bs
->next
)
4437 tmp
= new bpstat (*bs
);
4440 /* This is the first thing in the chain. */
4450 /* Find the bpstat associated with this breakpoint. */
4453 bpstat_find_breakpoint (bpstat
*bsp
, struct breakpoint
*breakpoint
)
4458 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4460 if (bsp
->breakpoint_at
== breakpoint
)
4466 /* See breakpoint.h. */
4469 bpstat_explains_signal (bpstat
*bsp
, enum gdb_signal sig
)
4471 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4473 if (bsp
->breakpoint_at
== NULL
)
4475 /* A moribund location can never explain a signal other than
4477 if (sig
== GDB_SIGNAL_TRAP
)
4482 if (bsp
->breakpoint_at
->explains_signal (sig
))
4490 /* See breakpoint.h. */
4493 bpstat_num (bpstat
**bsp
, int *num
)
4495 struct breakpoint
*b
;
4498 return 0; /* No more breakpoint values */
4500 /* We assume we'll never have several bpstats that correspond to a
4501 single breakpoint -- otherwise, this function might return the
4502 same number more than once and this will look ugly. */
4503 b
= (*bsp
)->breakpoint_at
;
4504 *bsp
= (*bsp
)->next
;
4506 return -1; /* breakpoint that's been deleted since */
4508 *num
= b
->number
; /* We have its number */
4512 /* See breakpoint.h */
4515 bpstat_locno (const bpstat
*bs
)
4517 const struct breakpoint
*b
= bs
->breakpoint_at
;
4518 const struct bp_location
*bl
= bs
->bp_location_at
.get ();
4522 if (b
!= nullptr && b
->loc
!= nullptr && b
->loc
->next
!= nullptr)
4524 const bp_location
*bl_i
;
4527 bl_i
!= bl
&& bl_i
->next
!= nullptr;
4535 warning (_("location number not found for breakpoint %d address %s."),
4536 b
->number
, paddress (bl
->gdbarch
, bl
->address
));
4544 /* See breakpoint.h. */
4547 print_num_locno (const bpstat
*bs
, struct ui_out
*uiout
)
4549 struct breakpoint
*b
= bs
->breakpoint_at
;
4552 uiout
->text (_("deleted breakpoint"));
4555 uiout
->field_signed ("bkptno", b
->number
);
4557 int locno
= bpstat_locno (bs
);
4559 uiout
->message (".%pF", signed_field ("locno", locno
));
4563 /* See breakpoint.h. */
4566 bpstat_clear_actions (void)
4570 if (inferior_ptid
== null_ptid
)
4573 thread_info
*tp
= inferior_thread ();
4574 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4576 bs
->commands
= NULL
;
4577 bs
->old_val
.reset (nullptr);
4581 /* Called when a command is about to proceed the inferior. */
4584 breakpoint_about_to_proceed (void)
4586 if (inferior_ptid
!= null_ptid
)
4588 struct thread_info
*tp
= inferior_thread ();
4590 /* Allow inferior function calls in breakpoint commands to not
4591 interrupt the command list. When the call finishes
4592 successfully, the inferior will be standing at the same
4593 breakpoint as if nothing happened. */
4594 if (tp
->control
.in_infcall
)
4598 breakpoint_proceeded
= 1;
4601 /* Return true iff CMD as the first line of a command sequence is `silent'
4602 or its equivalent. */
4605 command_line_is_silent (struct command_line
*cmd
)
4607 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4610 /* Sets the $_hit_bpnum and $_hit_locno to bpnum and locno.
4611 A locno 0 is changed to 1 to e.g. let the user do
4612 (gdb) disable $_hit_bpnum.$_hit_locno
4613 for a single location breakpoint. */
4616 set_hit_convenience_vars (int bpnum
, int locno
)
4618 set_internalvar_integer (lookup_internalvar ("_hit_bpnum"), bpnum
);
4619 set_internalvar_integer (lookup_internalvar ("_hit_locno"),
4620 (locno
> 0 ? locno
: 1));
4623 /* Execute all the commands associated with all the breakpoints at
4624 this location. Any of these commands could cause the process to
4625 proceed beyond this point, etc. We look out for such changes by
4626 checking the global "breakpoint_proceeded" after each command.
4628 Returns true if a breakpoint command resumed the inferior. In that
4629 case, it is the caller's responsibility to recall it again with the
4630 bpstat of the current thread. */
4633 bpstat_do_actions_1 (bpstat
**bsp
)
4638 /* Avoid endless recursion if a `source' command is contained
4640 if (executing_breakpoint_commands
)
4643 scoped_restore save_executing
4644 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4646 scoped_restore preventer
= prevent_dont_repeat ();
4648 /* This pointer will iterate over the list of bpstat's. */
4651 /* The $_hit_* convenience variables are set before running the
4652 commands of BS. In case we have several bs, after the loop,
4653 we set again the variables to the first printed bpnum and locno.
4654 For multiple breakpoints, this ensures the variables are set to the
4655 breakpoint printed for the user. */
4656 int printed_hit_bpnum
= -1;
4657 int printed_hit_locno
= -1;
4659 breakpoint_proceeded
= 0;
4660 for (; bs
!= NULL
; bs
= bs
->next
)
4662 struct command_line
*cmd
= NULL
;
4664 /* Set the _hit_* convenience variables before running BS's commands. */
4666 const struct breakpoint
*b
= bs
->breakpoint_at
;
4669 int locno
= bpstat_locno (bs
);
4671 set_hit_convenience_vars (b
->number
, locno
);
4672 if (printed_hit_locno
== -1 && bs
->print
)
4674 printed_hit_bpnum
= b
->number
;
4675 printed_hit_locno
= locno
;
4680 /* Take ownership of the BSP's command tree, if it has one.
4682 The command tree could legitimately contain commands like
4683 'step' and 'next', which call clear_proceed_status, which
4684 frees the bpstat BS and its command tree. To make sure this doesn't
4685 free the tree we're executing out from under us, we need to
4686 take ownership of the tree ourselves. Since a given bpstat's
4687 commands are only executed once, we don't need to copy it; we
4688 can clear the pointer in the bpstat, and make sure we free
4689 the tree when we're done. */
4690 counted_command_line ccmd
= bs
->commands
;
4691 bs
->commands
= NULL
;
4694 if (command_line_is_silent (cmd
))
4696 /* The action has been already done by bpstat_stop_status. */
4702 execute_control_command (cmd
);
4703 /* After execute_control_command, if breakpoint_proceeded is true,
4704 BS has been freed and cannot be accessed anymore. */
4706 if (breakpoint_proceeded
)
4712 if (breakpoint_proceeded
)
4714 if (current_ui
->async
)
4715 /* If we are in async mode, then the target might be still
4716 running, not stopped at any breakpoint, so nothing for
4717 us to do here -- just return to the event loop. */
4720 /* In sync mode, when execute_control_command returns
4721 we're already standing on the next breakpoint.
4722 Breakpoint commands for that stop were not run, since
4723 execute_command does not run breakpoint commands --
4724 only command_line_handler does, but that one is not
4725 involved in execution of breakpoint commands. So, we
4726 can now execute breakpoint commands. It should be
4727 noted that making execute_command do bpstat actions is
4728 not an option -- in this case we'll have recursive
4729 invocation of bpstat for each breakpoint with a
4730 command, and can easily blow up GDB stack. Instead, we
4731 return true, which will trigger the caller to recall us
4732 with the new stop_bpstat. */
4738 /* Now that we have executed the commands of all bs, set the _hit_*
4739 convenience variables to the printed values. */
4740 if (printed_hit_locno
!= -1)
4741 set_hit_convenience_vars (printed_hit_bpnum
, printed_hit_locno
);
4746 /* Helper for bpstat_do_actions. Get the current thread, if there's
4747 one, is alive and has execution. Return NULL otherwise. */
4749 static thread_info
*
4750 get_bpstat_thread ()
4752 if (inferior_ptid
== null_ptid
|| !target_has_execution ())
4755 thread_info
*tp
= inferior_thread ();
4756 if (tp
->state
== THREAD_EXITED
|| tp
->executing ())
4762 bpstat_do_actions (void)
4764 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4767 /* Do any commands attached to breakpoint we are stopped at. */
4768 while ((tp
= get_bpstat_thread ()) != NULL
)
4770 /* Since in sync mode, bpstat_do_actions may resume the
4771 inferior, and only return when it is stopped at the next
4772 breakpoint, we keep doing breakpoint actions until it returns
4773 false to indicate the inferior was not resumed. */
4774 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4778 cleanup_if_error
.release ();
4781 /* Print out the (old or new) value associated with a watchpoint. */
4784 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4787 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4790 struct value_print_options opts
;
4791 get_user_print_options (&opts
);
4792 value_print (val
, stream
, &opts
);
4796 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4797 debugging multiple threads. */
4800 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4802 if (uiout
->is_mi_like_p ())
4807 if (show_thread_that_caused_stop ())
4809 struct thread_info
*thr
= inferior_thread ();
4811 uiout
->text ("Thread ");
4812 uiout
->field_string ("thread-id", print_thread_id (thr
));
4814 const char *name
= thread_name (thr
);
4817 uiout
->text (" \"");
4818 uiout
->field_string ("name", name
);
4822 uiout
->text (" hit ");
4826 /* Generic routine for printing messages indicating why we
4827 stopped. The behavior of this function depends on the value
4828 'print_it' in the bpstat structure. Under some circumstances we
4829 may decide not to print anything here and delegate the task to
4832 static enum print_stop_action
4833 print_bp_stop_message (bpstat
*bs
)
4835 switch (bs
->print_it
)
4838 /* Nothing should be printed for this bpstat entry. */
4839 return PRINT_UNKNOWN
;
4843 /* We still want to print the frame, but we already printed the
4844 relevant messages. */
4845 return PRINT_SRC_AND_LOC
;
4848 case print_it_normal
:
4850 struct breakpoint
*b
= bs
->breakpoint_at
;
4852 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4853 which has since been deleted. */
4855 return PRINT_UNKNOWN
;
4857 /* Normal case. Call the breakpoint's print_it method. */
4858 return b
->print_it (bs
);
4863 internal_error (_("print_bp_stop_message: unrecognized enum value"));
4868 /* See breakpoint.h. */
4871 print_solib_event (bool is_catchpoint
)
4873 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4874 bool any_added
= !current_program_space
->added_solibs
.empty ();
4878 if (any_added
|| any_deleted
)
4879 current_uiout
->text (_("Stopped due to shared library event:\n"));
4881 current_uiout
->text (_("Stopped due to shared library event (no "
4882 "libraries added or removed)\n"));
4885 if (current_uiout
->is_mi_like_p ())
4886 current_uiout
->field_string ("reason",
4887 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4891 current_uiout
->text (_(" Inferior unloaded "));
4892 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4893 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4895 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4898 current_uiout
->text (" ");
4899 current_uiout
->field_string ("library", name
);
4900 current_uiout
->text ("\n");
4906 current_uiout
->text (_(" Inferior loaded "));
4907 ui_out_emit_list
list_emitter (current_uiout
, "added");
4909 for (so_list
*iter
: current_program_space
->added_solibs
)
4912 current_uiout
->text (" ");
4914 current_uiout
->field_string ("library", iter
->so_name
);
4915 current_uiout
->text ("\n");
4920 /* Print a message indicating what happened. This is called from
4921 normal_stop(). The input to this routine is the head of the bpstat
4922 list - a list of the eventpoints that caused this stop. KIND is
4923 the target_waitkind for the stopping event. This
4924 routine calls the generic print routine for printing a message
4925 about reasons for stopping. This will print (for example) the
4926 "Breakpoint n," part of the output. The return value of this
4929 PRINT_UNKNOWN: Means we printed nothing.
4930 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4931 code to print the location. An example is
4932 "Breakpoint 1, " which should be followed by
4934 PRINT_SRC_ONLY: Means we printed something, but there is no need
4935 to also print the location part of the message.
4936 An example is the catch/throw messages, which
4937 don't require a location appended to the end.
4938 PRINT_NOTHING: We have done some printing and we don't need any
4939 further info to be printed. */
4941 enum print_stop_action
4942 bpstat_print (bpstat
*bs
, target_waitkind kind
)
4944 enum print_stop_action val
;
4946 /* Maybe another breakpoint in the chain caused us to stop.
4947 (Currently all watchpoints go on the bpstat whether hit or not.
4948 That probably could (should) be changed, provided care is taken
4949 with respect to bpstat_explains_signal). */
4950 for (; bs
; bs
= bs
->next
)
4952 val
= print_bp_stop_message (bs
);
4953 if (val
== PRINT_SRC_ONLY
4954 || val
== PRINT_SRC_AND_LOC
4955 || val
== PRINT_NOTHING
)
4959 /* If we had hit a shared library event breakpoint,
4960 print_bp_stop_message would print out this message. If we hit an
4961 OS-level shared library event, do the same thing. */
4962 if (kind
== TARGET_WAITKIND_LOADED
)
4964 print_solib_event (false);
4965 return PRINT_NOTHING
;
4968 /* We reached the end of the chain, or we got a null BS to start
4969 with and nothing was printed. */
4970 return PRINT_UNKNOWN
;
4973 /* Evaluate the boolean expression EXP and return the result. */
4976 breakpoint_cond_eval (expression
*exp
)
4978 scoped_value_mark mark
;
4979 return value_true (evaluate_expression (exp
));
4982 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4984 bpstat::bpstat (struct bp_location
*bl
, bpstat
***bs_link_pointer
)
4986 bp_location_at (bp_location_ref_ptr::new_reference (bl
)),
4987 breakpoint_at (bl
->owner
),
4991 print_it (print_it_normal
)
4993 **bs_link_pointer
= this;
4994 *bs_link_pointer
= &next
;
4999 breakpoint_at (NULL
),
5003 print_it (print_it_normal
)
5007 /* The target has stopped with waitstatus WS. Check if any hardware
5008 watchpoints have triggered, according to the target. */
5011 watchpoints_triggered (const target_waitstatus
&ws
)
5013 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
5016 if (!stopped_by_watchpoint
)
5018 /* We were not stopped by a watchpoint. Mark all watchpoints
5019 as not triggered. */
5020 for (breakpoint
*b
: all_breakpoints ())
5021 if (is_hardware_watchpoint (b
))
5023 struct watchpoint
*w
= (struct watchpoint
*) b
;
5025 w
->watchpoint_triggered
= watch_triggered_no
;
5031 if (!target_stopped_data_address (current_inferior ()->top_target (), &addr
))
5033 /* We were stopped by a watchpoint, but we don't know where.
5034 Mark all watchpoints as unknown. */
5035 for (breakpoint
*b
: all_breakpoints ())
5036 if (is_hardware_watchpoint (b
))
5038 struct watchpoint
*w
= (struct watchpoint
*) b
;
5040 w
->watchpoint_triggered
= watch_triggered_unknown
;
5046 /* The target could report the data address. Mark watchpoints
5047 affected by this data address as triggered, and all others as not
5050 for (breakpoint
*b
: all_breakpoints ())
5051 if (is_hardware_watchpoint (b
))
5053 struct watchpoint
*w
= (struct watchpoint
*) b
;
5055 w
->watchpoint_triggered
= watch_triggered_no
;
5056 for (bp_location
*loc
: b
->locations ())
5058 if (is_masked_watchpoint (b
))
5060 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
5061 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
5063 if (newaddr
== start
)
5065 w
->watchpoint_triggered
= watch_triggered_yes
;
5069 /* Exact match not required. Within range is sufficient. */
5070 else if (target_watchpoint_addr_within_range
5071 (current_inferior ()->top_target (), addr
, loc
->address
,
5074 w
->watchpoint_triggered
= watch_triggered_yes
;
5083 /* Possible return values for watchpoint_check. */
5084 enum wp_check_result
5086 /* The watchpoint has been deleted. */
5089 /* The value has changed. */
5090 WP_VALUE_CHANGED
= 2,
5092 /* The value has not changed. */
5093 WP_VALUE_NOT_CHANGED
= 3,
5095 /* Ignore this watchpoint, no matter if the value changed or not. */
5099 #define BP_TEMPFLAG 1
5100 #define BP_HARDWAREFLAG 2
5102 /* Evaluate watchpoint condition expression and check if its value
5105 static wp_check_result
5106 watchpoint_check (bpstat
*bs
)
5108 struct watchpoint
*b
;
5110 bool within_current_scope
;
5112 /* BS is built from an existing struct breakpoint. */
5113 gdb_assert (bs
->breakpoint_at
!= NULL
);
5114 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5116 /* If this is a local watchpoint, we only want to check if the
5117 watchpoint frame is in scope if the current thread is the thread
5118 that was used to create the watchpoint. */
5119 if (!watchpoint_in_thread_scope (b
))
5122 if (b
->exp_valid_block
== NULL
)
5123 within_current_scope
= true;
5126 frame_info_ptr frame
= get_current_frame ();
5127 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5128 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5130 /* stack_frame_destroyed_p() returns a non-zero value if we're
5131 still in the function but the stack frame has already been
5132 invalidated. Since we can't rely on the values of local
5133 variables after the stack has been destroyed, we are treating
5134 the watchpoint in that state as `not changed' without further
5135 checking. Don't mark watchpoints as changed if the current
5136 frame is in an epilogue - even if they are in some other
5137 frame, our view of the stack is likely to be wrong and
5138 frame_find_by_id could error out. */
5139 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
5142 fr
= frame_find_by_id (b
->watchpoint_frame
);
5143 within_current_scope
= (fr
!= NULL
);
5145 /* If we've gotten confused in the unwinder, we might have
5146 returned a frame that can't describe this variable. */
5147 if (within_current_scope
)
5149 struct symbol
*function
;
5151 function
= get_frame_function (fr
);
5152 if (function
== NULL
5153 || !contained_in (b
->exp_valid_block
, function
->value_block ()))
5154 within_current_scope
= false;
5157 if (within_current_scope
)
5158 /* If we end up stopping, the current frame will get selected
5159 in normal_stop. So this call to select_frame won't affect
5164 if (within_current_scope
)
5166 /* We use value_{,free_to_}mark because it could be a *long*
5167 time before we return to the command level and call
5168 free_all_values. We can't call free_all_values because we
5169 might be in the middle of evaluating a function call. */
5172 struct value
*new_val
;
5174 if (is_masked_watchpoint (b
))
5175 /* Since we don't know the exact trigger address (from
5176 stopped_data_address), just tell the user we've triggered
5177 a mask watchpoint. */
5178 return WP_VALUE_CHANGED
;
5180 mark
= value_mark ();
5181 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &new_val
,
5184 if (b
->val_bitsize
!= 0)
5185 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5187 /* We use value_equal_contents instead of value_equal because
5188 the latter coerces an array to a pointer, thus comparing just
5189 the address of the array instead of its contents. This is
5190 not what we want. */
5191 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5192 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
5195 bs
->old_val
= b
->val
;
5196 b
->val
= release_value (new_val
);
5197 b
->val_valid
= true;
5198 if (new_val
!= NULL
)
5199 value_free_to_mark (mark
);
5200 return WP_VALUE_CHANGED
;
5204 /* Nothing changed. */
5205 value_free_to_mark (mark
);
5206 return WP_VALUE_NOT_CHANGED
;
5211 /* This seems like the only logical thing to do because
5212 if we temporarily ignored the watchpoint, then when
5213 we reenter the block in which it is valid it contains
5214 garbage (in the case of a function, it may have two
5215 garbage values, one before and one after the prologue).
5216 So we can't even detect the first assignment to it and
5217 watch after that (since the garbage may or may not equal
5218 the first value assigned). */
5219 /* We print all the stop information in
5220 breakpointprint_it, but in this case, by the time we
5221 call breakpoint->print_it this bp will be deleted
5222 already. So we have no choice but print the information
5225 SWITCH_THRU_ALL_UIS ()
5227 struct ui_out
*uiout
= current_uiout
;
5229 if (uiout
->is_mi_like_p ())
5231 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5232 uiout
->message ("\nWatchpoint %pF deleted because the program has "
5233 "left the block in\n"
5234 "which its expression is valid.\n",
5235 signed_field ("wpnum", b
->number
));
5238 /* Make sure the watchpoint's commands aren't executed. */
5240 watchpoint_del_at_next_stop (b
);
5246 /* Return true if it looks like target has stopped due to hitting
5247 breakpoint location BL. This function does not check if we should
5248 stop, only if BL explains the stop. */
5251 bpstat_check_location (const struct bp_location
*bl
,
5252 const address_space
*aspace
, CORE_ADDR bp_addr
,
5253 const target_waitstatus
&ws
)
5255 struct breakpoint
*b
= bl
->owner
;
5257 /* BL is from an existing breakpoint. */
5258 gdb_assert (b
!= NULL
);
5260 return b
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5263 /* Determine if the watched values have actually changed, and we
5264 should stop. If not, set BS->stop to false. */
5267 bpstat_check_watchpoint (bpstat
*bs
)
5269 const struct bp_location
*bl
;
5270 struct watchpoint
*b
;
5272 /* BS is built for existing struct breakpoint. */
5273 bl
= bs
->bp_location_at
.get ();
5274 gdb_assert (bl
!= NULL
);
5275 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5276 gdb_assert (b
!= NULL
);
5279 bool must_check_value
= false;
5281 if (b
->type
== bp_watchpoint
)
5282 /* For a software watchpoint, we must always check the
5284 must_check_value
= true;
5285 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5286 /* We have a hardware watchpoint (read, write, or access)
5287 and the target earlier reported an address watched by
5289 must_check_value
= true;
5290 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5291 && b
->type
== bp_hardware_watchpoint
)
5292 /* We were stopped by a hardware watchpoint, but the target could
5293 not report the data address. We must check the watchpoint's
5294 value. Access and read watchpoints are out of luck; without
5295 a data address, we can't figure it out. */
5296 must_check_value
= true;
5298 if (must_check_value
)
5304 e
= watchpoint_check (bs
);
5306 catch (const gdb_exception
&ex
)
5308 exception_fprintf (gdb_stderr
, ex
,
5309 "Error evaluating expression "
5310 "for watchpoint %d\n",
5313 SWITCH_THRU_ALL_UIS ()
5315 gdb_printf (_("Watchpoint %d deleted.\n"),
5318 watchpoint_del_at_next_stop (b
);
5325 /* We've already printed what needs to be printed. */
5326 bs
->print_it
= print_it_done
;
5330 bs
->print_it
= print_it_noop
;
5333 case WP_VALUE_CHANGED
:
5334 if (b
->type
== bp_read_watchpoint
)
5336 /* There are two cases to consider here:
5338 1. We're watching the triggered memory for reads.
5339 In that case, trust the target, and always report
5340 the watchpoint hit to the user. Even though
5341 reads don't cause value changes, the value may
5342 have changed since the last time it was read, and
5343 since we're not trapping writes, we will not see
5344 those, and as such we should ignore our notion of
5347 2. We're watching the triggered memory for both
5348 reads and writes. There are two ways this may
5351 2.1. This is a target that can't break on data
5352 reads only, but can break on accesses (reads or
5353 writes), such as e.g., x86. We detect this case
5354 at the time we try to insert read watchpoints.
5356 2.2. Otherwise, the target supports read
5357 watchpoints, but, the user set an access or write
5358 watchpoint watching the same memory as this read
5361 If we're watching memory writes as well as reads,
5362 ignore watchpoint hits when we find that the
5363 value hasn't changed, as reads don't cause
5364 changes. This still gives false positives when
5365 the program writes the same value to memory as
5366 what there was already in memory (we will confuse
5367 it for a read), but it's much better than
5370 int other_write_watchpoint
= 0;
5372 if (bl
->watchpoint_type
== hw_read
)
5374 for (breakpoint
*other_b
: all_breakpoints ())
5375 if (other_b
->type
== bp_hardware_watchpoint
5376 || other_b
->type
== bp_access_watchpoint
)
5378 struct watchpoint
*other_w
=
5379 (struct watchpoint
*) other_b
;
5381 if (other_w
->watchpoint_triggered
5382 == watch_triggered_yes
)
5384 other_write_watchpoint
= 1;
5390 if (other_write_watchpoint
5391 || bl
->watchpoint_type
== hw_access
)
5393 /* We're watching the same memory for writes,
5394 and the value changed since the last time we
5395 updated it, so this trap must be for a write.
5397 bs
->print_it
= print_it_noop
;
5402 case WP_VALUE_NOT_CHANGED
:
5403 if (b
->type
== bp_hardware_watchpoint
5404 || b
->type
== bp_watchpoint
)
5406 /* Don't stop: write watchpoints shouldn't fire if
5407 the value hasn't changed. */
5408 bs
->print_it
= print_it_noop
;
5418 else /* !must_check_value */
5420 /* This is a case where some watchpoint(s) triggered, but
5421 not at the address of this watchpoint, or else no
5422 watchpoint triggered after all. So don't print
5423 anything for this watchpoint. */
5424 bs
->print_it
= print_it_noop
;
5430 /* For breakpoints that are currently marked as telling gdb to stop,
5431 check conditions (condition proper, frame, thread and ignore count)
5432 of breakpoint referred to by BS. If we should not stop for this
5433 breakpoint, set BS->stop to 0. */
5436 bpstat_check_breakpoint_conditions (bpstat
*bs
, thread_info
*thread
)
5438 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
5440 const struct bp_location
*bl
;
5441 struct breakpoint
*b
;
5443 bool condition_result
= true;
5444 struct expression
*cond
;
5446 gdb_assert (bs
->stop
);
5448 /* BS is built for existing struct breakpoint. */
5449 bl
= bs
->bp_location_at
.get ();
5450 gdb_assert (bl
!= NULL
);
5451 b
= bs
->breakpoint_at
;
5452 gdb_assert (b
!= NULL
);
5454 infrun_debug_printf ("thread = %s, breakpoint %d.%d",
5455 thread
->ptid
.to_string ().c_str (),
5456 b
->number
, find_loc_num_by_location (bl
));
5458 /* Even if the target evaluated the condition on its end and notified GDB, we
5459 need to do so again since GDB does not know if we stopped due to a
5460 breakpoint or a single step breakpoint. */
5462 if (frame_id_p (b
->frame_id
)
5463 && b
->frame_id
!= get_stack_frame_id (get_current_frame ()))
5465 infrun_debug_printf ("incorrect frame %s not %s, not stopping",
5466 get_stack_frame_id (get_current_frame ()).to_string ().c_str (),
5467 b
->frame_id
.to_string ().c_str ());
5472 /* If this is a thread/task-specific breakpoint, don't waste cpu
5473 evaluating the condition if this isn't the specified
5475 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5476 || (b
->task
!= -1 && b
->task
!= ada_get_task_number (thread
)))
5478 infrun_debug_printf ("incorrect thread or task, not stopping");
5483 /* Evaluate extension language breakpoints that have a "stop" method
5485 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5487 if (is_watchpoint (b
))
5489 struct watchpoint
*w
= (struct watchpoint
*) b
;
5491 cond
= w
->cond_exp
.get ();
5494 cond
= bl
->cond
.get ();
5496 if (cond
!= nullptr && b
->disposition
!= disp_del_at_next_stop
)
5498 bool within_current_scope
= true;
5499 struct watchpoint
* w
;
5501 /* We use scoped_value_mark because it could be a long time
5502 before we return to the command level and call
5503 free_all_values. We can't call free_all_values because we
5504 might be in the middle of evaluating a function call. */
5505 scoped_value_mark mark
;
5507 if (is_watchpoint (b
))
5508 w
= (struct watchpoint
*) b
;
5512 /* Need to select the frame, with all that implies so that
5513 the conditions will have the right context. Because we
5514 use the frame, we will not see an inlined function's
5515 variables when we arrive at a breakpoint at the start
5516 of the inlined function; the current frame will be the
5518 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5519 select_frame (get_current_frame ());
5522 frame_info_ptr frame
;
5524 /* For local watchpoint expressions, which particular
5525 instance of a local is being watched matters, so we
5526 keep track of the frame to evaluate the expression
5527 in. To evaluate the condition however, it doesn't
5528 really matter which instantiation of the function
5529 where the condition makes sense triggers the
5530 watchpoint. This allows an expression like "watch
5531 global if q > 10" set in `func', catch writes to
5532 global on all threads that call `func', or catch
5533 writes on all recursive calls of `func' by a single
5534 thread. We simply always evaluate the condition in
5535 the innermost frame that's executing where it makes
5536 sense to evaluate the condition. It seems
5538 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5540 select_frame (frame
);
5542 within_current_scope
= false;
5544 if (within_current_scope
)
5548 condition_result
= breakpoint_cond_eval (cond
);
5550 catch (const gdb_exception
&ex
)
5552 exception_fprintf (gdb_stderr
, ex
,
5553 "Error in testing breakpoint condition:\n");
5558 warning (_("Watchpoint condition cannot be tested "
5559 "in the current scope"));
5560 /* If we failed to set the right context for this
5561 watchpoint, unconditionally report it. */
5563 /* FIXME-someday, should give breakpoint #. */
5566 if (cond
!= nullptr && !condition_result
)
5568 infrun_debug_printf ("condition_result = false, not stopping");
5572 else if (b
->ignore_count
> 0)
5574 infrun_debug_printf ("ignore count %d, not stopping",
5578 /* Increase the hit count even though we don't stop. */
5580 gdb::observers::breakpoint_modified
.notify (b
);
5585 infrun_debug_printf ("stopping at this breakpoint");
5587 infrun_debug_printf ("not stopping at this breakpoint");
5590 /* Returns true if we need to track moribund locations of LOC's type
5591 on the current target. */
5594 need_moribund_for_location_type (const struct bp_location
*loc
)
5596 return ((loc
->loc_type
== bp_loc_software_breakpoint
5597 && !target_supports_stopped_by_sw_breakpoint ())
5598 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5599 && !target_supports_stopped_by_hw_breakpoint ()));
5602 /* See breakpoint.h. */
5605 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5606 const target_waitstatus
&ws
)
5608 bpstat
*bs_head
= nullptr, **bs_link
= &bs_head
;
5610 for (breakpoint
*b
: all_breakpoints ())
5612 if (!breakpoint_enabled (b
))
5615 for (bp_location
*bl
: b
->locations ())
5617 /* For hardware watchpoints, we look only at the first
5618 location. The watchpoint_check function will work on the
5619 entire expression, not the individual locations. For
5620 read watchpoints, the watchpoints_triggered function has
5621 checked all locations already. */
5622 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5625 if (!bl
->enabled
|| bl
->disabled_by_cond
|| bl
->shlib_disabled
)
5628 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5631 /* Come here if it's a watchpoint, or if the break address
5634 bpstat
*bs
= new bpstat (bl
, &bs_link
); /* Alloc a bpstat to
5637 /* Assume we stop. Should we find a watchpoint that is not
5638 actually triggered, or if the condition of the breakpoint
5639 evaluates as false, we'll reset 'stop' to 0. */
5643 /* If this is a scope breakpoint, mark the associated
5644 watchpoint as triggered so that we will handle the
5645 out-of-scope event. We'll get to the watchpoint next
5647 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5649 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5651 w
->watchpoint_triggered
= watch_triggered_yes
;
5656 /* Check if a moribund breakpoint explains the stop. */
5657 if (!target_supports_stopped_by_sw_breakpoint ()
5658 || !target_supports_stopped_by_hw_breakpoint ())
5660 for (bp_location
*loc
: moribund_locations
)
5662 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5663 && need_moribund_for_location_type (loc
))
5665 bpstat
*bs
= new bpstat (loc
, &bs_link
);
5666 /* For hits of moribund locations, we should just proceed. */
5669 bs
->print_it
= print_it_noop
;
5677 /* See breakpoint.h. */
5680 bpstat_stop_status (const address_space
*aspace
,
5681 CORE_ADDR bp_addr
, thread_info
*thread
,
5682 const target_waitstatus
&ws
,
5685 struct breakpoint
*b
= NULL
;
5686 /* First item of allocated bpstat's. */
5687 bpstat
*bs_head
= stop_chain
;
5689 int need_remove_insert
;
5692 /* First, build the bpstat chain with locations that explain a
5693 target stop, while being careful to not set the target running,
5694 as that may invalidate locations (in particular watchpoint
5695 locations are recreated). Resuming will happen here with
5696 breakpoint conditions or watchpoint expressions that include
5697 inferior function calls. */
5698 if (bs_head
== NULL
)
5699 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5701 /* A bit of special processing for shlib breakpoints. We need to
5702 process solib loading here, so that the lists of loaded and
5703 unloaded libraries are correct before we handle "catch load" and
5705 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5707 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5709 handle_solib_event ();
5714 /* Now go through the locations that caused the target to stop, and
5715 check whether we're interested in reporting this stop to higher
5716 layers, or whether we should resume the target transparently. */
5720 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5725 b
= bs
->breakpoint_at
;
5726 b
->check_status (bs
);
5729 bpstat_check_breakpoint_conditions (bs
, thread
);
5735 /* We will stop here. */
5736 if (b
->disposition
== disp_disable
)
5738 --(b
->enable_count
);
5739 if (b
->enable_count
<= 0)
5740 b
->enable_state
= bp_disabled
;
5743 gdb::observers::breakpoint_modified
.notify (b
);
5746 bs
->commands
= b
->commands
;
5747 if (command_line_is_silent (bs
->commands
5748 ? bs
->commands
.get () : NULL
))
5751 b
->after_condition_true (bs
);
5756 /* Print nothing for this entry if we don't stop or don't
5758 if (!bs
->stop
|| !bs
->print
)
5759 bs
->print_it
= print_it_noop
;
5762 /* If we aren't stopping, the value of some hardware watchpoint may
5763 not have changed, but the intermediate memory locations we are
5764 watching may have. Don't bother if we're stopping; this will get
5766 need_remove_insert
= 0;
5767 if (! bpstat_causes_stop (bs_head
))
5768 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5770 && bs
->breakpoint_at
5771 && is_hardware_watchpoint (bs
->breakpoint_at
))
5773 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5775 update_watchpoint (w
, false /* don't reparse. */);
5776 need_remove_insert
= 1;
5779 if (need_remove_insert
)
5780 update_global_location_list (UGLL_MAY_INSERT
);
5781 else if (removed_any
)
5782 update_global_location_list (UGLL_DONT_INSERT
);
5787 /* See breakpoint.h. */
5790 bpstat_stop_status_nowatch (const address_space
*aspace
, CORE_ADDR bp_addr
,
5791 thread_info
*thread
, const target_waitstatus
&ws
)
5793 gdb_assert (!target_stopped_by_watchpoint ());
5795 /* Clear all watchpoints' 'watchpoint_triggered' value from a
5796 previous stop to avoid confusing bpstat_stop_status. */
5797 watchpoints_triggered (ws
);
5799 return bpstat_stop_status (aspace
, bp_addr
, thread
, ws
);
5803 handle_jit_event (CORE_ADDR address
)
5805 struct gdbarch
*gdbarch
;
5807 infrun_debug_printf ("handling bp_jit_event");
5809 /* Switch terminal for any messages produced by
5810 breakpoint_re_set. */
5811 target_terminal::ours_for_output ();
5813 gdbarch
= get_frame_arch (get_current_frame ());
5814 /* This event is caused by a breakpoint set in `jit_breakpoint_re_set`,
5815 thus it is expected that its objectfile can be found through
5816 minimal symbol lookup. If it doesn't work (and assert fails), it
5817 most likely means that `jit_breakpoint_re_set` was changes and this
5818 function needs to be updated too. */
5819 bound_minimal_symbol jit_bp_sym
= lookup_minimal_symbol_by_pc (address
);
5820 gdb_assert (jit_bp_sym
.objfile
!= nullptr);
5821 objfile
*objfile
= jit_bp_sym
.objfile
;
5822 if (objfile
->separate_debug_objfile_backlink
)
5823 objfile
= objfile
->separate_debug_objfile_backlink
;
5824 jit_event_handler (gdbarch
, objfile
);
5826 target_terminal::inferior ();
5829 /* Prepare WHAT final decision for infrun. */
5831 /* Decide what infrun needs to do with this bpstat. */
5834 bpstat_what (bpstat
*bs_head
)
5836 struct bpstat_what retval
;
5839 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5840 retval
.call_dummy
= STOP_NONE
;
5841 retval
.is_longjmp
= false;
5843 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5845 /* Extract this BS's action. After processing each BS, we check
5846 if its action overrides all we've seem so far. */
5847 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5850 if (bs
->breakpoint_at
== NULL
)
5852 /* I suspect this can happen if it was a momentary
5853 breakpoint which has since been deleted. */
5857 bptype
= bs
->breakpoint_at
->type
;
5864 case bp_hardware_breakpoint
:
5865 case bp_single_step
:
5868 case bp_shlib_event
:
5872 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5874 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5877 this_action
= BPSTAT_WHAT_SINGLE
;
5880 case bp_hardware_watchpoint
:
5881 case bp_read_watchpoint
:
5882 case bp_access_watchpoint
:
5886 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5888 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5892 /* There was a watchpoint, but we're not stopping.
5893 This requires no further action. */
5897 case bp_longjmp_call_dummy
:
5901 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5902 retval
.is_longjmp
= bptype
!= bp_exception
;
5905 this_action
= BPSTAT_WHAT_SINGLE
;
5907 case bp_longjmp_resume
:
5908 case bp_exception_resume
:
5911 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5912 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5915 this_action
= BPSTAT_WHAT_SINGLE
;
5917 case bp_step_resume
:
5919 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5922 /* It is for the wrong frame. */
5923 this_action
= BPSTAT_WHAT_SINGLE
;
5926 case bp_hp_step_resume
:
5928 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5931 /* It is for the wrong frame. */
5932 this_action
= BPSTAT_WHAT_SINGLE
;
5935 case bp_watchpoint_scope
:
5936 case bp_thread_event
:
5937 case bp_overlay_event
:
5938 case bp_longjmp_master
:
5939 case bp_std_terminate_master
:
5940 case bp_exception_master
:
5941 this_action
= BPSTAT_WHAT_SINGLE
;
5947 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5949 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5953 /* Some catchpoints are implemented with breakpoints.
5954 For those, we need to step over the breakpoint. */
5955 if (bs
->bp_location_at
->loc_type
== bp_loc_software_breakpoint
5956 || bs
->bp_location_at
->loc_type
== bp_loc_hardware_breakpoint
)
5957 this_action
= BPSTAT_WHAT_SINGLE
;
5961 this_action
= BPSTAT_WHAT_SINGLE
;
5964 /* Make sure the action is stop (silent or noisy),
5965 so infrun.c pops the dummy frame. */
5966 retval
.call_dummy
= STOP_STACK_DUMMY
;
5967 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5969 case bp_std_terminate
:
5970 /* Make sure the action is stop (silent or noisy),
5971 so infrun.c pops the dummy frame. */
5972 retval
.call_dummy
= STOP_STD_TERMINATE
;
5973 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5976 case bp_fast_tracepoint
:
5977 case bp_static_tracepoint
:
5978 case bp_static_marker_tracepoint
:
5979 /* Tracepoint hits should not be reported back to GDB, and
5980 if one got through somehow, it should have been filtered
5982 internal_error (_("bpstat_what: tracepoint encountered"));
5984 case bp_gnu_ifunc_resolver
:
5985 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5986 this_action
= BPSTAT_WHAT_SINGLE
;
5988 case bp_gnu_ifunc_resolver_return
:
5989 /* The breakpoint will be removed, execution will restart from the
5990 PC of the former breakpoint. */
5991 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5996 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5998 this_action
= BPSTAT_WHAT_SINGLE
;
6002 internal_error (_("bpstat_what: unhandled bptype %d"), (int) bptype
);
6005 retval
.main_action
= std::max (retval
.main_action
, this_action
);
6012 bpstat_run_callbacks (bpstat
*bs_head
)
6016 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
6018 struct breakpoint
*b
= bs
->breakpoint_at
;
6025 handle_jit_event (bs
->bp_location_at
->address
);
6027 case bp_gnu_ifunc_resolver
:
6028 gnu_ifunc_resolver_stop ((code_breakpoint
*) b
);
6030 case bp_gnu_ifunc_resolver_return
:
6031 gnu_ifunc_resolver_return_stop ((code_breakpoint
*) b
);
6037 /* See breakpoint.h. */
6040 bpstat_should_step ()
6042 for (breakpoint
*b
: all_breakpoints ())
6043 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
6049 /* See breakpoint.h. */
6052 bpstat_causes_stop (bpstat
*bs
)
6054 for (; bs
!= NULL
; bs
= bs
->next
)
6063 /* Compute a number of spaces suitable to indent the next line
6064 so it starts at the position corresponding to the table column
6065 named COL_NAME in the currently active table of UIOUT. */
6068 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
6070 int i
, total_width
, width
, align
;
6074 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
6076 if (strcmp (text
, col_name
) == 0)
6079 total_width
+= width
+ 1;
6085 /* Determine if the locations of this breakpoint will have their conditions
6086 evaluated by the target, host or a mix of both. Returns the following:
6088 "host": Host evals condition.
6089 "host or target": Host or Target evals condition.
6090 "target": Target evals condition.
6094 bp_condition_evaluator (const breakpoint
*b
)
6096 char host_evals
= 0;
6097 char target_evals
= 0;
6102 if (!is_breakpoint (b
))
6105 if (gdb_evaluates_breakpoint_condition_p ()
6106 || !target_supports_evaluation_of_breakpoint_conditions ())
6107 return condition_evaluation_host
;
6109 for (bp_location
*bl
: b
->locations ())
6111 if (bl
->cond_bytecode
)
6117 if (host_evals
&& target_evals
)
6118 return condition_evaluation_both
;
6119 else if (target_evals
)
6120 return condition_evaluation_target
;
6122 return condition_evaluation_host
;
6125 /* Determine the breakpoint location's condition evaluator. This is
6126 similar to bp_condition_evaluator, but for locations. */
6129 bp_location_condition_evaluator (const struct bp_location
*bl
)
6131 if (bl
&& !is_breakpoint (bl
->owner
))
6134 if (gdb_evaluates_breakpoint_condition_p ()
6135 || !target_supports_evaluation_of_breakpoint_conditions ())
6136 return condition_evaluation_host
;
6138 if (bl
&& bl
->cond_bytecode
)
6139 return condition_evaluation_target
;
6141 return condition_evaluation_host
;
6144 /* Print the LOC location out of the list of B->LOC locations. */
6147 print_breakpoint_location (const breakpoint
*b
,
6148 struct bp_location
*loc
)
6150 struct ui_out
*uiout
= current_uiout
;
6152 scoped_restore_current_program_space restore_pspace
;
6154 if (loc
!= NULL
&& loc
->shlib_disabled
)
6158 set_current_program_space (loc
->pspace
);
6160 if (b
->display_canonical
)
6161 uiout
->field_string ("what", b
->locspec
->to_string ());
6162 else if (loc
&& loc
->symtab
)
6164 const struct symbol
*sym
= loc
->symbol
;
6168 uiout
->text ("in ");
6169 uiout
->field_string ("func", sym
->print_name (),
6170 function_name_style
.style ());
6172 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
6173 uiout
->text ("at ");
6175 uiout
->field_string ("file",
6176 symtab_to_filename_for_display (loc
->symtab
),
6177 file_name_style
.style ());
6180 if (uiout
->is_mi_like_p ())
6181 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
6183 uiout
->field_signed ("line", loc
->line_number
);
6189 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
6191 uiout
->field_stream ("at", stb
);
6195 uiout
->field_string ("pending", b
->locspec
->to_string ());
6196 /* If extra_string is available, it could be holding a condition
6197 or dprintf arguments. In either case, make sure it is printed,
6198 too, but only for non-MI streams. */
6199 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
6201 if (b
->type
== bp_dprintf
)
6205 uiout
->text (b
->extra_string
.get ());
6209 if (loc
&& is_breakpoint (b
)
6210 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6211 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6214 uiout
->field_string ("evaluated-by",
6215 bp_location_condition_evaluator (loc
));
6221 bptype_string (enum bptype type
)
6223 struct ep_type_description
6226 const char *description
;
6228 static struct ep_type_description bptypes
[] =
6230 {bp_none
, "?deleted?"},
6231 {bp_breakpoint
, "breakpoint"},
6232 {bp_hardware_breakpoint
, "hw breakpoint"},
6233 {bp_single_step
, "sw single-step"},
6234 {bp_until
, "until"},
6235 {bp_finish
, "finish"},
6236 {bp_watchpoint
, "watchpoint"},
6237 {bp_hardware_watchpoint
, "hw watchpoint"},
6238 {bp_read_watchpoint
, "read watchpoint"},
6239 {bp_access_watchpoint
, "acc watchpoint"},
6240 {bp_longjmp
, "longjmp"},
6241 {bp_longjmp_resume
, "longjmp resume"},
6242 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6243 {bp_exception
, "exception"},
6244 {bp_exception_resume
, "exception resume"},
6245 {bp_step_resume
, "step resume"},
6246 {bp_hp_step_resume
, "high-priority step resume"},
6247 {bp_watchpoint_scope
, "watchpoint scope"},
6248 {bp_call_dummy
, "call dummy"},
6249 {bp_std_terminate
, "std::terminate"},
6250 {bp_shlib_event
, "shlib events"},
6251 {bp_thread_event
, "thread events"},
6252 {bp_overlay_event
, "overlay events"},
6253 {bp_longjmp_master
, "longjmp master"},
6254 {bp_std_terminate_master
, "std::terminate master"},
6255 {bp_exception_master
, "exception master"},
6256 {bp_catchpoint
, "catchpoint"},
6257 {bp_tracepoint
, "tracepoint"},
6258 {bp_fast_tracepoint
, "fast tracepoint"},
6259 {bp_static_tracepoint
, "static tracepoint"},
6260 {bp_static_marker_tracepoint
, "static marker tracepoint"},
6261 {bp_dprintf
, "dprintf"},
6262 {bp_jit_event
, "jit events"},
6263 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6264 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6267 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6268 || ((int) type
!= bptypes
[(int) type
].type
))
6269 internal_error (_("bptypes table does not describe type #%d."),
6272 return bptypes
[(int) type
].description
;
6275 /* For MI, output a field named 'thread-groups' with a list as the value.
6276 For CLI, prefix the list with the string 'inf'. */
6279 output_thread_groups (struct ui_out
*uiout
,
6280 const char *field_name
,
6281 const std::vector
<int> &inf_nums
,
6284 int is_mi
= uiout
->is_mi_like_p ();
6286 /* For backward compatibility, don't display inferiors in CLI unless
6287 there are several. Always display them for MI. */
6288 if (!is_mi
&& mi_only
)
6291 ui_out_emit_list
list_emitter (uiout
, field_name
);
6293 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6299 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6300 uiout
->field_string (NULL
, mi_group
);
6305 uiout
->text (" inf ");
6309 uiout
->text (plongest (inf_nums
[i
]));
6314 /* See breakpoint.h. */
6316 bool fix_breakpoint_script_output_globally
= false;
6318 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
6319 instead of going via breakpoint_ops::print_one. This makes "maint
6320 info breakpoints" show the software breakpoint locations of
6321 catchpoints, which are considered internal implementation
6322 detail. Returns true if RAW_LOC is false and if the breakpoint's
6323 print_one method did something; false otherwise. */
6326 print_one_breakpoint_location (struct breakpoint
*b
,
6327 struct bp_location
*loc
,
6329 struct bp_location
**last_loc
,
6330 int allflag
, bool raw_loc
)
6332 struct command_line
*l
;
6333 static char bpenables
[] = "nynny";
6335 struct ui_out
*uiout
= current_uiout
;
6336 bool header_of_multiple
= false;
6337 bool part_of_multiple
= (loc
!= NULL
);
6338 struct value_print_options opts
;
6340 get_user_print_options (&opts
);
6342 gdb_assert (!loc
|| loc_number
!= 0);
6343 /* See comment in print_one_breakpoint concerning treatment of
6344 breakpoints with single disabled location. */
6347 && (b
->loc
->next
!= NULL
6348 || !b
->loc
->enabled
|| b
->loc
->disabled_by_cond
)))
6349 header_of_multiple
= true;
6357 if (part_of_multiple
)
6358 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
6360 uiout
->field_signed ("number", b
->number
);
6364 if (part_of_multiple
)
6365 uiout
->field_skip ("type");
6367 uiout
->field_string ("type", bptype_string (b
->type
));
6371 if (part_of_multiple
)
6372 uiout
->field_skip ("disp");
6374 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6378 if (part_of_multiple
)
6380 /* For locations that are disabled because of an invalid
6381 condition, display "N*" on the CLI, where "*" refers to a
6382 footnote below the table. For MI, simply display a "N"
6383 without a footnote. On the CLI, for enabled locations whose
6384 breakpoint is disabled, display "y-". */
6385 auto get_enable_state
= [uiout
, loc
] () -> const char *
6387 if (uiout
->is_mi_like_p ())
6389 if (loc
->disabled_by_cond
)
6391 else if (!loc
->enabled
)
6398 if (loc
->disabled_by_cond
)
6400 else if (!loc
->enabled
)
6402 else if (!breakpoint_enabled (loc
->owner
))
6408 uiout
->field_string ("enabled", get_enable_state ());
6411 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6414 bool result
= false;
6415 if (!raw_loc
&& b
->print_one (last_loc
))
6419 if (is_watchpoint (b
))
6421 struct watchpoint
*w
= (struct watchpoint
*) b
;
6423 /* Field 4, the address, is omitted (which makes the columns
6424 not line up too nicely with the headers, but the effect
6425 is relatively readable). */
6426 if (opts
.addressprint
)
6427 uiout
->field_skip ("addr");
6429 uiout
->field_string ("what", w
->exp_string
.get ());
6431 else if (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6432 || is_ada_exception_catchpoint (b
))
6434 if (opts
.addressprint
)
6437 if (header_of_multiple
)
6438 uiout
->field_string ("addr", "<MULTIPLE>",
6439 metadata_style
.style ());
6440 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6441 uiout
->field_string ("addr", "<PENDING>",
6442 metadata_style
.style ());
6444 uiout
->field_core_addr ("addr",
6445 loc
->gdbarch
, loc
->address
);
6448 if (!header_of_multiple
)
6449 print_breakpoint_location (b
, loc
);
6455 if (loc
!= NULL
&& !header_of_multiple
)
6457 std::vector
<int> inf_nums
;
6460 for (inferior
*inf
: all_inferiors ())
6462 if (inf
->pspace
== loc
->pspace
)
6463 inf_nums
.push_back (inf
->num
);
6466 /* For backward compatibility, don't display inferiors in CLI unless
6467 there are several. Always display for MI. */
6469 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6470 && (program_spaces
.size () > 1
6471 || number_of_inferiors () > 1)
6472 /* LOC is for existing B, it cannot be in
6473 moribund_locations and thus having NULL OWNER. */
6474 && loc
->owner
->type
!= bp_catchpoint
))
6476 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6479 /* In the MI output, each location of a thread or task specific
6480 breakpoint includes the relevant thread or task ID. This is done for
6481 backwards compatibility reasons.
6483 For the CLI output, the thread/task information is printed on a
6484 separate line, see the 'stop only in thread' and 'stop only in task'
6486 if (!header_of_multiple
&& uiout
->is_mi_like_p ())
6488 if (b
->thread
!= -1)
6489 uiout
->field_signed ("thread", b
->thread
);
6490 else if (b
->task
!= -1)
6491 uiout
->field_signed ("task", b
->task
);
6496 if (!part_of_multiple
)
6497 b
->print_one_detail (uiout
);
6499 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6502 uiout
->text ("\tstop only in stack frame at ");
6503 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6505 uiout
->field_core_addr ("frame",
6506 b
->gdbarch
, b
->frame_id
.stack_addr
);
6510 if (!part_of_multiple
&& b
->cond_string
)
6513 if (is_tracepoint (b
))
6514 uiout
->text ("\ttrace only if ");
6516 uiout
->text ("\tstop only if ");
6517 uiout
->field_string ("cond", b
->cond_string
.get ());
6519 /* Print whether the target is doing the breakpoint's condition
6520 evaluation. If GDB is doing the evaluation, don't print anything. */
6521 if (is_breakpoint (b
)
6522 && breakpoint_condition_evaluation_mode ()
6523 == condition_evaluation_target
)
6525 uiout
->message (" (%pF evals)",
6526 string_field ("evaluated-by",
6527 bp_condition_evaluator (b
)));
6532 if (!part_of_multiple
&& b
->thread
!= -1)
6534 /* FIXME should make an annotation for this. */
6535 uiout
->text ("\tstop only in thread ");
6536 if (uiout
->is_mi_like_p ())
6537 uiout
->field_signed ("thread", b
->thread
);
6540 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6542 uiout
->field_string ("thread", print_thread_id (thr
));
6547 if (!part_of_multiple
&& b
->task
!= -1)
6549 uiout
->text ("\tstop only in task ");
6550 uiout
->field_signed ("task", b
->task
);
6554 if (!part_of_multiple
)
6558 /* FIXME should make an annotation for this. */
6559 if (is_catchpoint (b
))
6560 uiout
->text ("\tcatchpoint");
6561 else if (is_tracepoint (b
))
6562 uiout
->text ("\ttracepoint");
6564 uiout
->text ("\tbreakpoint");
6565 uiout
->text (" already hit ");
6566 uiout
->field_signed ("times", b
->hit_count
);
6567 if (b
->hit_count
== 1)
6568 uiout
->text (" time\n");
6570 uiout
->text (" times\n");
6574 /* Output the count also if it is zero, but only if this is mi. */
6575 if (uiout
->is_mi_like_p ())
6576 uiout
->field_signed ("times", b
->hit_count
);
6580 if (!part_of_multiple
&& b
->ignore_count
)
6583 uiout
->message ("\tignore next %pF hits\n",
6584 signed_field ("ignore", b
->ignore_count
));
6587 /* Note that an enable count of 1 corresponds to "enable once"
6588 behavior, which is reported by the combination of enablement and
6589 disposition, so we don't need to mention it here. */
6590 if (!part_of_multiple
&& b
->enable_count
> 1)
6593 uiout
->text ("\tdisable after ");
6594 /* Tweak the wording to clarify that ignore and enable counts
6595 are distinct, and have additive effect. */
6596 if (b
->ignore_count
)
6597 uiout
->text ("additional ");
6599 uiout
->text ("next ");
6600 uiout
->field_signed ("enable", b
->enable_count
);
6601 uiout
->text (" hits\n");
6604 if (!part_of_multiple
&& is_tracepoint (b
))
6606 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6608 if (tp
->traceframe_usage
)
6610 uiout
->text ("\ttrace buffer usage ");
6611 uiout
->field_signed ("traceframe-usage", tp
->traceframe_usage
);
6612 uiout
->text (" bytes\n");
6616 l
= b
->commands
? b
->commands
.get () : NULL
;
6617 if (!part_of_multiple
&& l
)
6621 bool use_fixed_output
=
6622 (uiout
->test_flags (fix_breakpoint_script_output
)
6623 || fix_breakpoint_script_output_globally
);
6625 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
6626 gdb::optional
<ui_out_emit_list
> list_emitter
;
6628 if (use_fixed_output
)
6629 list_emitter
.emplace (uiout
, "script");
6631 tuple_emitter
.emplace (uiout
, "script");
6633 print_command_lines (uiout
, l
, 4);
6636 if (is_tracepoint (b
))
6638 struct tracepoint
*t
= (struct tracepoint
*) b
;
6640 if (!part_of_multiple
&& t
->pass_count
)
6642 annotate_field (10);
6643 uiout
->text ("\tpass count ");
6644 uiout
->field_signed ("pass", t
->pass_count
);
6645 uiout
->text (" \n");
6648 /* Don't display it when tracepoint or tracepoint location is
6650 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6652 annotate_field (11);
6654 if (uiout
->is_mi_like_p ())
6655 uiout
->field_string ("installed",
6656 loc
->inserted
? "y" : "n");
6662 uiout
->text ("\tnot ");
6663 uiout
->text ("installed on target\n");
6668 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6670 if (is_watchpoint (b
))
6672 struct watchpoint
*w
= (struct watchpoint
*) b
;
6674 uiout
->field_string ("original-location", w
->exp_string
.get ());
6676 else if (b
->locspec
!= nullptr)
6678 const char *str
= b
->locspec
->to_string ();
6680 uiout
->field_string ("original-location", str
);
6687 /* See breakpoint.h. */
6689 bool fix_multi_location_breakpoint_output_globally
= false;
6692 print_one_breakpoint (struct breakpoint
*b
,
6693 struct bp_location
**last_loc
,
6696 struct ui_out
*uiout
= current_uiout
;
6697 bool use_fixed_output
6698 = (uiout
->test_flags (fix_multi_location_breakpoint_output
)
6699 || fix_multi_location_breakpoint_output_globally
);
6701 gdb::optional
<ui_out_emit_tuple
> bkpt_tuple_emitter (gdb::in_place
, uiout
, "bkpt");
6702 bool printed
= print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
6705 /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6707 if (!use_fixed_output
)
6708 bkpt_tuple_emitter
.reset ();
6710 /* If this breakpoint has custom print function,
6711 it's already printed. Otherwise, print individual
6712 locations, if any. */
6713 if (!printed
|| allflag
)
6715 /* If breakpoint has a single location that is disabled, we
6716 print it as if it had several locations, since otherwise it's
6717 hard to represent "breakpoint enabled, location disabled"
6720 Note that while hardware watchpoints have several locations
6721 internally, that's not a property exposed to users.
6723 Likewise, while catchpoints may be implemented with
6724 breakpoints (e.g., catch throw), that's not a property
6725 exposed to users. We do however display the internal
6726 breakpoint locations with "maint info breakpoints". */
6727 if (!is_hardware_watchpoint (b
)
6728 && (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6729 || is_ada_exception_catchpoint (b
))
6731 || (b
->loc
&& (b
->loc
->next
6733 || b
->loc
->disabled_by_cond
))))
6735 gdb::optional
<ui_out_emit_list
> locations_list
;
6737 /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6738 MI record. For later versions, place breakpoint locations in a
6740 if (uiout
->is_mi_like_p () && use_fixed_output
)
6741 locations_list
.emplace (uiout
, "locations");
6744 for (bp_location
*loc
: b
->locations ())
6746 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6747 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6756 breakpoint_address_bits (struct breakpoint
*b
)
6758 int print_address_bits
= 0;
6760 for (bp_location
*loc
: b
->locations ())
6762 if (!bl_address_is_meaningful (loc
))
6765 int addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6766 if (addr_bit
> print_address_bits
)
6767 print_address_bits
= addr_bit
;
6770 return print_address_bits
;
6773 /* See breakpoint.h. */
6776 print_breakpoint (breakpoint
*b
)
6778 struct bp_location
*dummy_loc
= NULL
;
6779 print_one_breakpoint (b
, &dummy_loc
, 0);
6782 /* Return true if this breakpoint was set by the user, false if it is
6783 internal or momentary. */
6786 user_breakpoint_p (struct breakpoint
*b
)
6788 return b
->number
> 0;
6791 /* See breakpoint.h. */
6794 pending_breakpoint_p (struct breakpoint
*b
)
6796 return b
->loc
== NULL
;
6799 /* Print information on breakpoints (including watchpoints and tracepoints).
6801 If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
6802 understood by number_or_range_parser. Only breakpoints included in this
6803 list are then printed.
6805 If SHOW_INTERNAL is true, print internal breakpoints.
6807 If FILTER is non-NULL, call it on each breakpoint and only include the
6808 ones for which it returns true.
6810 Return the total number of breakpoints listed. */
6813 breakpoint_1 (const char *bp_num_list
, bool show_internal
,
6814 bool (*filter
) (const struct breakpoint
*))
6816 struct bp_location
*last_loc
= NULL
;
6817 int nr_printable_breakpoints
;
6818 struct value_print_options opts
;
6819 int print_address_bits
= 0;
6820 int print_type_col_width
= 14;
6821 struct ui_out
*uiout
= current_uiout
;
6822 bool has_disabled_by_cond_location
= false;
6824 get_user_print_options (&opts
);
6826 /* Compute the number of rows in the table, as well as the size
6827 required for address fields. */
6828 nr_printable_breakpoints
= 0;
6829 for (breakpoint
*b
: all_breakpoints ())
6831 /* If we have a filter, only list the breakpoints it accepts. */
6832 if (filter
&& !filter (b
))
6835 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6836 accept. Skip the others. */
6837 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6839 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6841 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6845 if (show_internal
|| user_breakpoint_p (b
))
6847 int addr_bit
, type_len
;
6849 addr_bit
= breakpoint_address_bits (b
);
6850 if (addr_bit
> print_address_bits
)
6851 print_address_bits
= addr_bit
;
6853 type_len
= strlen (bptype_string (b
->type
));
6854 if (type_len
> print_type_col_width
)
6855 print_type_col_width
= type_len
;
6857 nr_printable_breakpoints
++;
6862 ui_out_emit_table
table_emitter (uiout
,
6863 opts
.addressprint
? 6 : 5,
6864 nr_printable_breakpoints
,
6867 if (nr_printable_breakpoints
> 0)
6868 annotate_breakpoints_headers ();
6869 if (nr_printable_breakpoints
> 0)
6871 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6872 if (nr_printable_breakpoints
> 0)
6874 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6875 if (nr_printable_breakpoints
> 0)
6877 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6878 if (nr_printable_breakpoints
> 0)
6880 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6881 if (opts
.addressprint
)
6883 if (nr_printable_breakpoints
> 0)
6885 if (print_address_bits
<= 32)
6886 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6888 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6890 if (nr_printable_breakpoints
> 0)
6892 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6893 uiout
->table_body ();
6894 if (nr_printable_breakpoints
> 0)
6895 annotate_breakpoints_table ();
6897 for (breakpoint
*b
: all_breakpoints ())
6900 /* If we have a filter, only list the breakpoints it accepts. */
6901 if (filter
&& !filter (b
))
6904 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6905 accept. Skip the others. */
6907 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6909 if (show_internal
) /* maintenance info breakpoint */
6911 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6914 else /* all others */
6916 if (!number_is_in_list (bp_num_list
, b
->number
))
6920 /* We only print out user settable breakpoints unless the
6921 show_internal is set. */
6922 if (show_internal
|| user_breakpoint_p (b
))
6924 print_one_breakpoint (b
, &last_loc
, show_internal
);
6925 for (bp_location
*loc
: b
->locations ())
6926 if (loc
->disabled_by_cond
)
6927 has_disabled_by_cond_location
= true;
6932 if (nr_printable_breakpoints
== 0)
6934 /* If there's a filter, let the caller decide how to report
6938 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6939 uiout
->message ("No breakpoints or watchpoints.\n");
6941 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6947 if (last_loc
&& !server_command
)
6948 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6950 if (has_disabled_by_cond_location
&& !uiout
->is_mi_like_p ())
6951 uiout
->message (_("(*): Breakpoint condition is invalid at this "
6955 /* FIXME? Should this be moved up so that it is only called when
6956 there have been breakpoints? */
6957 annotate_breakpoints_table_end ();
6959 return nr_printable_breakpoints
;
6962 /* Display the value of default-collect in a way that is generally
6963 compatible with the breakpoint list. */
6966 default_collect_info (void)
6968 struct ui_out
*uiout
= current_uiout
;
6970 /* If it has no value (which is frequently the case), say nothing; a
6971 message like "No default-collect." gets in user's face when it's
6973 if (default_collect
.empty ())
6976 /* The following phrase lines up nicely with per-tracepoint collect
6978 uiout
->text ("default collect ");
6979 uiout
->field_string ("default-collect", default_collect
);
6980 uiout
->text (" \n");
6984 info_breakpoints_command (const char *args
, int from_tty
)
6986 breakpoint_1 (args
, false, NULL
);
6988 default_collect_info ();
6992 info_watchpoints_command (const char *args
, int from_tty
)
6994 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6995 struct ui_out
*uiout
= current_uiout
;
6997 if (num_printed
== 0)
6999 if (args
== NULL
|| *args
== '\0')
7000 uiout
->message ("No watchpoints.\n");
7002 uiout
->message ("No watchpoint matching '%s'.\n", args
);
7007 maintenance_info_breakpoints (const char *args
, int from_tty
)
7009 breakpoint_1 (args
, true, NULL
);
7011 default_collect_info ();
7015 breakpoint_has_pc (struct breakpoint
*b
,
7016 struct program_space
*pspace
,
7017 CORE_ADDR pc
, struct obj_section
*section
)
7019 for (bp_location
*bl
: b
->locations ())
7021 if (bl
->pspace
== pspace
7022 && bl
->address
== pc
7023 && (!overlay_debugging
|| bl
->section
== section
))
7029 /* See breakpoint.h. */
7032 describe_other_breakpoints (struct gdbarch
*gdbarch
,
7033 struct program_space
*pspace
, CORE_ADDR pc
,
7034 struct obj_section
*section
, int thread
)
7038 for (breakpoint
*b
: all_breakpoints ())
7039 others
+= (user_breakpoint_p (b
)
7040 && breakpoint_has_pc (b
, pspace
, pc
, section
));
7045 gdb_printf (_("Note: breakpoint "));
7046 else /* if (others == ???) */
7047 gdb_printf (_("Note: breakpoints "));
7048 for (breakpoint
*b
: all_breakpoints ())
7049 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
7052 gdb_printf ("%d", b
->number
);
7053 if (b
->thread
== -1 && thread
!= -1)
7054 gdb_printf (" (all threads)");
7055 else if (b
->thread
!= -1)
7057 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
7058 gdb_printf (" (thread %s)", print_thread_id (thr
));
7060 else if (b
->task
!= -1)
7061 gdb_printf (" (task %d)", b
->task
);
7062 gdb_printf ("%s%s ",
7063 ((b
->enable_state
== bp_disabled
7064 || b
->enable_state
== bp_call_disabled
)
7068 : ((others
== 1) ? " and" : ""));
7070 current_uiout
->message (_("also set at pc %ps.\n"),
7071 styled_string (address_style
.style (),
7072 paddress (gdbarch
, pc
)));
7077 /* Return true iff it is meaningful to use the address member of LOC.
7078 For some breakpoint types, the locations' address members are
7079 irrelevant and it makes no sense to attempt to compare them to
7080 other addresses (or use them for any other purpose either).
7082 More specifically, software watchpoints and catchpoints that are
7083 not backed by breakpoints always have a zero valued location
7084 address and we don't want to mark breakpoints of any of these types
7085 to be a duplicate of an actual breakpoint location at address
7089 bl_address_is_meaningful (bp_location
*loc
)
7091 return loc
->loc_type
!= bp_loc_other
;
7094 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7095 true if LOC1 and LOC2 represent the same watchpoint location. */
7098 watchpoint_locations_match (const struct bp_location
*loc1
,
7099 const struct bp_location
*loc2
)
7101 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
7102 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
7104 /* Both of them must exist. */
7105 gdb_assert (w1
!= NULL
);
7106 gdb_assert (w2
!= NULL
);
7108 /* If the target can evaluate the condition expression in hardware,
7109 then we we need to insert both watchpoints even if they are at
7110 the same place. Otherwise the watchpoint will only trigger when
7111 the condition of whichever watchpoint was inserted evaluates to
7112 true, not giving a chance for GDB to check the condition of the
7113 other watchpoint. */
7115 && target_can_accel_watchpoint_condition (loc1
->address
,
7117 loc1
->watchpoint_type
,
7118 w1
->cond_exp
.get ()))
7120 && target_can_accel_watchpoint_condition (loc2
->address
,
7122 loc2
->watchpoint_type
,
7123 w2
->cond_exp
.get ())))
7126 /* Note that this checks the owner's type, not the location's. In
7127 case the target does not support read watchpoints, but does
7128 support access watchpoints, we'll have bp_read_watchpoint
7129 watchpoints with hw_access locations. Those should be considered
7130 duplicates of hw_read locations. The hw_read locations will
7131 become hw_access locations later. */
7132 return (loc1
->owner
->type
== loc2
->owner
->type
7133 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
7134 && loc1
->address
== loc2
->address
7135 && loc1
->length
== loc2
->length
);
7138 /* See breakpoint.h. */
7141 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
7142 const address_space
*aspace2
, CORE_ADDR addr2
)
7144 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7145 || aspace1
== aspace2
)
7149 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7150 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7151 matches ASPACE2. On targets that have global breakpoints, the address
7152 space doesn't really matter. */
7155 breakpoint_address_match_range (const address_space
*aspace1
,
7157 int len1
, const address_space
*aspace2
,
7160 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7161 || aspace1
== aspace2
)
7162 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7165 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7166 a ranged breakpoint. In most targets, a match happens only if ASPACE
7167 matches the breakpoint's address space. On targets that have global
7168 breakpoints, the address space doesn't really matter. */
7171 breakpoint_location_address_match (struct bp_location
*bl
,
7172 const address_space
*aspace
,
7175 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7178 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7179 bl
->address
, bl
->length
,
7183 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7184 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7185 match happens only if ASPACE matches the breakpoint's address
7186 space. On targets that have global breakpoints, the address space
7187 doesn't really matter. */
7190 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7191 const address_space
*aspace
,
7192 CORE_ADDR addr
, int len
)
7194 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7195 || bl
->pspace
->aspace
== aspace
)
7197 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7199 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7205 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7206 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7207 true, otherwise returns false. */
7210 tracepoint_locations_match (const struct bp_location
*loc1
,
7211 const struct bp_location
*loc2
)
7213 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7214 /* Since tracepoint locations are never duplicated with others', tracepoint
7215 locations at the same address of different tracepoints are regarded as
7216 different locations. */
7217 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7222 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7223 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
7224 the same location. If SW_HW_BPS_MATCH is true, then software
7225 breakpoint locations and hardware breakpoint locations match,
7226 otherwise they don't. */
7229 breakpoint_locations_match (const struct bp_location
*loc1
,
7230 const struct bp_location
*loc2
,
7231 bool sw_hw_bps_match
)
7233 int hw_point1
, hw_point2
;
7235 /* Both of them must not be in moribund_locations. */
7236 gdb_assert (loc1
->owner
!= NULL
);
7237 gdb_assert (loc2
->owner
!= NULL
);
7239 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7240 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7242 if (hw_point1
!= hw_point2
)
7245 return watchpoint_locations_match (loc1
, loc2
);
7246 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7247 return tracepoint_locations_match (loc1
, loc2
);
7249 /* We compare bp_location.length in order to cover ranged
7250 breakpoints. Keep this in sync with
7251 bp_location_is_less_than. */
7252 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7253 loc2
->pspace
->aspace
, loc2
->address
)
7254 && (loc1
->loc_type
== loc2
->loc_type
|| sw_hw_bps_match
)
7255 && loc1
->length
== loc2
->length
);
7259 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7260 int bnum
, bool have_bnum
)
7262 /* The longest string possibly returned by hex_string_custom
7263 is 50 chars. These must be at least that big for safety. */
7267 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7268 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7270 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7271 bnum
, astr1
, astr2
);
7273 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7276 /* Adjust a breakpoint's address to account for architectural
7277 constraints on breakpoint placement. Return the adjusted address.
7278 Note: Very few targets require this kind of adjustment. For most
7279 targets, this function is simply the identity function. */
7282 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7283 CORE_ADDR bpaddr
, enum bptype bptype
,
7284 struct program_space
*pspace
)
7286 gdb_assert (pspace
!= nullptr);
7288 if (bptype
== bp_watchpoint
7289 || bptype
== bp_hardware_watchpoint
7290 || bptype
== bp_read_watchpoint
7291 || bptype
== bp_access_watchpoint
7292 || bptype
== bp_catchpoint
)
7294 /* Watchpoints and the various bp_catch_* eventpoints should not
7295 have their addresses modified. */
7298 else if (bptype
== bp_single_step
)
7300 /* Single-step breakpoints should not have their addresses
7301 modified. If there's any architectural constrain that
7302 applies to this address, then it should have already been
7303 taken into account when the breakpoint was created in the
7304 first place. If we didn't do this, stepping through e.g.,
7305 Thumb-2 IT blocks would break. */
7310 CORE_ADDR adjusted_bpaddr
= bpaddr
;
7312 /* Some targets have architectural constraints on the placement
7313 of breakpoint instructions. Obtain the adjusted address. */
7314 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7316 /* Targets that implement this adjustment function will likely
7317 inspect either the symbol table, target memory at BPADDR, or
7318 even state registers, so ensure a suitable thread (and its
7319 associated program space) are currently selected. */
7320 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
7321 switch_to_program_space_and_thread (pspace
);
7323 = gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7327 = gdbarch_remove_non_address_bits (gdbarch
, adjusted_bpaddr
);
7329 /* An adjusted breakpoint address can significantly alter
7330 a user's expectations. Print a warning if an adjustment
7332 if (adjusted_bpaddr
!= bpaddr
)
7333 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, false);
7335 return adjusted_bpaddr
;
7340 bp_location_from_bp_type (bptype type
)
7345 case bp_single_step
:
7349 case bp_longjmp_resume
:
7350 case bp_longjmp_call_dummy
:
7352 case bp_exception_resume
:
7353 case bp_step_resume
:
7354 case bp_hp_step_resume
:
7355 case bp_watchpoint_scope
:
7357 case bp_std_terminate
:
7358 case bp_shlib_event
:
7359 case bp_thread_event
:
7360 case bp_overlay_event
:
7362 case bp_longjmp_master
:
7363 case bp_std_terminate_master
:
7364 case bp_exception_master
:
7365 case bp_gnu_ifunc_resolver
:
7366 case bp_gnu_ifunc_resolver_return
:
7368 return bp_loc_software_breakpoint
;
7369 case bp_hardware_breakpoint
:
7370 return bp_loc_hardware_breakpoint
;
7371 case bp_hardware_watchpoint
:
7372 case bp_read_watchpoint
:
7373 case bp_access_watchpoint
:
7374 return bp_loc_hardware_watchpoint
;
7376 return bp_loc_software_watchpoint
;
7379 case bp_fast_tracepoint
:
7380 case bp_static_tracepoint
:
7381 case bp_static_marker_tracepoint
:
7382 return bp_loc_other
;
7384 internal_error (_("unknown breakpoint type"));
7388 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
7390 this->owner
= owner
;
7391 this->cond_bytecode
= NULL
;
7392 this->shlib_disabled
= 0;
7394 this->disabled_by_cond
= false;
7396 this->loc_type
= type
;
7398 if (this->loc_type
== bp_loc_software_breakpoint
7399 || this->loc_type
== bp_loc_hardware_breakpoint
)
7400 mark_breakpoint_location_modified (this);
7405 bp_location::bp_location (breakpoint
*owner
)
7406 : bp_location::bp_location (owner
,
7407 bp_location_from_bp_type (owner
->type
))
7411 /* Decrement reference count. If the reference count reaches 0,
7412 destroy the bp_location. Sets *BLP to NULL. */
7415 decref_bp_location (struct bp_location
**blp
)
7417 bp_location_ref_policy::decref (*blp
);
7421 /* Add breakpoint B at the end of the global breakpoint chain. */
7424 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7426 struct breakpoint
*b1
;
7427 struct breakpoint
*result
= b
.get ();
7429 /* Add this breakpoint to the end of the chain so that a list of
7430 breakpoints will come out in order of increasing numbers. */
7432 b1
= breakpoint_chain
;
7434 breakpoint_chain
= b
.release ();
7439 b1
->next
= b
.release ();
7445 /* Initialize loc->function_name. */
7448 set_breakpoint_location_function (struct bp_location
*loc
)
7450 gdb_assert (loc
->owner
!= NULL
);
7452 if (loc
->owner
->type
== bp_breakpoint
7453 || loc
->owner
->type
== bp_hardware_breakpoint
7454 || is_tracepoint (loc
->owner
))
7456 const char *function_name
;
7458 if (loc
->msymbol
!= NULL
7459 && (loc
->msymbol
->type () == mst_text_gnu_ifunc
7460 || loc
->msymbol
->type () == mst_data_gnu_ifunc
))
7462 struct breakpoint
*b
= loc
->owner
;
7464 function_name
= loc
->msymbol
->linkage_name ();
7466 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7467 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7469 /* Create only the whole new breakpoint of this type but do not
7470 mess more complicated breakpoints with multiple locations. */
7471 b
->type
= bp_gnu_ifunc_resolver
;
7472 /* Remember the resolver's address for use by the return
7474 loc
->related_address
= loc
->address
;
7478 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7481 loc
->function_name
= make_unique_xstrdup (function_name
);
7485 /* Attempt to determine architecture of location identified by SAL. */
7487 get_sal_arch (struct symtab_and_line sal
)
7490 return sal
.section
->objfile
->arch ();
7492 return sal
.symtab
->compunit ()->objfile ()->arch ();
7497 /* Call this routine when stepping and nexting to enable a breakpoint
7498 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7499 initiated the operation. */
7502 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7504 int thread
= tp
->global_num
;
7506 /* To avoid having to rescan all objfile symbols at every step,
7507 we maintain a list of continually-inserted but always disabled
7508 longjmp "master" breakpoints. Here, we simply create momentary
7509 clones of those and enable them for the requested thread. */
7510 for (breakpoint
*b
: all_breakpoints_safe ())
7511 if (b
->pspace
== current_program_space
7512 && (b
->type
== bp_longjmp_master
7513 || b
->type
== bp_exception_master
))
7515 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7516 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7517 after their removal. */
7518 momentary_breakpoint_from_master (b
, type
, 1, thread
);
7521 tp
->initiating_frame
= frame
;
7524 /* Delete all longjmp breakpoints from THREAD. */
7526 delete_longjmp_breakpoint (int thread
)
7528 for (breakpoint
*b
: all_breakpoints_safe ())
7529 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7531 if (b
->thread
== thread
)
7532 delete_breakpoint (b
);
7537 delete_longjmp_breakpoint_at_next_stop (int thread
)
7539 for (breakpoint
*b
: all_breakpoints_safe ())
7540 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7542 if (b
->thread
== thread
)
7543 b
->disposition
= disp_del_at_next_stop
;
7547 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7548 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7549 pointer to any of them. Return NULL if this system cannot place longjmp
7553 set_longjmp_breakpoint_for_call_dummy (void)
7555 breakpoint
*retval
= nullptr;
7557 for (breakpoint
*b
: all_breakpoints ())
7558 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7560 int thread
= inferior_thread ()->global_num
;
7562 = momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7565 /* Link NEW_B into the chain of RETVAL breakpoints. */
7567 gdb_assert (new_b
->related_breakpoint
== new_b
);
7570 new_b
->related_breakpoint
= retval
;
7571 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7572 retval
= retval
->related_breakpoint
;
7573 retval
->related_breakpoint
= new_b
;
7579 /* Verify all existing dummy frames and their associated breakpoints for
7580 TP. Remove those which can no longer be found in the current frame
7583 If the unwind fails then there is not sufficient information to discard
7584 dummy frames. In this case, elide the clean up and the dummy frames will
7585 be cleaned up next time this function is called from a location where
7586 unwinding is possible. */
7589 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7591 struct breakpoint
*b
, *b_tmp
;
7593 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7594 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7596 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7598 /* Find the bp_call_dummy breakpoint in the list of breakpoints
7599 chained off b->related_breakpoint. */
7600 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7601 dummy_b
= dummy_b
->related_breakpoint
;
7603 /* If there was no bp_call_dummy breakpoint then there's nothing
7604 more to do. Or, if the dummy frame associated with the
7605 bp_call_dummy is still on the stack then we need to leave this
7606 bp_call_dummy in place. */
7607 if (dummy_b
->type
!= bp_call_dummy
7608 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7611 /* We didn't find the dummy frame on the stack, this could be
7612 because we have longjmp'd to a stack frame that is previous to
7613 the dummy frame, or it could be because the stack unwind is
7614 broken at some point between the longjmp frame and the dummy
7617 Next we figure out why the stack unwind stopped. If it looks
7618 like the unwind is complete then we assume the dummy frame has
7619 been jumped over, however, if the unwind stopped for an
7620 unexpected reason then we assume the stack unwind is currently
7621 broken, and that we will (eventually) return to the dummy
7624 It might be tempting to consider using frame_id_inner here, but
7625 that is not safe. There is no guarantee that the stack frames
7626 we are looking at here are even on the same stack as the
7627 original dummy frame, hence frame_id_inner can't be used. See
7628 the comments on frame_id_inner for more details. */
7629 bool unwind_finished_unexpectedly
= false;
7630 for (frame_info_ptr fi
= get_current_frame (); fi
!= nullptr; )
7632 frame_info_ptr prev
= get_prev_frame (fi
);
7633 if (prev
== nullptr)
7635 /* FI is the last stack frame. Why did this frame not
7637 auto stop_reason
= get_frame_unwind_stop_reason (fi
);
7638 if (stop_reason
!= UNWIND_NO_REASON
7639 && stop_reason
!= UNWIND_OUTERMOST
)
7640 unwind_finished_unexpectedly
= true;
7644 if (unwind_finished_unexpectedly
)
7647 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7649 while (b
->related_breakpoint
!= b
)
7651 if (b_tmp
== b
->related_breakpoint
)
7652 b_tmp
= b
->related_breakpoint
->next
;
7653 delete_breakpoint (b
->related_breakpoint
);
7655 delete_breakpoint (b
);
7660 enable_overlay_breakpoints (void)
7662 for (breakpoint
*b
: all_breakpoints ())
7663 if (b
->type
== bp_overlay_event
)
7665 b
->enable_state
= bp_enabled
;
7666 update_global_location_list (UGLL_MAY_INSERT
);
7667 overlay_events_enabled
= 1;
7672 disable_overlay_breakpoints (void)
7674 for (breakpoint
*b
: all_breakpoints ())
7675 if (b
->type
== bp_overlay_event
)
7677 b
->enable_state
= bp_disabled
;
7678 update_global_location_list (UGLL_DONT_INSERT
);
7679 overlay_events_enabled
= 0;
7683 /* Set an active std::terminate breakpoint for each std::terminate
7684 master breakpoint. */
7686 set_std_terminate_breakpoint (void)
7688 for (breakpoint
*b
: all_breakpoints_safe ())
7689 if (b
->pspace
== current_program_space
7690 && b
->type
== bp_std_terminate_master
)
7692 momentary_breakpoint_from_master (b
, bp_std_terminate
, 1,
7693 inferior_thread ()->global_num
);
7697 /* Delete all the std::terminate breakpoints. */
7699 delete_std_terminate_breakpoint (void)
7701 for (breakpoint
*b
: all_breakpoints_safe ())
7702 if (b
->type
== bp_std_terminate
)
7703 delete_breakpoint (b
);
7707 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7709 struct breakpoint
*b
;
7711 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
7713 b
->enable_state
= bp_enabled
;
7714 /* locspec has to be used or breakpoint_re_set will delete me. */
7715 b
->locspec
= new_address_location_spec (b
->loc
->address
, NULL
, 0);
7717 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7722 struct lang_and_radix
7728 /* Create a breakpoint for JIT code registration and unregistration. */
7731 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7733 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
7736 /* Remove JIT code registration and unregistration breakpoint(s). */
7739 remove_jit_event_breakpoints (void)
7741 for (breakpoint
*b
: all_breakpoints_safe ())
7742 if (b
->type
== bp_jit_event
7743 && b
->loc
->pspace
== current_program_space
)
7744 delete_breakpoint (b
);
7748 remove_solib_event_breakpoints (void)
7750 for (breakpoint
*b
: all_breakpoints_safe ())
7751 if (b
->type
== bp_shlib_event
7752 && b
->loc
->pspace
== current_program_space
)
7753 delete_breakpoint (b
);
7756 /* See breakpoint.h. */
7759 remove_solib_event_breakpoints_at_next_stop (void)
7761 for (breakpoint
*b
: all_breakpoints_safe ())
7762 if (b
->type
== bp_shlib_event
7763 && b
->loc
->pspace
== current_program_space
)
7764 b
->disposition
= disp_del_at_next_stop
;
7767 /* Helper for create_solib_event_breakpoint /
7768 create_and_insert_solib_event_breakpoint. Allows specifying which
7769 INSERT_MODE to pass through to update_global_location_list. */
7771 static struct breakpoint
*
7772 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7773 enum ugll_insert_mode insert_mode
)
7775 struct breakpoint
*b
;
7777 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
7778 update_global_location_list_nothrow (insert_mode
);
7783 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7785 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7788 /* See breakpoint.h. */
7791 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7793 struct breakpoint
*b
;
7795 /* Explicitly tell update_global_location_list to insert
7797 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7798 if (!b
->loc
->inserted
)
7800 delete_breakpoint (b
);
7806 /* Disable any breakpoints that are on code in shared libraries. Only
7807 apply to enabled breakpoints, disabled ones can just stay disabled. */
7810 disable_breakpoints_in_shlibs (void)
7812 for (bp_location
*loc
: all_bp_locations ())
7814 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7815 struct breakpoint
*b
= loc
->owner
;
7817 /* We apply the check to all breakpoints, including disabled for
7818 those with loc->duplicate set. This is so that when breakpoint
7819 becomes enabled, or the duplicate is removed, gdb will try to
7820 insert all breakpoints. If we don't set shlib_disabled here,
7821 we'll try to insert those breakpoints and fail. */
7822 if (((b
->type
== bp_breakpoint
)
7823 || (b
->type
== bp_jit_event
)
7824 || (b
->type
== bp_hardware_breakpoint
)
7825 || (is_tracepoint (b
)))
7826 && loc
->pspace
== current_program_space
7827 && !loc
->shlib_disabled
7828 && solib_name_from_address (loc
->pspace
, loc
->address
)
7831 loc
->shlib_disabled
= 1;
7836 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7837 notification of unloaded_shlib. Only apply to enabled breakpoints,
7838 disabled ones can just stay disabled. */
7841 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7843 bool disabled_shlib_breaks
= false;
7845 for (bp_location
*loc
: all_bp_locations ())
7847 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7848 struct breakpoint
*b
= loc
->owner
;
7850 if (solib
->pspace
== loc
->pspace
7851 && !loc
->shlib_disabled
7852 && (((b
->type
== bp_breakpoint
7853 || b
->type
== bp_jit_event
7854 || b
->type
== bp_hardware_breakpoint
)
7855 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7856 || loc
->loc_type
== bp_loc_software_breakpoint
))
7857 || is_tracepoint (b
))
7858 && solib_contains_address_p (solib
, loc
->address
))
7860 loc
->shlib_disabled
= 1;
7861 /* At this point, we cannot rely on remove_breakpoint
7862 succeeding so we must mark the breakpoint as not inserted
7863 to prevent future errors occurring in remove_breakpoints. */
7866 /* This may cause duplicate notifications for the same breakpoint. */
7867 gdb::observers::breakpoint_modified
.notify (b
);
7869 if (!disabled_shlib_breaks
)
7871 target_terminal::ours_for_output ();
7872 warning (_("Temporarily disabling breakpoints "
7873 "for unloaded shared library \"%s\""),
7876 disabled_shlib_breaks
= true;
7881 /* Disable any breakpoints and tracepoints in OBJFILE upon
7882 notification of free_objfile. Only apply to enabled breakpoints,
7883 disabled ones can just stay disabled. */
7886 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7888 if (objfile
== NULL
)
7891 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7892 managed by the user with add-symbol-file/remove-symbol-file.
7893 Similarly to how breakpoints in shared libraries are handled in
7894 response to "nosharedlibrary", mark breakpoints in such modules
7895 shlib_disabled so they end up uninserted on the next global
7896 location list update. Shared libraries not loaded by the user
7897 aren't handled here -- they're already handled in
7898 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7899 solib_unloaded observer. We skip objfiles that are not
7900 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7902 if ((objfile
->flags
& OBJF_SHARED
) == 0
7903 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7906 for (breakpoint
*b
: all_breakpoints ())
7908 bool bp_modified
= false;
7910 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7913 for (bp_location
*loc
: b
->locations ())
7915 CORE_ADDR loc_addr
= loc
->address
;
7917 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7918 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7921 if (loc
->shlib_disabled
!= 0)
7924 if (objfile
->pspace
!= loc
->pspace
)
7927 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7928 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7931 if (is_addr_in_objfile (loc_addr
, objfile
))
7933 loc
->shlib_disabled
= 1;
7934 /* At this point, we don't know whether the object was
7935 unmapped from the inferior or not, so leave the
7936 inserted flag alone. We'll handle failure to
7937 uninsert quietly, in case the object was indeed
7940 mark_breakpoint_location_modified (loc
);
7947 gdb::observers::breakpoint_modified
.notify (b
);
7951 /* See breakpoint.h. */
7953 breakpoint::breakpoint (struct gdbarch
*gdbarch_
, enum bptype bptype
,
7954 bool temp
, const char *cond_string_
)
7956 disposition (temp
? disp_del
: disp_donttouch
),
7958 language (current_language
->la_language
),
7959 input_radix (::input_radix
),
7960 cond_string (cond_string_
!= nullptr
7961 ? make_unique_xstrdup (cond_string_
)
7963 related_breakpoint (this)
7967 /* See breakpoint.h. */
7969 catchpoint::catchpoint (struct gdbarch
*gdbarch
, bool temp
,
7970 const char *cond_string
)
7971 : breakpoint (gdbarch
, bp_catchpoint
, temp
, cond_string
)
7973 add_dummy_location (this, current_program_space
);
7975 pspace
= current_program_space
;
7979 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
7981 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
7982 set_breakpoint_number (internal
, b
);
7983 if (is_tracepoint (b
))
7984 set_tracepoint_count (breakpoint_count
);
7987 gdb::observers::breakpoint_created
.notify (b
);
7990 update_global_location_list (UGLL_MAY_INSERT
);
7996 hw_breakpoint_used_count (void)
8000 for (breakpoint
*b
: all_breakpoints ())
8001 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8002 for (bp_location
*bl
: b
->locations ())
8004 /* Special types of hardware breakpoints may use more than
8006 i
+= b
->resources_needed (bl
);
8012 /* Returns the resources B would use if it were a hardware
8016 hw_watchpoint_use_count (struct breakpoint
*b
)
8020 if (!breakpoint_enabled (b
))
8023 for (bp_location
*bl
: b
->locations ())
8025 /* Special types of hardware watchpoints may use more than
8027 i
+= b
->resources_needed (bl
);
8033 /* Returns the sum the used resources of all hardware watchpoints of
8034 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8035 the sum of the used resources of all hardware watchpoints of other
8036 types _not_ TYPE. */
8039 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8040 enum bptype type
, int *other_type_used
)
8044 *other_type_used
= 0;
8045 for (breakpoint
*b
: all_breakpoints ())
8049 if (!breakpoint_enabled (b
))
8052 if (b
->type
== type
)
8053 i
+= hw_watchpoint_use_count (b
);
8054 else if (is_hardware_watchpoint (b
))
8055 *other_type_used
= 1;
8062 disable_watchpoints_before_interactive_call_start (void)
8064 for (breakpoint
*b
: all_breakpoints ())
8065 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8067 b
->enable_state
= bp_call_disabled
;
8068 update_global_location_list (UGLL_DONT_INSERT
);
8073 enable_watchpoints_after_interactive_call_stop (void)
8075 for (breakpoint
*b
: all_breakpoints ())
8076 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8078 b
->enable_state
= bp_enabled
;
8079 update_global_location_list (UGLL_MAY_INSERT
);
8084 disable_breakpoints_before_startup (void)
8086 current_program_space
->executing_startup
= 1;
8087 update_global_location_list (UGLL_DONT_INSERT
);
8091 enable_breakpoints_after_startup (void)
8093 current_program_space
->executing_startup
= 0;
8094 breakpoint_re_set ();
8097 /* Allocate a new momentary breakpoint. */
8099 template<typename
... Arg
>
8100 static momentary_breakpoint
*
8101 new_momentary_breakpoint (struct gdbarch
*gdbarch
, enum bptype type
,
8104 if (type
== bp_longjmp
|| type
== bp_exception
)
8105 return new longjmp_breakpoint (gdbarch
, type
,
8106 std::forward
<Arg
> (args
)...);
8108 return new momentary_breakpoint (gdbarch
, type
,
8109 std::forward
<Arg
> (args
)...);
8112 /* Set a momentary breakpoint of type TYPE at address specified by
8113 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8117 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8118 struct frame_id frame_id
, enum bptype type
)
8120 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8122 gdb_assert (!frame_id_artificial_p (frame_id
));
8124 std::unique_ptr
<momentary_breakpoint
> b
8125 (new_momentary_breakpoint (gdbarch
, type
, sal
.pspace
, frame_id
,
8126 inferior_thread ()->global_num
));
8128 b
->add_location (sal
);
8130 breakpoint_up
bp (add_to_breakpoint_chain (std::move (b
)));
8132 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8137 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8138 The new breakpoint will have type TYPE, use OPS as its
8139 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8141 static struct breakpoint
*
8142 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8147 std::unique_ptr
<breakpoint
> copy
8148 (new_momentary_breakpoint (orig
->gdbarch
, type
, orig
->pspace
,
8149 orig
->frame_id
, thread
));
8150 copy
->loc
= copy
->allocate_location ();
8151 set_breakpoint_location_function (copy
->loc
);
8153 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8154 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8155 copy
->loc
->address
= orig
->loc
->address
;
8156 copy
->loc
->section
= orig
->loc
->section
;
8157 copy
->loc
->pspace
= orig
->loc
->pspace
;
8158 copy
->loc
->probe
= orig
->loc
->probe
;
8159 copy
->loc
->line_number
= orig
->loc
->line_number
;
8160 copy
->loc
->symtab
= orig
->loc
->symtab
;
8161 copy
->loc
->enabled
= loc_enabled
;
8163 breakpoint
*b
= add_to_breakpoint_chain (std::move (copy
));
8164 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8168 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8172 clone_momentary_breakpoint (struct breakpoint
*orig
)
8174 /* If there's nothing to clone, then return nothing. */
8178 return momentary_breakpoint_from_master (orig
, orig
->type
, 0,
8183 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8186 struct symtab_and_line sal
;
8188 sal
= find_pc_line (pc
, 0);
8190 sal
.section
= find_pc_overlay (pc
);
8191 sal
.explicit_pc
= 1;
8193 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8197 /* Tell the user we have just set a breakpoint B. */
8200 mention (const breakpoint
*b
)
8202 b
->print_mention ();
8203 current_uiout
->text ("\n");
8207 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8209 /* Handle "set breakpoint auto-hw on".
8211 If the explicitly specified breakpoint type is not hardware
8212 breakpoint, check the memory map to see whether the breakpoint
8213 address is in read-only memory.
8215 - location type is not hardware breakpoint, memory is read-only.
8216 We change the type of the location to hardware breakpoint.
8218 - location type is hardware breakpoint, memory is read-write. This
8219 means we've previously made the location hardware one, but then the
8220 memory map changed, so we undo.
8224 handle_automatic_hardware_breakpoints (bp_location
*bl
)
8226 if (automatic_hardware_breakpoints
8227 && bl
->owner
->type
!= bp_hardware_breakpoint
8228 && (bl
->loc_type
== bp_loc_software_breakpoint
8229 || bl
->loc_type
== bp_loc_hardware_breakpoint
))
8231 /* When breakpoints are removed, remove_breakpoints will use
8232 location types we've just set here, the only possible problem
8233 is that memory map has changed during running program, but
8234 it's not going to work anyway with current gdb. */
8235 mem_region
*mr
= lookup_mem_region (bl
->address
);
8239 enum bp_loc_type new_type
;
8241 if (mr
->attrib
.mode
!= MEM_RW
)
8242 new_type
= bp_loc_hardware_breakpoint
;
8244 new_type
= bp_loc_software_breakpoint
;
8246 if (new_type
!= bl
->loc_type
)
8248 static bool said
= false;
8250 bl
->loc_type
= new_type
;
8253 gdb_printf (_("Note: automatically using "
8254 "hardware breakpoints for "
8255 "read-only addresses.\n"));
8264 code_breakpoint::add_location (const symtab_and_line
&sal
)
8266 struct bp_location
*new_loc
, **tmp
;
8267 CORE_ADDR adjusted_address
;
8268 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8270 if (loc_gdbarch
== NULL
)
8271 loc_gdbarch
= gdbarch
;
8273 /* Adjust the breakpoint's address prior to allocating a location.
8274 Once we call allocate_location(), that mostly uninitialized
8275 location will be placed on the location chain. Adjustment of the
8276 breakpoint may cause target_read_memory() to be called and we do
8277 not want its scan of the location chain to find a breakpoint and
8278 location that's only been partially initialized. */
8279 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8283 /* Sort the locations by their ADDRESS. */
8284 new_loc
= allocate_location ();
8285 for (tmp
= &(loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8286 tmp
= &((*tmp
)->next
))
8288 new_loc
->next
= *tmp
;
8291 new_loc
->requested_address
= sal
.pc
;
8292 new_loc
->address
= adjusted_address
;
8293 new_loc
->pspace
= sal
.pspace
;
8294 new_loc
->probe
.prob
= sal
.prob
;
8295 new_loc
->probe
.objfile
= sal
.objfile
;
8296 gdb_assert (new_loc
->pspace
!= NULL
);
8297 new_loc
->section
= sal
.section
;
8298 new_loc
->gdbarch
= loc_gdbarch
;
8299 new_loc
->line_number
= sal
.line
;
8300 new_loc
->symtab
= sal
.symtab
;
8301 new_loc
->symbol
= sal
.symbol
;
8302 new_loc
->msymbol
= sal
.msymbol
;
8303 new_loc
->objfile
= sal
.objfile
;
8305 set_breakpoint_location_function (new_loc
);
8307 /* While by definition, permanent breakpoints are already present in the
8308 code, we don't mark the location as inserted. Normally one would expect
8309 that GDB could rely on that breakpoint instruction to stop the program,
8310 thus removing the need to insert its own breakpoint, except that executing
8311 the breakpoint instruction can kill the target instead of reporting a
8312 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8313 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8314 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8315 breakpoint be inserted normally results in QEMU knowing about the GDB
8316 breakpoint, and thus trap before the breakpoint instruction is executed.
8317 (If GDB later needs to continue execution past the permanent breakpoint,
8318 it manually increments the PC, thus avoiding executing the breakpoint
8320 if (bp_loc_is_permanent (new_loc
))
8321 new_loc
->permanent
= 1;
8327 /* Return true if LOC is pointing to a permanent breakpoint,
8328 return false otherwise. */
8331 bp_loc_is_permanent (struct bp_location
*loc
)
8333 gdb_assert (loc
!= NULL
);
8335 /* If we have a non-breakpoint-backed catchpoint or a software
8336 watchpoint, just return 0. We should not attempt to read from
8337 the addresses the locations of these breakpoint types point to.
8338 gdbarch_program_breakpoint_here_p, below, will attempt to read
8340 if (!bl_address_is_meaningful (loc
))
8343 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8344 switch_to_program_space_and_thread (loc
->pspace
);
8345 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8348 /* Build a command list for the dprintf corresponding to the current
8349 settings of the dprintf style options. */
8352 update_dprintf_command_list (struct breakpoint
*b
)
8354 const char *dprintf_args
= b
->extra_string
.get ();
8355 gdb::unique_xmalloc_ptr
<char> printf_line
= nullptr;
8360 dprintf_args
= skip_spaces (dprintf_args
);
8362 /* Allow a comma, as it may have terminated a location, but don't
8364 if (*dprintf_args
== ',')
8366 dprintf_args
= skip_spaces (dprintf_args
);
8368 if (*dprintf_args
!= '"')
8369 error (_("Bad format string, missing '\"'."));
8371 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8372 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8373 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8375 if (dprintf_function
.empty ())
8376 error (_("No function supplied for dprintf call"));
8378 if (!dprintf_channel
.empty ())
8379 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8380 dprintf_function
.c_str (),
8381 dprintf_channel
.c_str (),
8384 printf_line
= xstrprintf ("call (void) %s (%s)",
8385 dprintf_function
.c_str (),
8388 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8390 if (target_can_run_breakpoint_commands ())
8391 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8394 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8395 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8399 internal_error (_("Invalid dprintf style."));
8401 gdb_assert (printf_line
!= NULL
);
8403 /* Manufacture a printf sequence. */
8404 struct command_line
*printf_cmd_line
8405 = new struct command_line (simple_control
, printf_line
.release ());
8406 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8407 command_lines_deleter ()));
8410 /* Update all dprintf commands, making their command lists reflect
8411 current style settings. */
8414 update_dprintf_commands (const char *args
, int from_tty
,
8415 struct cmd_list_element
*c
)
8417 for (breakpoint
*b
: all_breakpoints ())
8418 if (b
->type
== bp_dprintf
)
8419 update_dprintf_command_list (b
);
8422 code_breakpoint::code_breakpoint (struct gdbarch
*gdbarch_
,
8424 gdb::array_view
<const symtab_and_line
> sals
,
8425 location_spec_up
&&locspec_
,
8426 gdb::unique_xmalloc_ptr
<char> filter_
,
8427 gdb::unique_xmalloc_ptr
<char> cond_string_
,
8428 gdb::unique_xmalloc_ptr
<char> extra_string_
,
8429 enum bpdisp disposition_
,
8430 int thread_
, int task_
, int ignore_count_
,
8432 int enabled_
, unsigned flags
,
8433 int display_canonical_
)
8434 : breakpoint (gdbarch_
, type_
)
8438 if (type
== bp_hardware_breakpoint
)
8440 int target_resources_ok
;
8442 i
= hw_breakpoint_used_count ();
8443 target_resources_ok
=
8444 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8446 if (target_resources_ok
== 0)
8447 error (_("No hardware breakpoint support in the target."));
8448 else if (target_resources_ok
< 0)
8449 error (_("Hardware breakpoints used exceeds limit."));
8452 gdb_assert (!sals
.empty ());
8454 /* At most one of thread or task can be set on any breakpoint. */
8455 gdb_assert (thread
== -1 || task
== -1);
8459 cond_string
= std::move (cond_string_
);
8460 extra_string
= std::move (extra_string_
);
8461 ignore_count
= ignore_count_
;
8462 enable_state
= enabled_
? bp_enabled
: bp_disabled
;
8463 disposition
= disposition_
;
8465 if (type
== bp_static_tracepoint
8466 || type
== bp_static_marker_tracepoint
)
8468 auto *t
= gdb::checked_static_cast
<struct tracepoint
*> (this);
8469 struct static_tracepoint_marker marker
;
8471 if (strace_marker_p (this))
8473 /* We already know the marker exists, otherwise, we wouldn't
8474 see a sal for it. */
8475 const char *p
= &locspec_
->to_string ()[3];
8478 p
= skip_spaces (p
);
8480 endp
= skip_to_space (p
);
8482 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8484 gdb_printf (_("Probed static tracepoint marker \"%s\"\n"),
8485 t
->static_trace_marker_id
.c_str ());
8487 else if (target_static_tracepoint_marker_at (sals
[0].pc
, &marker
))
8489 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8491 gdb_printf (_("Probed static tracepoint marker \"%s\"\n"),
8492 t
->static_trace_marker_id
.c_str ());
8495 warning (_("Couldn't determine the static tracepoint marker to probe"));
8498 for (const auto &sal
: sals
)
8502 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8503 if (loc_gdbarch
== nullptr)
8504 loc_gdbarch
= gdbarch
;
8506 describe_other_breakpoints (loc_gdbarch
,
8507 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8510 bp_location
*new_loc
= add_location (sal
);
8511 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8512 new_loc
->inserted
= 1;
8514 /* Do not set breakpoint locations conditions yet. As locations
8515 are inserted, they get sorted based on their addresses. Let
8516 the list stabilize to have reliable location numbers. */
8518 /* Dynamic printf requires and uses additional arguments on the
8519 command line, otherwise it's an error. */
8520 if (type
== bp_dprintf
)
8522 if (extra_string
!= nullptr)
8523 update_dprintf_command_list (this);
8525 error (_("Format string required"));
8527 else if (extra_string
!= nullptr)
8528 error (_("Garbage '%s' at end of command"), extra_string
.get ());
8531 /* The order of the locations is now stable. Set the location
8532 condition using the location's number. */
8534 for (bp_location
*bl
: locations ())
8536 if (cond_string
!= nullptr)
8537 set_breakpoint_location_condition (cond_string
.get (), bl
,
8543 display_canonical
= display_canonical_
;
8544 if (locspec_
!= nullptr)
8545 locspec
= std::move (locspec_
);
8547 locspec
= new_address_location_spec (this->loc
->address
, NULL
, 0);
8548 filter
= std::move (filter_
);
8552 create_breakpoint_sal (struct gdbarch
*gdbarch
,
8553 gdb::array_view
<const symtab_and_line
> sals
,
8554 location_spec_up
&&locspec
,
8555 gdb::unique_xmalloc_ptr
<char> filter
,
8556 gdb::unique_xmalloc_ptr
<char> cond_string
,
8557 gdb::unique_xmalloc_ptr
<char> extra_string
,
8558 enum bptype type
, enum bpdisp disposition
,
8559 int thread
, int task
, int ignore_count
,
8561 int enabled
, int internal
, unsigned flags
,
8562 int display_canonical
)
8564 std::unique_ptr
<code_breakpoint
> b
8565 = new_breakpoint_from_type (gdbarch
,
8568 std::move (locspec
),
8570 std::move (cond_string
),
8571 std::move (extra_string
),
8573 thread
, task
, ignore_count
,
8578 install_breakpoint (internal
, std::move (b
), 0);
8581 /* Add SALS.nelts breakpoints to the breakpoint table. For each
8582 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
8583 value. COND_STRING, if not NULL, specified the condition to be
8584 used for all breakpoints. Essentially the only case where
8585 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
8586 function. In that case, it's still not possible to specify
8587 separate conditions for different overloaded functions, so
8588 we take just a single condition string.
8590 NOTE: If the function succeeds, the caller is expected to cleanup
8591 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
8592 array contents). If the function fails (error() is called), the
8593 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
8594 COND and SALS arrays and each of those arrays contents. */
8597 create_breakpoints_sal (struct gdbarch
*gdbarch
,
8598 struct linespec_result
*canonical
,
8599 gdb::unique_xmalloc_ptr
<char> cond_string
,
8600 gdb::unique_xmalloc_ptr
<char> extra_string
,
8601 enum bptype type
, enum bpdisp disposition
,
8602 int thread
, int task
, int ignore_count
,
8604 int enabled
, int internal
, unsigned flags
)
8606 if (canonical
->pre_expanded
)
8607 gdb_assert (canonical
->lsals
.size () == 1);
8609 for (const auto &lsal
: canonical
->lsals
)
8611 /* Note that 'location' can be NULL in the case of a plain
8612 'break', without arguments. */
8613 location_spec_up locspec
8614 = (canonical
->locspec
!= nullptr
8615 ? canonical
->locspec
->clone ()
8617 gdb::unique_xmalloc_ptr
<char> filter_string
8618 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
8620 create_breakpoint_sal (gdbarch
, lsal
.sals
,
8621 std::move (locspec
),
8622 std::move (filter_string
),
8623 std::move (cond_string
),
8624 std::move (extra_string
),
8626 thread
, task
, ignore_count
,
8627 from_tty
, enabled
, internal
, flags
,
8628 canonical
->special_display
);
8632 /* Parse LOCSPEC which is assumed to be a SAL specification possibly
8633 followed by conditionals. On return, SALS contains an array of SAL
8634 addresses found. LOCSPEC points to the end of the SAL (for
8637 The array and the line spec strings are allocated on the heap, it is
8638 the caller's responsibility to free them. */
8641 parse_breakpoint_sals (location_spec
*locspec
,
8642 struct linespec_result
*canonical
)
8644 struct symtab_and_line cursal
;
8646 if (locspec
->type () == LINESPEC_LOCATION_SPEC
)
8648 const char *spec
= as_linespec_location_spec (locspec
)->spec_string
;
8652 /* The last displayed codepoint, if it's valid, is our default
8653 breakpoint address. */
8654 if (last_displayed_sal_is_valid ())
8656 /* Set sal's pspace, pc, symtab, and line to the values
8657 corresponding to the last call to print_frame_info.
8658 Be sure to reinitialize LINE with NOTCURRENT == 0
8659 as the breakpoint line number is inappropriate otherwise.
8660 find_pc_line would adjust PC, re-set it back. */
8661 symtab_and_line sal
= get_last_displayed_sal ();
8662 CORE_ADDR pc
= sal
.pc
;
8664 sal
= find_pc_line (pc
, 0);
8666 /* "break" without arguments is equivalent to "break *PC"
8667 where PC is the last displayed codepoint's address. So
8668 make sure to set sal.explicit_pc to prevent GDB from
8669 trying to expand the list of sals to include all other
8670 instances with the same symtab and line. */
8672 sal
.explicit_pc
= 1;
8674 struct linespec_sals lsal
;
8676 lsal
.canonical
= NULL
;
8678 canonical
->lsals
.push_back (std::move (lsal
));
8682 error (_("No default breakpoint address now."));
8686 /* Force almost all breakpoints to be in terms of the
8687 current_source_symtab (which is decode_line_1's default).
8688 This should produce the results we want almost all of the
8689 time while leaving default_breakpoint_* alone.
8691 ObjC: However, don't match an Objective-C method name which
8692 may have a '+' or '-' succeeded by a '['. */
8693 cursal
= get_current_source_symtab_and_line ();
8694 if (last_displayed_sal_is_valid ())
8696 const char *spec
= NULL
;
8698 if (locspec
->type () == LINESPEC_LOCATION_SPEC
)
8699 spec
= as_linespec_location_spec (locspec
)->spec_string
;
8703 && strchr ("+-", spec
[0]) != NULL
8706 decode_line_full (locspec
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
8707 get_last_displayed_symtab (),
8708 get_last_displayed_line (),
8709 canonical
, NULL
, NULL
);
8714 decode_line_full (locspec
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
8715 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
8719 /* Convert each SAL into a real PC. Verify that the PC can be
8720 inserted as a breakpoint. If it can't throw an error. */
8723 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
8725 for (auto &sal
: sals
)
8726 resolve_sal_pc (&sal
);
8729 /* Fast tracepoints may have restrictions on valid locations. For
8730 instance, a fast tracepoint using a jump instead of a trap will
8731 likely have to overwrite more bytes than a trap would, and so can
8732 only be placed where the instruction is longer than the jump, or a
8733 multi-instruction sequence does not have a jump into the middle of
8737 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
8738 gdb::array_view
<const symtab_and_line
> sals
)
8740 for (const auto &sal
: sals
)
8742 struct gdbarch
*sarch
;
8744 sarch
= get_sal_arch (sal
);
8745 /* We fall back to GDBARCH if there is no architecture
8746 associated with SAL. */
8750 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
8751 error (_("May not have a fast tracepoint at %s%s"),
8752 paddress (sarch
, sal
.pc
), msg
.c_str ());
8756 /* Given TOK, a string specification of condition and thread, as
8757 accepted by the 'break' command, extract the condition
8758 string and thread number and set *COND_STRING and *THREAD.
8759 PC identifies the context at which the condition should be parsed.
8760 If no condition is found, *COND_STRING is set to NULL.
8761 If no thread is found, *THREAD is set to -1. */
8764 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
8765 gdb::unique_xmalloc_ptr
<char> *cond_string
,
8766 int *thread
, int *task
,
8767 gdb::unique_xmalloc_ptr
<char> *rest
)
8769 cond_string
->reset ();
8777 const char *end_tok
;
8779 const char *cond_start
= NULL
;
8780 const char *cond_end
= NULL
;
8782 tok
= skip_spaces (tok
);
8784 if ((*tok
== '"' || *tok
== ',') && rest
)
8786 rest
->reset (savestring (tok
, strlen (tok
)));
8790 end_tok
= skip_to_space (tok
);
8792 toklen
= end_tok
- tok
;
8794 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8796 tok
= cond_start
= end_tok
+ 1;
8799 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
8801 catch (const gdb_exception_error
&)
8806 tok
= tok
+ strlen (tok
);
8809 cond_string
->reset (savestring (cond_start
, cond_end
- cond_start
));
8811 else if (toklen
>= 1 && strncmp (tok
, "-force-condition", toklen
) == 0)
8816 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
8819 struct thread_info
*thr
;
8822 error(_("You can specify only one thread."));
8825 error (_("You can specify only one of thread or task."));
8828 thr
= parse_thread_id (tok
, &tmptok
);
8830 error (_("Junk after thread keyword."));
8831 *thread
= thr
->global_num
;
8834 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
8839 error(_("You can specify only one task."));
8842 error (_("You can specify only one of thread or task."));
8845 *task
= strtol (tok
, &tmptok
, 0);
8847 error (_("Junk after task keyword."));
8848 if (!valid_task_id (*task
))
8849 error (_("Unknown task %d."), *task
);
8854 rest
->reset (savestring (tok
, strlen (tok
)));
8858 error (_("Junk at end of arguments."));
8862 /* Call 'find_condition_and_thread' for each sal in SALS until a parse
8863 succeeds. The parsed values are written to COND_STRING, THREAD,
8864 TASK, and REST. See the comment of 'find_condition_and_thread'
8865 for the description of these parameters and INPUT. */
8868 find_condition_and_thread_for_sals (const std::vector
<symtab_and_line
> &sals
,
8870 gdb::unique_xmalloc_ptr
<char> *cond_string
,
8871 int *thread
, int *task
,
8872 gdb::unique_xmalloc_ptr
<char> *rest
)
8874 int num_failures
= 0;
8875 for (auto &sal
: sals
)
8877 gdb::unique_xmalloc_ptr
<char> cond
;
8880 gdb::unique_xmalloc_ptr
<char> remaining
;
8882 /* Here we want to parse 'arg' to separate condition from thread
8883 number. But because parsing happens in a context and the
8884 contexts of sals might be different, try each until there is
8885 success. Finding one successful parse is sufficient for our
8886 goal. When setting the breakpoint we'll re-parse the
8887 condition in the context of each sal. */
8890 find_condition_and_thread (input
, sal
.pc
, &cond
, &thread_id
,
8891 &task_id
, &remaining
);
8892 *cond_string
= std::move (cond
);
8893 /* At most one of thread or task can be set. */
8894 gdb_assert (thread_id
== -1 || task_id
== -1);
8895 *thread
= thread_id
;
8897 *rest
= std::move (remaining
);
8900 catch (const gdb_exception_error
&e
)
8903 /* If no sal remains, do not continue. */
8904 if (num_failures
== sals
.size ())
8910 /* Decode a static tracepoint marker spec. */
8912 static std::vector
<symtab_and_line
>
8913 decode_static_tracepoint_spec (const char **arg_p
)
8915 const char *p
= &(*arg_p
)[3];
8918 p
= skip_spaces (p
);
8920 endp
= skip_to_space (p
);
8922 std::string
marker_str (p
, endp
- p
);
8924 std::vector
<static_tracepoint_marker
> markers
8925 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
8926 if (markers
.empty ())
8927 error (_("No known static tracepoint marker named %s"),
8928 marker_str
.c_str ());
8930 std::vector
<symtab_and_line
> sals
;
8931 sals
.reserve (markers
.size ());
8933 for (const static_tracepoint_marker
&marker
: markers
)
8935 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
8936 sal
.pc
= marker
.address
;
8937 sals
.push_back (sal
);
8944 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
8945 according to IS_TRACEPOINT. */
8947 static const struct breakpoint_ops
*
8948 breakpoint_ops_for_location_spec_type (enum location_spec_type locspec_type
,
8953 if (locspec_type
== PROBE_LOCATION_SPEC
)
8954 return &tracepoint_probe_breakpoint_ops
;
8956 return &code_breakpoint_ops
;
8960 if (locspec_type
== PROBE_LOCATION_SPEC
)
8961 return &bkpt_probe_breakpoint_ops
;
8963 return &code_breakpoint_ops
;
8967 /* See breakpoint.h. */
8969 const struct breakpoint_ops
*
8970 breakpoint_ops_for_location_spec (const location_spec
*locspec
,
8973 if (locspec
!= nullptr)
8974 return (breakpoint_ops_for_location_spec_type
8975 (locspec
->type (), is_tracepoint
));
8976 return &code_breakpoint_ops
;
8979 /* See breakpoint.h. */
8982 create_breakpoint (struct gdbarch
*gdbarch
,
8983 location_spec
*locspec
,
8984 const char *cond_string
,
8985 int thread
, const char *extra_string
,
8986 bool force_condition
, int parse_extra
,
8987 int tempflag
, enum bptype type_wanted
,
8989 enum auto_boolean pending_break_support
,
8990 const struct breakpoint_ops
*ops
,
8991 int from_tty
, int enabled
, int internal
,
8994 struct linespec_result canonical
;
8995 bool pending
= false;
8997 int prev_bkpt_count
= breakpoint_count
;
8999 gdb_assert (ops
!= NULL
);
9001 /* If extra_string isn't useful, set it to NULL. */
9002 if (extra_string
!= NULL
&& *extra_string
== '\0')
9003 extra_string
= NULL
;
9007 ops
->create_sals_from_location_spec (locspec
, &canonical
);
9009 catch (const gdb_exception_error
&e
)
9011 /* If caller is interested in rc value from parse, set
9013 if (e
.error
== NOT_FOUND_ERROR
)
9015 /* If pending breakpoint support is turned off, throw
9018 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9021 exception_print (gdb_stderr
, e
);
9023 /* If pending breakpoint support is auto query and the user
9024 selects no, then simply return the error code. */
9025 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9026 && !nquery (_("Make %s pending on future shared library load? "),
9027 bptype_string (type_wanted
)))
9030 /* At this point, either the user was queried about setting
9031 a pending breakpoint and selected yes, or pending
9032 breakpoint behavior is on and thus a pending breakpoint
9033 is defaulted on behalf of the user. */
9040 if (!pending
&& canonical
.lsals
.empty ())
9043 /* Resolve all line numbers to PC's and verify that the addresses
9044 are ok for the target. */
9047 for (auto &lsal
: canonical
.lsals
)
9048 breakpoint_sals_to_pc (lsal
.sals
);
9051 /* Fast tracepoints may have additional restrictions on location. */
9052 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9054 for (const auto &lsal
: canonical
.lsals
)
9055 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9058 /* Verify that condition can be parsed, before setting any
9059 breakpoints. Allocate a separate condition expression for each
9063 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9064 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9068 gdb::unique_xmalloc_ptr
<char> rest
;
9069 gdb::unique_xmalloc_ptr
<char> cond
;
9071 const linespec_sals
&lsal
= canonical
.lsals
[0];
9073 find_condition_and_thread_for_sals (lsal
.sals
, extra_string
,
9074 &cond
, &thread
, &task
, &rest
);
9075 cond_string_copy
= std::move (cond
);
9076 extra_string_copy
= std::move (rest
);
9080 if (type_wanted
!= bp_dprintf
9081 && extra_string
!= NULL
&& *extra_string
!= '\0')
9082 error (_("Garbage '%s' at end of location"), extra_string
);
9084 /* Check the validity of the condition. We should error out
9085 if the condition is invalid at all of the locations and
9086 if it is not forced. In the PARSE_EXTRA case above, this
9087 check is done when parsing the EXTRA_STRING. */
9088 if (cond_string
!= nullptr && !force_condition
)
9090 int num_failures
= 0;
9091 const linespec_sals
&lsal
= canonical
.lsals
[0];
9092 for (const auto &sal
: lsal
.sals
)
9094 const char *cond
= cond_string
;
9097 parse_exp_1 (&cond
, sal
.pc
, block_for_pc (sal
.pc
), 0);
9098 /* One success is sufficient to keep going. */
9101 catch (const gdb_exception_error
&)
9104 /* If this is the last sal, error out. */
9105 if (num_failures
== lsal
.sals
.size ())
9111 /* Create a private copy of condition string. */
9113 cond_string_copy
.reset (xstrdup (cond_string
));
9114 /* Create a private copy of any extra string. */
9116 extra_string_copy
.reset (xstrdup (extra_string
));
9119 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9120 std::move (cond_string_copy
),
9121 std::move (extra_string_copy
),
9123 tempflag
? disp_del
: disp_donttouch
,
9124 thread
, task
, ignore_count
,
9125 from_tty
, enabled
, internal
, flags
);
9129 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (gdbarch
,
9131 b
->locspec
= locspec
->clone ();
9134 b
->cond_string
= NULL
;
9137 /* Create a private copy of condition string. */
9138 b
->cond_string
.reset (cond_string
!= NULL
9139 ? xstrdup (cond_string
)
9144 /* Create a private copy of any extra string. */
9145 b
->extra_string
.reset (extra_string
!= NULL
9146 ? xstrdup (extra_string
)
9148 b
->ignore_count
= ignore_count
;
9149 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9150 b
->condition_not_parsed
= 1;
9151 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9152 if ((type_wanted
!= bp_breakpoint
9153 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9154 b
->pspace
= current_program_space
;
9156 install_breakpoint (internal
, std::move (b
), 0);
9159 if (canonical
.lsals
.size () > 1)
9161 warning (_("Multiple breakpoints were set.\nUse the "
9162 "\"delete\" command to delete unwanted breakpoints."));
9163 prev_breakpoint_count
= prev_bkpt_count
;
9166 update_global_location_list (UGLL_MAY_INSERT
);
9171 /* Set a breakpoint.
9172 ARG is a string describing breakpoint address,
9173 condition, and thread.
9174 FLAG specifies if a breakpoint is hardware on,
9175 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9179 break_command_1 (const char *arg
, int flag
, int from_tty
)
9181 int tempflag
= flag
& BP_TEMPFLAG
;
9182 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9183 ? bp_hardware_breakpoint
9186 location_spec_up locspec
= string_to_location_spec (&arg
, current_language
);
9187 const struct breakpoint_ops
*ops
9188 = breakpoint_ops_for_location_spec (locspec
.get (),
9189 false /* is_tracepoint */);
9191 create_breakpoint (get_current_arch (),
9193 NULL
, 0, arg
, false, 1 /* parse arg */,
9194 tempflag
, type_wanted
,
9195 0 /* Ignore count */,
9196 pending_break_support
,
9204 /* Helper function for break_command_1 and disassemble_command. */
9207 resolve_sal_pc (struct symtab_and_line
*sal
)
9211 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9213 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9214 error (_("No line %d in file \"%s\"."),
9215 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9218 /* If this SAL corresponds to a breakpoint inserted using a line
9219 number, then skip the function prologue if necessary. */
9220 if (sal
->explicit_line
)
9221 skip_prologue_sal (sal
);
9224 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9226 const struct blockvector
*bv
;
9227 const struct block
*b
;
9230 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9231 sal
->symtab
->compunit ());
9234 sym
= block_linkage_function (b
);
9237 = sym
->obj_section (sal
->symtab
->compunit ()->objfile ());
9240 /* It really is worthwhile to have the section, so we'll
9241 just have to look harder. This case can be executed
9242 if we have line numbers but no functions (as can
9243 happen in assembly source). */
9245 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9246 switch_to_program_space_and_thread (sal
->pspace
);
9248 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9250 sal
->section
= msym
.obj_section ();
9257 break_command (const char *arg
, int from_tty
)
9259 break_command_1 (arg
, 0, from_tty
);
9263 tbreak_command (const char *arg
, int from_tty
)
9265 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9269 hbreak_command (const char *arg
, int from_tty
)
9271 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9275 thbreak_command (const char *arg
, int from_tty
)
9277 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9280 /* The dynamic printf command is mostly like a regular breakpoint, but
9281 with a prewired command list consisting of a single output command,
9282 built from extra arguments supplied on the dprintf command
9286 dprintf_command (const char *arg
, int from_tty
)
9288 location_spec_up locspec
= string_to_location_spec (&arg
, current_language
);
9290 /* If non-NULL, ARG should have been advanced past the location;
9291 the next character must be ','. */
9294 if (arg
[0] != ',' || arg
[1] == '\0')
9295 error (_("Format string required"));
9298 /* Skip the comma. */
9303 create_breakpoint (get_current_arch (),
9305 NULL
, 0, arg
, false, 1 /* parse arg */,
9307 0 /* Ignore count */,
9308 pending_break_support
,
9309 &code_breakpoint_ops
,
9317 agent_printf_command (const char *arg
, int from_tty
)
9319 error (_("May only run agent-printf on the target"));
9322 /* Implement the "breakpoint_hit" method for ranged breakpoints. */
9325 ranged_breakpoint::breakpoint_hit (const struct bp_location
*bl
,
9326 const address_space
*aspace
,
9328 const target_waitstatus
&ws
)
9330 if (ws
.kind () != TARGET_WAITKIND_STOPPED
9331 || ws
.sig () != GDB_SIGNAL_TRAP
)
9334 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9335 bl
->length
, aspace
, bp_addr
);
9338 /* Implement the "resources_needed" method for ranged breakpoints. */
9341 ranged_breakpoint::resources_needed (const struct bp_location
*bl
)
9343 return target_ranged_break_num_registers ();
9346 /* Implement the "print_it" method for ranged breakpoints. */
9348 enum print_stop_action
9349 ranged_breakpoint::print_it (const bpstat
*bs
) const
9351 struct bp_location
*bl
= loc
;
9352 struct ui_out
*uiout
= current_uiout
;
9354 gdb_assert (type
== bp_hardware_breakpoint
);
9356 /* Ranged breakpoints have only one location. */
9357 gdb_assert (bl
&& bl
->next
== NULL
);
9359 annotate_breakpoint (number
);
9361 maybe_print_thread_hit_breakpoint (uiout
);
9363 if (disposition
== disp_del
)
9364 uiout
->text ("Temporary ranged breakpoint ");
9366 uiout
->text ("Ranged breakpoint ");
9367 if (uiout
->is_mi_like_p ())
9369 uiout
->field_string ("reason",
9370 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9371 uiout
->field_string ("disp", bpdisp_text (disposition
));
9373 print_num_locno (bs
, uiout
);
9376 return PRINT_SRC_AND_LOC
;
9379 /* Implement the "print_one" method for ranged breakpoints. */
9382 ranged_breakpoint::print_one (bp_location
**last_loc
) const
9384 struct bp_location
*bl
= loc
;
9385 struct value_print_options opts
;
9386 struct ui_out
*uiout
= current_uiout
;
9388 /* Ranged breakpoints have only one location. */
9389 gdb_assert (bl
&& bl
->next
== NULL
);
9391 get_user_print_options (&opts
);
9393 if (opts
.addressprint
)
9394 /* We don't print the address range here, it will be printed later
9395 by ranged_breakpoint::print_one_detail. */
9396 uiout
->field_skip ("addr");
9398 print_breakpoint_location (this, bl
);
9404 /* Implement the "print_one_detail" method for ranged breakpoints. */
9407 ranged_breakpoint::print_one_detail (struct ui_out
*uiout
) const
9409 CORE_ADDR address_start
, address_end
;
9410 struct bp_location
*bl
= loc
;
9415 address_start
= bl
->address
;
9416 address_end
= address_start
+ bl
->length
- 1;
9418 uiout
->text ("\taddress range: ");
9419 stb
.printf ("[%s, %s]",
9420 print_core_address (bl
->gdbarch
, address_start
),
9421 print_core_address (bl
->gdbarch
, address_end
));
9422 uiout
->field_stream ("addr", stb
);
9426 /* Implement the "print_mention" method for ranged breakpoints. */
9429 ranged_breakpoint::print_mention () const
9431 struct bp_location
*bl
= loc
;
9432 struct ui_out
*uiout
= current_uiout
;
9435 gdb_assert (type
== bp_hardware_breakpoint
);
9437 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9438 number
, paddress (bl
->gdbarch
, bl
->address
),
9439 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9442 /* Implement the "print_recreate" method for ranged breakpoints. */
9445 ranged_breakpoint::print_recreate (struct ui_file
*fp
) const
9447 gdb_printf (fp
, "break-range %s, %s",
9448 locspec
->to_string (),
9449 locspec_range_end
->to_string ());
9450 print_recreate_thread (fp
);
9453 /* Find the address where the end of the breakpoint range should be
9454 placed, given the SAL of the end of the range. This is so that if
9455 the user provides a line number, the end of the range is set to the
9456 last instruction of the given line. */
9459 find_breakpoint_range_end (struct symtab_and_line sal
)
9463 /* If the user provided a PC value, use it. Otherwise,
9464 find the address of the end of the given location. */
9465 if (sal
.explicit_pc
)
9472 ret
= find_line_pc_range (sal
, &start
, &end
);
9474 error (_("Could not find location of the end of the range."));
9476 /* find_line_pc_range returns the start of the next line. */
9483 /* Implement the "break-range" CLI command. */
9486 break_range_command (const char *arg
, int from_tty
)
9488 const char *arg_start
;
9489 struct linespec_result canonical_start
, canonical_end
;
9490 int bp_count
, can_use_bp
, length
;
9493 /* We don't support software ranged breakpoints. */
9494 if (target_ranged_break_num_registers () < 0)
9495 error (_("This target does not support hardware ranged breakpoints."));
9497 bp_count
= hw_breakpoint_used_count ();
9498 bp_count
+= target_ranged_break_num_registers ();
9499 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9502 error (_("Hardware breakpoints used exceeds limit."));
9504 arg
= skip_spaces (arg
);
9505 if (arg
== NULL
|| arg
[0] == '\0')
9506 error(_("No address range specified."));
9509 location_spec_up start_locspec
9510 = string_to_location_spec (&arg
, current_language
);
9511 parse_breakpoint_sals (start_locspec
.get (), &canonical_start
);
9514 error (_("Too few arguments."));
9515 else if (canonical_start
.lsals
.empty ())
9516 error (_("Could not find location of the beginning of the range."));
9518 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
9520 if (canonical_start
.lsals
.size () > 1
9521 || lsal_start
.sals
.size () != 1)
9522 error (_("Cannot create a ranged breakpoint with multiple locations."));
9524 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
9525 std::string
addr_string_start (arg_start
, arg
- arg_start
);
9527 arg
++; /* Skip the comma. */
9528 arg
= skip_spaces (arg
);
9530 /* Parse the end location specification. */
9534 /* We call decode_line_full directly here instead of using
9535 parse_breakpoint_sals because we need to specify the start
9536 location spec's symtab and line as the default symtab and line
9537 for the end of the range. This makes it possible to have ranges
9538 like "foo.c:27, +14", where +14 means 14 lines from the start
9540 location_spec_up end_locspec
9541 = string_to_location_spec (&arg
, current_language
);
9542 decode_line_full (end_locspec
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
9543 sal_start
.symtab
, sal_start
.line
,
9544 &canonical_end
, NULL
, NULL
);
9546 if (canonical_end
.lsals
.empty ())
9547 error (_("Could not find location of the end of the range."));
9549 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
9550 if (canonical_end
.lsals
.size () > 1
9551 || lsal_end
.sals
.size () != 1)
9552 error (_("Cannot create a ranged breakpoint with multiple locations."));
9554 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
9556 end
= find_breakpoint_range_end (sal_end
);
9557 if (sal_start
.pc
> end
)
9558 error (_("Invalid address range, end precedes start."));
9560 length
= end
- sal_start
.pc
+ 1;
9562 /* Length overflowed. */
9563 error (_("Address range too large."));
9564 else if (length
== 1)
9566 /* This range is simple enough to be handled by
9567 the `hbreak' command. */
9568 hbreak_command (&addr_string_start
[0], 1);
9573 /* Now set up the breakpoint and install it. */
9575 std::unique_ptr
<breakpoint
> br
9576 (new ranged_breakpoint (get_current_arch (),
9578 std::move (start_locspec
),
9579 std::move (end_locspec
)));
9581 install_breakpoint (false, std::move (br
), true);
9584 /* Return non-zero if EXP is verified as constant. Returned zero
9585 means EXP is variable. Also the constant detection may fail for
9586 some constant expressions and in such case still falsely return
9590 watchpoint_exp_is_const (const struct expression
*exp
)
9592 return exp
->op
->constant_p ();
9595 /* Implement the "re_set" method for watchpoints. */
9598 watchpoint::re_set ()
9600 /* Watchpoint can be either on expression using entirely global
9601 variables, or it can be on local variables.
9603 Watchpoints of the first kind are never auto-deleted, and even
9604 persist across program restarts. Since they can use variables
9605 from shared libraries, we need to reparse expression as libraries
9606 are loaded and unloaded.
9608 Watchpoints on local variables can also change meaning as result
9609 of solib event. For example, if a watchpoint uses both a local
9610 and a global variables in expression, it's a local watchpoint,
9611 but unloading of a shared library will make the expression
9612 invalid. This is not a very common use case, but we still
9613 re-evaluate expression, to avoid surprises to the user.
9615 Note that for local watchpoints, we re-evaluate it only if
9616 watchpoints frame id is still valid. If it's not, it means the
9617 watchpoint is out of scope and will be deleted soon. In fact,
9618 I'm not sure we'll ever be called in this case.
9620 If a local watchpoint's frame id is still valid, then
9621 exp_valid_block is likewise valid, and we can safely use it.
9623 Don't do anything about disabled watchpoints, since they will be
9624 reevaluated again when enabled. */
9625 update_watchpoint (this, true /* reparse */);
9628 /* Implement the "insert" method for hardware watchpoints. */
9631 watchpoint::insert_location (struct bp_location
*bl
)
9633 int length
= exact
? 1 : bl
->length
;
9635 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
9639 /* Implement the "remove" method for hardware watchpoints. */
9642 watchpoint::remove_location (struct bp_location
*bl
,
9643 enum remove_bp_reason reason
)
9645 int length
= exact
? 1 : bl
->length
;
9647 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
9652 watchpoint::breakpoint_hit (const struct bp_location
*bl
,
9653 const address_space
*aspace
, CORE_ADDR bp_addr
,
9654 const target_waitstatus
&ws
)
9656 struct breakpoint
*b
= bl
->owner
;
9658 /* Continuable hardware watchpoints are treated as non-existent if the
9659 reason we stopped wasn't a hardware watchpoint (we didn't stop on
9660 some data address). Otherwise gdb won't stop on a break instruction
9661 in the code (not from a breakpoint) when a hardware watchpoint has
9662 been defined. Also skip watchpoints which we know did not trigger
9663 (did not match the data address). */
9664 if (is_hardware_watchpoint (b
)
9665 && watchpoint_triggered
== watch_triggered_no
)
9672 watchpoint::check_status (bpstat
*bs
)
9674 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
9676 bpstat_check_watchpoint (bs
);
9679 /* Implement the "resources_needed" method for hardware
9683 watchpoint::resources_needed (const struct bp_location
*bl
)
9685 int length
= exact
? 1 : bl
->length
;
9687 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
9690 /* Implement the "works_in_software_mode" method for hardware
9694 watchpoint::works_in_software_mode () const
9696 /* Read and access watchpoints only work with hardware support. */
9697 return type
== bp_watchpoint
|| type
== bp_hardware_watchpoint
;
9700 enum print_stop_action
9701 watchpoint::print_it (const bpstat
*bs
) const
9703 struct breakpoint
*b
;
9704 enum print_stop_action result
;
9705 struct ui_out
*uiout
= current_uiout
;
9707 gdb_assert (bs
->bp_location_at
!= NULL
);
9709 b
= bs
->breakpoint_at
;
9711 annotate_watchpoint (b
->number
);
9712 maybe_print_thread_hit_breakpoint (uiout
);
9716 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
9720 case bp_hardware_watchpoint
:
9721 if (uiout
->is_mi_like_p ())
9723 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
9725 tuple_emitter
.emplace (uiout
, "value");
9726 uiout
->text ("\nOld value = ");
9727 watchpoint_value_print (bs
->old_val
.get (), &stb
);
9728 uiout
->field_stream ("old", stb
);
9729 uiout
->text ("\nNew value = ");
9730 watchpoint_value_print (val
.get (), &stb
);
9731 uiout
->field_stream ("new", stb
);
9733 /* More than one watchpoint may have been triggered. */
9734 result
= PRINT_UNKNOWN
;
9737 case bp_read_watchpoint
:
9738 if (uiout
->is_mi_like_p ())
9740 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
9742 tuple_emitter
.emplace (uiout
, "value");
9743 uiout
->text ("\nValue = ");
9744 watchpoint_value_print (val
.get (), &stb
);
9745 uiout
->field_stream ("value", stb
);
9747 result
= PRINT_UNKNOWN
;
9750 case bp_access_watchpoint
:
9751 if (bs
->old_val
!= NULL
)
9753 if (uiout
->is_mi_like_p ())
9756 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9758 tuple_emitter
.emplace (uiout
, "value");
9759 uiout
->text ("\nOld value = ");
9760 watchpoint_value_print (bs
->old_val
.get (), &stb
);
9761 uiout
->field_stream ("old", stb
);
9762 uiout
->text ("\nNew value = ");
9767 if (uiout
->is_mi_like_p ())
9770 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9771 tuple_emitter
.emplace (uiout
, "value");
9772 uiout
->text ("\nValue = ");
9774 watchpoint_value_print (val
.get (), &stb
);
9775 uiout
->field_stream ("new", stb
);
9777 result
= PRINT_UNKNOWN
;
9780 result
= PRINT_UNKNOWN
;
9786 /* Implement the "print_mention" method for hardware watchpoints. */
9789 watchpoint::print_mention () const
9791 struct ui_out
*uiout
= current_uiout
;
9792 const char *tuple_name
;
9797 uiout
->text ("Watchpoint ");
9800 case bp_hardware_watchpoint
:
9801 uiout
->text ("Hardware watchpoint ");
9804 case bp_read_watchpoint
:
9805 uiout
->text ("Hardware read watchpoint ");
9806 tuple_name
= "hw-rwpt";
9808 case bp_access_watchpoint
:
9809 uiout
->text ("Hardware access (read/write) watchpoint ");
9810 tuple_name
= "hw-awpt";
9813 internal_error (_("Invalid hardware watchpoint type."));
9816 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
9817 uiout
->field_signed ("number", number
);
9819 uiout
->field_string ("exp", exp_string
.get ());
9822 /* Implement the "print_recreate" method for watchpoints. */
9825 watchpoint::print_recreate (struct ui_file
*fp
) const
9830 case bp_hardware_watchpoint
:
9831 gdb_printf (fp
, "watch");
9833 case bp_read_watchpoint
:
9834 gdb_printf (fp
, "rwatch");
9836 case bp_access_watchpoint
:
9837 gdb_printf (fp
, "awatch");
9840 internal_error (_("Invalid watchpoint type."));
9843 gdb_printf (fp
, " %s", exp_string
.get ());
9844 print_recreate_thread (fp
);
9847 /* Implement the "explains_signal" method for watchpoints. */
9850 watchpoint::explains_signal (enum gdb_signal sig
)
9852 /* A software watchpoint cannot cause a signal other than
9854 if (type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
9860 struct masked_watchpoint
: public watchpoint
9862 using watchpoint::watchpoint
;
9864 int insert_location (struct bp_location
*) override
;
9865 int remove_location (struct bp_location
*,
9866 enum remove_bp_reason reason
) override
;
9867 int resources_needed (const struct bp_location
*) override
;
9868 bool works_in_software_mode () const override
;
9869 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
9870 void print_one_detail (struct ui_out
*) const override
;
9871 void print_mention () const override
;
9872 void print_recreate (struct ui_file
*fp
) const override
;
9875 /* Implement the "insert" method for masked hardware watchpoints. */
9878 masked_watchpoint::insert_location (struct bp_location
*bl
)
9880 return target_insert_mask_watchpoint (bl
->address
, hw_wp_mask
,
9881 bl
->watchpoint_type
);
9884 /* Implement the "remove" method for masked hardware watchpoints. */
9887 masked_watchpoint::remove_location (struct bp_location
*bl
,
9888 enum remove_bp_reason reason
)
9890 return target_remove_mask_watchpoint (bl
->address
, hw_wp_mask
,
9891 bl
->watchpoint_type
);
9894 /* Implement the "resources_needed" method for masked hardware
9898 masked_watchpoint::resources_needed (const struct bp_location
*bl
)
9900 return target_masked_watch_num_registers (bl
->address
, hw_wp_mask
);
9903 /* Implement the "works_in_software_mode" method for masked hardware
9907 masked_watchpoint::works_in_software_mode () const
9912 /* Implement the "print_it" method for masked hardware
9915 enum print_stop_action
9916 masked_watchpoint::print_it (const bpstat
*bs
) const
9918 struct breakpoint
*b
= bs
->breakpoint_at
;
9919 struct ui_out
*uiout
= current_uiout
;
9921 /* Masked watchpoints have only one location. */
9922 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
9924 annotate_watchpoint (b
->number
);
9925 maybe_print_thread_hit_breakpoint (uiout
);
9929 case bp_hardware_watchpoint
:
9930 if (uiout
->is_mi_like_p ())
9932 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
9935 case bp_read_watchpoint
:
9936 if (uiout
->is_mi_like_p ())
9938 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
9941 case bp_access_watchpoint
:
9942 if (uiout
->is_mi_like_p ())
9945 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9948 internal_error (_("Invalid hardware watchpoint type."));
9953 Check the underlying instruction at PC for the memory\n\
9954 address and value which triggered this watchpoint.\n"));
9957 /* More than one watchpoint may have been triggered. */
9958 return PRINT_UNKNOWN
;
9961 /* Implement the "print_one_detail" method for masked hardware
9965 masked_watchpoint::print_one_detail (struct ui_out
*uiout
) const
9967 /* Masked watchpoints have only one location. */
9968 gdb_assert (loc
&& loc
->next
== NULL
);
9970 uiout
->text ("\tmask ");
9971 uiout
->field_core_addr ("mask", loc
->gdbarch
, hw_wp_mask
);
9975 /* Implement the "print_mention" method for masked hardware
9979 masked_watchpoint::print_mention () const
9981 struct ui_out
*uiout
= current_uiout
;
9982 const char *tuple_name
;
9986 case bp_hardware_watchpoint
:
9987 uiout
->text ("Masked hardware watchpoint ");
9990 case bp_read_watchpoint
:
9991 uiout
->text ("Masked hardware read watchpoint ");
9992 tuple_name
= "hw-rwpt";
9994 case bp_access_watchpoint
:
9995 uiout
->text ("Masked hardware access (read/write) watchpoint ");
9996 tuple_name
= "hw-awpt";
9999 internal_error (_("Invalid hardware watchpoint type."));
10002 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10003 uiout
->field_signed ("number", number
);
10004 uiout
->text (": ");
10005 uiout
->field_string ("exp", exp_string
.get ());
10008 /* Implement the "print_recreate" method for masked hardware
10012 masked_watchpoint::print_recreate (struct ui_file
*fp
) const
10016 case bp_hardware_watchpoint
:
10017 gdb_printf (fp
, "watch");
10019 case bp_read_watchpoint
:
10020 gdb_printf (fp
, "rwatch");
10022 case bp_access_watchpoint
:
10023 gdb_printf (fp
, "awatch");
10026 internal_error (_("Invalid hardware watchpoint type."));
10029 gdb_printf (fp
, " %s mask 0x%s", exp_string
.get (),
10030 phex (hw_wp_mask
, sizeof (CORE_ADDR
)));
10031 print_recreate_thread (fp
);
10034 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10037 is_masked_watchpoint (const struct breakpoint
*b
)
10039 return dynamic_cast<const masked_watchpoint
*> (b
) != nullptr;
10042 /* accessflag: hw_write: watch write,
10043 hw_read: watch read,
10044 hw_access: watch access (read or write) */
10046 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10047 bool just_location
, bool internal
)
10049 struct breakpoint
*scope_breakpoint
= NULL
;
10050 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10051 struct value
*result
;
10052 int saved_bitpos
= 0, saved_bitsize
= 0;
10053 const char *exp_start
= NULL
;
10054 const char *exp_end
= NULL
;
10055 const char *tok
, *end_tok
;
10057 const char *cond_start
= NULL
;
10058 const char *cond_end
= NULL
;
10059 enum bptype bp_type
;
10061 /* Flag to indicate whether we are going to use masks for
10062 the hardware watchpoint. */
10063 bool use_mask
= false;
10064 CORE_ADDR mask
= 0;
10067 /* Make sure that we actually have parameters to parse. */
10068 if (arg
!= NULL
&& arg
[0] != '\0')
10070 const char *value_start
;
10072 exp_end
= arg
+ strlen (arg
);
10074 /* Look for "parameter value" pairs at the end
10075 of the arguments string. */
10076 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10078 /* Skip whitespace at the end of the argument list. */
10079 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10082 /* Find the beginning of the last token.
10083 This is the value of the parameter. */
10084 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10086 value_start
= tok
+ 1;
10088 /* Skip whitespace. */
10089 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10094 /* Find the beginning of the second to last token.
10095 This is the parameter itself. */
10096 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10099 toklen
= end_tok
- tok
+ 1;
10101 if (toklen
== 6 && startswith (tok
, "thread"))
10103 struct thread_info
*thr
;
10104 /* At this point we've found a "thread" token, which means
10105 the user is trying to set a watchpoint that triggers
10106 only in a specific thread. */
10110 error(_("You can specify only one thread."));
10113 error (_("You can specify only one of thread or task."));
10115 /* Extract the thread ID from the next token. */
10116 thr
= parse_thread_id (value_start
, &endp
);
10118 /* Check if the user provided a valid thread ID. */
10119 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10120 invalid_thread_id_error (value_start
);
10122 thread
= thr
->global_num
;
10124 else if (toklen
== 4 && startswith (tok
, "task"))
10129 error(_("You can specify only one task."));
10132 error (_("You can specify only one of thread or task."));
10134 task
= strtol (value_start
, &tmp
, 0);
10135 if (tmp
== value_start
)
10136 error (_("Junk after task keyword."));
10137 if (!valid_task_id (task
))
10138 error (_("Unknown task %d."), task
);
10140 else if (toklen
== 4 && startswith (tok
, "mask"))
10142 /* We've found a "mask" token, which means the user wants to
10143 create a hardware watchpoint that is going to have the mask
10145 struct value
*mask_value
;
10148 error(_("You can specify only one mask."));
10150 use_mask
= just_location
= true;
10152 scoped_value_mark mark
;
10153 mask_value
= parse_to_comma_and_eval (&value_start
);
10154 mask
= value_as_address (mask_value
);
10157 /* We didn't recognize what we found. We should stop here. */
10160 /* Truncate the string and get rid of the "parameter value" pair before
10161 the arguments string is parsed by the parse_exp_1 function. */
10168 /* Parse the rest of the arguments. From here on out, everything
10169 is in terms of a newly allocated string instead of the original
10171 std::string
expression (arg
, exp_end
- arg
);
10172 exp_start
= arg
= expression
.c_str ();
10173 innermost_block_tracker tracker
;
10174 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10176 /* Remove trailing whitespace from the expression before saving it.
10177 This makes the eventual display of the expression string a bit
10179 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10182 /* Checking if the expression is not constant. */
10183 if (watchpoint_exp_is_const (exp
.get ()))
10187 len
= exp_end
- exp_start
;
10188 while (len
> 0 && isspace (exp_start
[len
- 1]))
10190 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10193 exp_valid_block
= tracker
.block ();
10194 struct value
*mark
= value_mark ();
10195 struct value
*val_as_value
= nullptr;
10196 fetch_subexp_value (exp
.get (), exp
->op
.get (), &val_as_value
, &result
, NULL
,
10199 if (val_as_value
!= NULL
&& just_location
)
10201 saved_bitpos
= val_as_value
->bitpos ();
10202 saved_bitsize
= val_as_value
->bitsize ();
10210 exp_valid_block
= NULL
;
10211 val
= release_value (value_addr (result
));
10212 value_free_to_mark (mark
);
10216 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10219 error (_("This target does not support masked watchpoints."));
10220 else if (ret
== -2)
10221 error (_("Invalid mask or memory region."));
10224 else if (val_as_value
!= NULL
)
10225 val
= release_value (val_as_value
);
10227 tok
= skip_spaces (arg
);
10228 end_tok
= skip_to_space (tok
);
10230 toklen
= end_tok
- tok
;
10231 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10233 tok
= cond_start
= end_tok
+ 1;
10234 innermost_block_tracker if_tracker
;
10235 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10237 /* The watchpoint expression may not be local, but the condition
10238 may still be. E.g.: `watch global if local > 0'. */
10239 cond_exp_valid_block
= if_tracker
.block ();
10244 error (_("Junk at end of command."));
10246 frame_info_ptr wp_frame
= block_innermost_frame (exp_valid_block
);
10248 /* Save this because create_internal_breakpoint below invalidates
10250 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10252 /* If the expression is "local", then set up a "watchpoint scope"
10253 breakpoint at the point where we've left the scope of the watchpoint
10254 expression. Create the scope breakpoint before the watchpoint, so
10255 that we will encounter it first in bpstat_stop_status. */
10256 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10258 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10260 if (frame_id_p (caller_frame_id
))
10262 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10263 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10266 = create_internal_breakpoint (caller_arch
, caller_pc
,
10267 bp_watchpoint_scope
);
10269 /* create_internal_breakpoint could invalidate WP_FRAME. */
10272 scope_breakpoint
->enable_state
= bp_enabled
;
10274 /* Automatically delete the breakpoint when it hits. */
10275 scope_breakpoint
->disposition
= disp_del
;
10277 /* Only break in the proper frame (help with recursion). */
10278 scope_breakpoint
->frame_id
= caller_frame_id
;
10280 /* Set the address at which we will stop. */
10281 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10282 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10283 scope_breakpoint
->loc
->address
10284 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10285 scope_breakpoint
->loc
->requested_address
,
10286 scope_breakpoint
->type
,
10287 current_program_space
);
10291 /* Now set up the breakpoint. We create all watchpoints as hardware
10292 watchpoints here even if hardware watchpoints are turned off, a call
10293 to update_watchpoint later in this function will cause the type to
10294 drop back to bp_watchpoint (software watchpoint) if required. */
10296 if (accessflag
== hw_read
)
10297 bp_type
= bp_read_watchpoint
;
10298 else if (accessflag
== hw_access
)
10299 bp_type
= bp_access_watchpoint
;
10301 bp_type
= bp_hardware_watchpoint
;
10303 std::unique_ptr
<watchpoint
> w
;
10305 w
.reset (new masked_watchpoint (nullptr, bp_type
));
10307 w
.reset (new watchpoint (nullptr, bp_type
));
10309 /* At most one of thread or task can be set on a watchpoint. */
10310 gdb_assert (thread
== -1 || task
== -1);
10311 w
->thread
= thread
;
10313 w
->disposition
= disp_donttouch
;
10314 w
->pspace
= current_program_space
;
10315 w
->exp
= std::move (exp
);
10316 w
->exp_valid_block
= exp_valid_block
;
10317 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10320 struct type
*t
= val
.get ()->type ();
10321 CORE_ADDR addr
= value_as_address (val
.get ());
10323 w
->exp_string_reparse
10324 = current_language
->watch_location_expression (t
, addr
);
10326 w
->exp_string
= xstrprintf ("-location %.*s",
10327 (int) (exp_end
- exp_start
), exp_start
);
10330 w
->exp_string
.reset (savestring (exp_start
, exp_end
- exp_start
));
10334 w
->hw_wp_mask
= mask
;
10339 w
->val_bitpos
= saved_bitpos
;
10340 w
->val_bitsize
= saved_bitsize
;
10341 w
->val_valid
= true;
10345 w
->cond_string
.reset (savestring (cond_start
, cond_end
- cond_start
));
10347 w
->cond_string
= 0;
10349 if (frame_id_p (watchpoint_frame
))
10351 w
->watchpoint_frame
= watchpoint_frame
;
10352 w
->watchpoint_thread
= inferior_ptid
;
10356 w
->watchpoint_frame
= null_frame_id
;
10357 w
->watchpoint_thread
= null_ptid
;
10360 if (scope_breakpoint
!= NULL
)
10362 /* The scope breakpoint is related to the watchpoint. We will
10363 need to act on them together. */
10364 w
->related_breakpoint
= scope_breakpoint
;
10365 scope_breakpoint
->related_breakpoint
= w
.get ();
10368 if (!just_location
)
10369 value_free_to_mark (mark
);
10371 /* Finally update the new watchpoint. This creates the locations
10372 that should be inserted. */
10373 update_watchpoint (w
.get (), true /* reparse */);
10375 install_breakpoint (internal
, std::move (w
), 1);
10378 /* Return count of debug registers needed to watch the given expression.
10379 If the watchpoint cannot be handled in hardware return zero. */
10382 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
10384 int found_memory_cnt
= 0;
10386 /* Did the user specifically forbid us to use hardware watchpoints? */
10387 if (!can_use_hw_watchpoints
)
10390 gdb_assert (!vals
.empty ());
10391 struct value
*head
= vals
[0].get ();
10393 /* Make sure that the value of the expression depends only upon
10394 memory contents, and values computed from them within GDB. If we
10395 find any register references or function calls, we can't use a
10396 hardware watchpoint.
10398 The idea here is that evaluating an expression generates a series
10399 of values, one holding the value of every subexpression. (The
10400 expression a*b+c has five subexpressions: a, b, a*b, c, and
10401 a*b+c.) GDB's values hold almost enough information to establish
10402 the criteria given above --- they identify memory lvalues,
10403 register lvalues, computed values, etcetera. So we can evaluate
10404 the expression, and then scan the chain of values that leaves
10405 behind to decide whether we can detect any possible change to the
10406 expression's final value using only hardware watchpoints.
10408 However, I don't think that the values returned by inferior
10409 function calls are special in any way. So this function may not
10410 notice that an expression involving an inferior function call
10411 can't be watched with hardware watchpoints. FIXME. */
10412 for (const value_ref_ptr
&iter
: vals
)
10414 struct value
*v
= iter
.get ();
10416 if (VALUE_LVAL (v
) == lval_memory
)
10418 if (v
!= head
&& value_lazy (v
))
10419 /* A lazy memory lvalue in the chain is one that GDB never
10420 needed to fetch; we either just used its address (e.g.,
10421 `a' in `a.b') or we never needed it at all (e.g., `a'
10422 in `a,b'). This doesn't apply to HEAD; if that is
10423 lazy then it was not readable, but watch it anyway. */
10427 /* Ahh, memory we actually used! Check if we can cover
10428 it with hardware watchpoints. */
10429 struct type
*vtype
= check_typedef (v
->type ());
10431 /* We only watch structs and arrays if user asked for it
10432 explicitly, never if they just happen to appear in a
10433 middle of some value chain. */
10435 || (vtype
->code () != TYPE_CODE_STRUCT
10436 && vtype
->code () != TYPE_CODE_ARRAY
))
10438 CORE_ADDR vaddr
= value_address (v
);
10442 len
= (target_exact_watchpoints
10443 && is_scalar_type_recursive (vtype
))?
10444 1 : v
->type ()->length ();
10446 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10450 found_memory_cnt
+= num_regs
;
10454 else if (VALUE_LVAL (v
) != not_lval
10455 && v
->deprecated_modifiable () == 0)
10456 return 0; /* These are values from the history (e.g., $1). */
10457 else if (VALUE_LVAL (v
) == lval_register
)
10458 return 0; /* Cannot watch a register with a HW watchpoint. */
10461 /* The expression itself looks suitable for using a hardware
10462 watchpoint, but give the target machine a chance to reject it. */
10463 return found_memory_cnt
;
10467 watch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10469 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
10472 /* Options for the watch, awatch, and rwatch commands. */
10474 struct watch_options
10476 /* For -location. */
10477 bool location
= false;
10480 /* Definitions of options for the "watch", "awatch", and "rwatch" commands.
10482 Historically GDB always accepted both '-location' and '-l' flags for
10483 these commands (both flags being synonyms). When converting to the
10484 newer option scheme only '-location' is added here. That's fine (for
10485 backward compatibility) as any non-ambiguous prefix of a flag will be
10486 accepted, so '-l', '-loc', are now all accepted.
10488 What this means is that, if in the future, we add any new flag here
10489 that starts with '-l' then this will break backward compatibility, so
10490 please, don't do that! */
10492 static const gdb::option::option_def watch_option_defs
[] = {
10493 gdb::option::flag_option_def
<watch_options
> {
10495 [] (watch_options
*opt
) { return &opt
->location
; },
10497 This evaluates EXPRESSION and watches the memory to which is refers.\n\
10498 -l can be used as a short form of -location."),
10502 /* Returns the option group used by 'watch', 'awatch', and 'rwatch'
10505 static gdb::option::option_def_group
10506 make_watch_options_def_group (watch_options
*opts
)
10508 return {{watch_option_defs
}, opts
};
10511 /* A helper function that looks for the "-location" argument and then
10512 calls watch_command_1. */
10515 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
10517 watch_options opts
;
10518 auto grp
= make_watch_options_def_group (&opts
);
10519 gdb::option::process_options
10520 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
10521 if (arg
!= nullptr && *arg
== '\0')
10524 watch_command_1 (arg
, accessflag
, from_tty
, opts
.location
, false);
10527 /* Command completion for 'watch', 'awatch', and 'rwatch' commands. */
10529 watch_command_completer (struct cmd_list_element
*ignore
,
10530 completion_tracker
&tracker
,
10531 const char *text
, const char * /*word*/)
10533 const auto group
= make_watch_options_def_group (nullptr);
10534 if (gdb::option::complete_options
10535 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
10538 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
10539 expression_completer (ignore
, tracker
, text
, word
);
10543 watch_command (const char *arg
, int from_tty
)
10545 watch_maybe_just_location (arg
, hw_write
, from_tty
);
10549 rwatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10551 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
10555 rwatch_command (const char *arg
, int from_tty
)
10557 watch_maybe_just_location (arg
, hw_read
, from_tty
);
10561 awatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10563 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
10567 awatch_command (const char *arg
, int from_tty
)
10569 watch_maybe_just_location (arg
, hw_access
, from_tty
);
10573 /* Data for the FSM that manages the until(location)/advance commands
10574 in infcmd.c. Here because it uses the mechanisms of
10577 struct until_break_fsm
: public thread_fsm
10579 /* The thread that was current when the command was executed. */
10582 /* The breakpoint set at the return address in the caller frame,
10583 plus breakpoints at all the destination locations. */
10584 std::vector
<breakpoint_up
> breakpoints
;
10586 until_break_fsm (struct interp
*cmd_interp
, int thread
,
10587 std::vector
<breakpoint_up
> &&breakpoints
)
10588 : thread_fsm (cmd_interp
),
10590 breakpoints (std::move (breakpoints
))
10594 void clean_up (struct thread_info
*thread
) override
;
10595 bool should_stop (struct thread_info
*thread
) override
;
10596 enum async_reply_reason
do_async_reply_reason () override
;
10599 /* Implementation of the 'should_stop' FSM method for the
10600 until(location)/advance commands. */
10603 until_break_fsm::should_stop (struct thread_info
*tp
)
10605 for (const breakpoint_up
&bp
: breakpoints
)
10606 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
10607 bp
.get ()) != NULL
)
10616 /* Implementation of the 'clean_up' FSM method for the
10617 until(location)/advance commands. */
10620 until_break_fsm::clean_up (struct thread_info
*)
10622 /* Clean up our temporary breakpoints. */
10623 breakpoints
.clear ();
10624 delete_longjmp_breakpoint (thread
);
10627 /* Implementation of the 'async_reply_reason' FSM method for the
10628 until(location)/advance commands. */
10630 enum async_reply_reason
10631 until_break_fsm::do_async_reply_reason ()
10633 return EXEC_ASYNC_LOCATION_REACHED
;
10637 until_break_command (const char *arg
, int from_tty
, int anywhere
)
10639 frame_info_ptr frame
;
10640 struct gdbarch
*frame_gdbarch
;
10641 struct frame_id stack_frame_id
;
10642 struct frame_id caller_frame_id
;
10644 struct thread_info
*tp
;
10646 clear_proceed_status (0);
10648 /* Set a breakpoint where the user wants it and at return from
10651 location_spec_up locspec
= string_to_location_spec (&arg
, current_language
);
10653 std::vector
<symtab_and_line
> sals
10654 = (last_displayed_sal_is_valid ()
10655 ? decode_line_1 (locspec
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10656 get_last_displayed_symtab (),
10657 get_last_displayed_line ())
10658 : decode_line_1 (locspec
.get (), DECODE_LINE_FUNFIRSTLINE
,
10662 error (_("Couldn't get information on specified line."));
10665 error (_("Junk at end of arguments."));
10667 tp
= inferior_thread ();
10668 thread
= tp
->global_num
;
10670 /* Note linespec handling above invalidates the frame chain.
10671 Installing a breakpoint also invalidates the frame chain (as it
10672 may need to switch threads), so do any frame handling before
10675 frame
= get_selected_frame (NULL
);
10676 frame_gdbarch
= get_frame_arch (frame
);
10677 stack_frame_id
= get_stack_frame_id (frame
);
10678 caller_frame_id
= frame_unwind_caller_id (frame
);
10680 /* Keep within the current frame, or in frames called by the current
10683 std::vector
<breakpoint_up
> breakpoints
;
10685 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
10687 if (frame_id_p (caller_frame_id
))
10689 struct symtab_and_line sal2
;
10690 struct gdbarch
*caller_gdbarch
;
10692 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
10693 sal2
.pc
= frame_unwind_caller_pc (frame
);
10694 caller_gdbarch
= frame_unwind_caller_arch (frame
);
10696 breakpoint_up caller_breakpoint
10697 = set_momentary_breakpoint (caller_gdbarch
, sal2
,
10698 caller_frame_id
, bp_until
);
10699 breakpoints
.emplace_back (std::move (caller_breakpoint
));
10701 set_longjmp_breakpoint (tp
, stack_frame_id
);
10702 lj_deleter
.emplace (thread
);
10705 /* set_momentary_breakpoint could invalidate FRAME. */
10708 /* If the user told us to continue until a specified location, we
10709 don't specify a frame at which we need to stop. Otherwise,
10710 specify the selected frame, because we want to stop only at the
10711 very same frame. */
10712 frame_id stop_frame_id
= anywhere
? null_frame_id
: stack_frame_id
;
10714 for (symtab_and_line
&sal
: sals
)
10716 resolve_sal_pc (&sal
);
10718 breakpoint_up location_breakpoint
10719 = set_momentary_breakpoint (frame_gdbarch
, sal
,
10720 stop_frame_id
, bp_until
);
10721 breakpoints
.emplace_back (std::move (location_breakpoint
));
10725 (std::unique_ptr
<thread_fsm
>
10726 (new until_break_fsm (command_interp (), tp
->global_num
,
10727 std::move (breakpoints
))));
10730 lj_deleter
->release ();
10732 proceed (-1, GDB_SIGNAL_DEFAULT
);
10737 /* Compare two breakpoints and return a strcmp-like result. */
10740 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
10742 uintptr_t ua
= (uintptr_t) a
;
10743 uintptr_t ub
= (uintptr_t) b
;
10745 if (a
->number
< b
->number
)
10747 else if (a
->number
> b
->number
)
10750 /* Now sort by address, in case we see, e..g, two breakpoints with
10754 return ua
> ub
? 1 : 0;
10757 /* Delete breakpoints by address or line. */
10760 clear_command (const char *arg
, int from_tty
)
10764 std::vector
<symtab_and_line
> decoded_sals
;
10765 symtab_and_line last_sal
;
10766 gdb::array_view
<symtab_and_line
> sals
;
10770 = decode_line_with_current_source (arg
,
10771 (DECODE_LINE_FUNFIRSTLINE
10772 | DECODE_LINE_LIST_MODE
));
10774 sals
= decoded_sals
;
10778 /* Set sal's line, symtab, pc, and pspace to the values
10779 corresponding to the last call to print_frame_info. If the
10780 codepoint is not valid, this will set all the fields to 0. */
10781 last_sal
= get_last_displayed_sal ();
10782 if (last_sal
.symtab
== 0)
10783 error (_("No source file specified."));
10789 /* We don't call resolve_sal_pc here. That's not as bad as it
10790 seems, because all existing breakpoints typically have both
10791 file/line and pc set. So, if clear is given file/line, we can
10792 match this to existing breakpoint without obtaining pc at all.
10794 We only support clearing given the address explicitly
10795 present in breakpoint table. Say, we've set breakpoint
10796 at file:line. There were several PC values for that file:line,
10797 due to optimization, all in one block.
10799 We've picked one PC value. If "clear" is issued with another
10800 PC corresponding to the same file:line, the breakpoint won't
10801 be cleared. We probably can still clear the breakpoint, but
10802 since the other PC value is never presented to user, user
10803 can only find it by guessing, and it does not seem important
10804 to support that. */
10806 /* For each line spec given, delete bps which correspond to it. Do
10807 it in two passes, solely to preserve the current behavior that
10808 from_tty is forced true if we delete more than one
10811 std::vector
<struct breakpoint
*> found
;
10812 for (const auto &sal
: sals
)
10814 const char *sal_fullname
;
10816 /* If exact pc given, clear bpts at that pc.
10817 If line given (pc == 0), clear all bpts on specified line.
10818 If defaulting, clear all bpts on default line
10821 defaulting sal.pc != 0 tests to do
10826 1 0 <can't happen> */
10828 sal_fullname
= (sal
.symtab
== NULL
10829 ? NULL
: symtab_to_fullname (sal
.symtab
));
10831 /* Find all matching breakpoints and add them to 'found'. */
10832 for (breakpoint
*b
: all_breakpoints ())
10835 /* Are we going to delete b? */
10836 if (b
->type
!= bp_none
&& !is_watchpoint (b
)
10837 && user_breakpoint_p (b
))
10839 for (bp_location
*loc
: b
->locations ())
10841 /* If the user specified file:line, don't allow a PC
10842 match. This matches historical gdb behavior. */
10843 int pc_match
= (!sal
.explicit_line
10845 && (loc
->pspace
== sal
.pspace
)
10846 && (loc
->address
== sal
.pc
)
10847 && (!section_is_overlay (loc
->section
)
10848 || loc
->section
== sal
.section
));
10849 int line_match
= 0;
10851 if ((default_match
|| sal
.explicit_line
)
10852 && loc
->symtab
!= NULL
10853 && sal_fullname
!= NULL
10854 && sal
.pspace
== loc
->pspace
10855 && loc
->line_number
== sal
.line
10856 && filename_cmp (symtab_to_fullname (loc
->symtab
),
10857 sal_fullname
) == 0)
10860 if (pc_match
|| line_match
)
10869 found
.push_back (b
);
10873 /* Now go thru the 'found' chain and delete them. */
10874 if (found
.empty ())
10877 error (_("No breakpoint at %s."), arg
);
10879 error (_("No breakpoint at this line."));
10882 /* Remove duplicates from the vec. */
10883 std::sort (found
.begin (), found
.end (),
10884 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
10886 return compare_breakpoints (bp_a
, bp_b
) < 0;
10888 found
.erase (std::unique (found
.begin (), found
.end (),
10889 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
10891 return compare_breakpoints (bp_a
, bp_b
) == 0;
10895 if (found
.size () > 1)
10896 from_tty
= 1; /* Always report if deleted more than one. */
10899 if (found
.size () == 1)
10900 gdb_printf (_("Deleted breakpoint "));
10902 gdb_printf (_("Deleted breakpoints "));
10905 for (breakpoint
*iter
: found
)
10908 gdb_printf ("%d ", iter
->number
);
10909 delete_breakpoint (iter
);
10915 /* Delete breakpoint in BS if they are `delete' breakpoints and
10916 all breakpoints that are marked for deletion, whether hit or not.
10917 This is called after any breakpoint is hit, or after errors. */
10920 breakpoint_auto_delete (bpstat
*bs
)
10922 for (; bs
; bs
= bs
->next
)
10923 if (bs
->breakpoint_at
10924 && bs
->breakpoint_at
->disposition
== disp_del
10926 delete_breakpoint (bs
->breakpoint_at
);
10928 for (breakpoint
*b
: all_breakpoints_safe ())
10929 if (b
->disposition
== disp_del_at_next_stop
)
10930 delete_breakpoint (b
);
10933 /* A comparison function for bp_location AP and BP being interfaced to
10934 std::sort. Sort elements primarily by their ADDRESS (no matter what
10935 bl_address_is_meaningful says), secondarily by ordering first
10936 permanent elements and terciarily just ensuring the array is sorted
10937 stable way despite std::sort being an unstable algorithm. */
10940 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
10942 if (a
->address
!= b
->address
)
10943 return a
->address
< b
->address
;
10945 /* Sort locations at the same address by their pspace number, keeping
10946 locations of the same inferior (in a multi-inferior environment)
10949 if (a
->pspace
->num
!= b
->pspace
->num
)
10950 return a
->pspace
->num
< b
->pspace
->num
;
10952 /* Sort permanent breakpoints first. */
10953 if (a
->permanent
!= b
->permanent
)
10954 return a
->permanent
> b
->permanent
;
10956 /* Sort by type in order to make duplicate determination easier.
10957 See update_global_location_list. This is kept in sync with
10958 breakpoint_locations_match. */
10959 if (a
->loc_type
< b
->loc_type
)
10962 /* Likewise, for range-breakpoints, sort by length. */
10963 if (a
->loc_type
== bp_loc_hardware_breakpoint
10964 && b
->loc_type
== bp_loc_hardware_breakpoint
10965 && a
->length
< b
->length
)
10968 /* Make the internal GDB representation stable across GDB runs
10969 where A and B memory inside GDB can differ. Breakpoint locations of
10970 the same type at the same address can be sorted in arbitrary order. */
10972 if (a
->owner
->number
!= b
->owner
->number
)
10973 return a
->owner
->number
< b
->owner
->number
;
10978 /* Set bp_locations_placed_address_before_address_max and
10979 bp_locations_shadow_len_after_address_max according to the current
10980 content of the bp_locations array. */
10983 bp_locations_target_extensions_update (void)
10985 bp_locations_placed_address_before_address_max
= 0;
10986 bp_locations_shadow_len_after_address_max
= 0;
10988 for (bp_location
*bl
: all_bp_locations ())
10990 CORE_ADDR start
, end
, addr
;
10992 if (!bp_location_has_shadow (bl
))
10995 start
= bl
->target_info
.placed_address
;
10996 end
= start
+ bl
->target_info
.shadow_len
;
10998 gdb_assert (bl
->address
>= start
);
10999 addr
= bl
->address
- start
;
11000 if (addr
> bp_locations_placed_address_before_address_max
)
11001 bp_locations_placed_address_before_address_max
= addr
;
11003 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11005 gdb_assert (bl
->address
< end
);
11006 addr
= end
- bl
->address
;
11007 if (addr
> bp_locations_shadow_len_after_address_max
)
11008 bp_locations_shadow_len_after_address_max
= addr
;
11012 /* Download tracepoint locations if they haven't been. */
11015 download_tracepoint_locations (void)
11017 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11019 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11021 for (breakpoint
*b
: all_tracepoints ())
11023 struct tracepoint
*t
;
11024 bool bp_location_downloaded
= false;
11026 if ((b
->type
== bp_fast_tracepoint
11027 ? !may_insert_fast_tracepoints
11028 : !may_insert_tracepoints
))
11031 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11033 if (target_can_download_tracepoint ())
11034 can_download_tracepoint
= TRIBOOL_TRUE
;
11036 can_download_tracepoint
= TRIBOOL_FALSE
;
11039 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11042 for (bp_location
*bl
: b
->locations ())
11044 /* In tracepoint, locations are _never_ duplicated, so
11045 should_be_inserted is equivalent to
11046 unduplicated_should_be_inserted. */
11047 if (!should_be_inserted (bl
) || bl
->inserted
)
11050 switch_to_program_space_and_thread (bl
->pspace
);
11052 target_download_tracepoint (bl
);
11055 bp_location_downloaded
= true;
11057 t
= (struct tracepoint
*) b
;
11058 t
->number_on_target
= b
->number
;
11059 if (bp_location_downloaded
)
11060 gdb::observers::breakpoint_modified
.notify (b
);
11064 /* Swap the insertion/duplication state between two locations. */
11067 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11069 const int left_inserted
= left
->inserted
;
11070 const int left_duplicate
= left
->duplicate
;
11071 const int left_needs_update
= left
->needs_update
;
11072 const struct bp_target_info left_target_info
= left
->target_info
;
11074 /* Locations of tracepoints can never be duplicated. */
11075 if (is_tracepoint (left
->owner
))
11076 gdb_assert (!left
->duplicate
);
11077 if (is_tracepoint (right
->owner
))
11078 gdb_assert (!right
->duplicate
);
11080 left
->inserted
= right
->inserted
;
11081 left
->duplicate
= right
->duplicate
;
11082 left
->needs_update
= right
->needs_update
;
11083 left
->target_info
= right
->target_info
;
11084 right
->inserted
= left_inserted
;
11085 right
->duplicate
= left_duplicate
;
11086 right
->needs_update
= left_needs_update
;
11087 right
->target_info
= left_target_info
;
11090 /* Force the re-insertion of the locations at ADDRESS. This is called
11091 once a new/deleted/modified duplicate location is found and we are evaluating
11092 conditions on the target's side. Such conditions need to be updated on
11096 force_breakpoint_reinsertion (struct bp_location
*bl
)
11098 CORE_ADDR address
= 0;
11101 address
= bl
->address
;
11102 pspace_num
= bl
->pspace
->num
;
11104 /* This is only meaningful if the target is
11105 evaluating conditions and if the user has
11106 opted for condition evaluation on the target's
11108 if (gdb_evaluates_breakpoint_condition_p ()
11109 || !target_supports_evaluation_of_breakpoint_conditions ())
11112 /* Flag all breakpoint locations with this address and
11113 the same program space as the location
11114 as "its condition has changed". We need to
11115 update the conditions on the target's side. */
11116 for (bp_location
*loc
: all_bp_locations_at_addr (address
))
11118 if (!is_breakpoint (loc
->owner
)
11119 || pspace_num
!= loc
->pspace
->num
)
11122 /* Flag the location appropriately. We use a different state to
11123 let everyone know that we already updated the set of locations
11124 with addr bl->address and program space bl->pspace. This is so
11125 we don't have to keep calling these functions just to mark locations
11126 that have already been marked. */
11127 loc
->condition_changed
= condition_updated
;
11129 /* Free the agent expression bytecode as well. We will compute
11131 loc
->cond_bytecode
.reset ();
11135 /* Called whether new breakpoints are created, or existing breakpoints
11136 deleted, to update the global location list and recompute which
11137 locations are duplicate of which.
11139 The INSERT_MODE flag determines whether locations may not, may, or
11140 shall be inserted now. See 'enum ugll_insert_mode' for more
11144 update_global_location_list (enum ugll_insert_mode insert_mode
)
11146 /* Last breakpoint location address that was marked for update. */
11147 CORE_ADDR last_addr
= 0;
11148 /* Last breakpoint location program space that was marked for update. */
11149 int last_pspace_num
= -1;
11151 /* Used in the duplicates detection below. When iterating over all
11152 bp_locations, points to the first bp_location of a given address.
11153 Breakpoints and watchpoints of different types are never
11154 duplicates of each other. Keep one pointer for each type of
11155 breakpoint/watchpoint, so we only need to loop over all locations
11157 struct bp_location
*bp_loc_first
; /* breakpoint */
11158 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11159 struct bp_location
*awp_loc_first
; /* access watchpoint */
11160 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11162 /* Saved former bp_locations array which we compare against the newly
11163 built bp_locations from the current state of ALL_BREAKPOINTS. */
11164 std::vector
<bp_location
*> old_locations
= std::move (bp_locations
);
11165 bp_locations
.clear ();
11167 for (breakpoint
*b
: all_breakpoints ())
11168 for (bp_location
*loc
: b
->locations ())
11169 bp_locations
.push_back (loc
);
11171 /* See if we need to "upgrade" a software breakpoint to a hardware
11172 breakpoint. Do this before deciding whether locations are
11173 duplicates. Also do this before sorting because sorting order
11174 depends on location type. */
11175 for (bp_location
*loc
: bp_locations
)
11176 if (!loc
->inserted
&& should_be_inserted (loc
))
11177 handle_automatic_hardware_breakpoints (loc
);
11179 std::sort (bp_locations
.begin (), bp_locations
.end (),
11180 bp_location_is_less_than
);
11182 bp_locations_target_extensions_update ();
11184 /* Identify bp_location instances that are no longer present in the
11185 new list, and therefore should be freed. Note that it's not
11186 necessary that those locations should be removed from inferior --
11187 if there's another location at the same address (previously
11188 marked as duplicate), we don't need to remove/insert the
11191 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11192 and former bp_location array state respectively. */
11195 for (bp_location
*old_loc
: old_locations
)
11197 /* Tells if 'old_loc' is found among the new locations. If
11198 not, we have to free it. */
11199 bool found_object
= false;
11200 /* Tells if the location should remain inserted in the target. */
11201 bool keep_in_target
= false;
11202 bool removed
= false;
11204 /* Skip LOCP entries which will definitely never be needed.
11205 Stop either at or being the one matching OLD_LOC. */
11206 while (loc_i
< bp_locations
.size ()
11207 && bp_locations
[loc_i
]->address
< old_loc
->address
)
11210 for (size_t loc2_i
= loc_i
;
11211 (loc2_i
< bp_locations
.size ()
11212 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11215 /* Check if this is a new/duplicated location or a duplicated
11216 location that had its condition modified. If so, we want to send
11217 its condition to the target if evaluation of conditions is taking
11219 if (bp_locations
[loc2_i
]->condition_changed
== condition_modified
11220 && (last_addr
!= old_loc
->address
11221 || last_pspace_num
!= old_loc
->pspace
->num
))
11223 force_breakpoint_reinsertion (bp_locations
[loc2_i
]);
11224 last_pspace_num
= old_loc
->pspace
->num
;
11227 if (bp_locations
[loc2_i
] == old_loc
)
11228 found_object
= true;
11231 /* We have already handled this address, update it so that we don't
11232 have to go through updates again. */
11233 last_addr
= old_loc
->address
;
11235 /* Target-side condition evaluation: Handle deleted locations. */
11237 force_breakpoint_reinsertion (old_loc
);
11239 /* If this location is no longer present, and inserted, look if
11240 there's maybe a new location at the same address. If so,
11241 mark that one inserted, and don't remove this one. This is
11242 needed so that we don't have a time window where a breakpoint
11243 at certain location is not inserted. */
11245 if (old_loc
->inserted
)
11247 /* If the location is inserted now, we might have to remove
11250 if (found_object
&& should_be_inserted (old_loc
))
11252 /* The location is still present in the location list,
11253 and still should be inserted. Don't do anything. */
11254 keep_in_target
= true;
11258 /* This location still exists, but it won't be kept in the
11259 target since it may have been disabled. We proceed to
11260 remove its target-side condition. */
11262 /* The location is either no longer present, or got
11263 disabled. See if there's another location at the
11264 same address, in which case we don't need to remove
11265 this one from the target. */
11267 /* OLD_LOC comes from existing struct breakpoint. */
11268 if (bl_address_is_meaningful (old_loc
))
11270 for (size_t loc2_i
= loc_i
;
11271 (loc2_i
< bp_locations
.size ()
11272 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11275 bp_location
*loc2
= bp_locations
[loc2_i
];
11277 if (loc2
== old_loc
)
11280 if (breakpoint_locations_match (loc2
, old_loc
))
11282 /* Read watchpoint locations are switched to
11283 access watchpoints, if the former are not
11284 supported, but the latter are. */
11285 if (is_hardware_watchpoint (old_loc
->owner
))
11287 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11288 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11291 /* loc2 is a duplicated location. We need to check
11292 if it should be inserted in case it will be
11294 if (unduplicated_should_be_inserted (loc2
))
11296 swap_insertion (old_loc
, loc2
);
11297 keep_in_target
= true;
11305 if (!keep_in_target
)
11307 if (remove_breakpoint (old_loc
))
11309 /* This is just about all we can do. We could keep
11310 this location on the global list, and try to
11311 remove it next time, but there's no particular
11312 reason why we will succeed next time.
11314 Note that at this point, old_loc->owner is still
11315 valid, as delete_breakpoint frees the breakpoint
11316 only after calling us. */
11317 gdb_printf (_("warning: Error removing "
11318 "breakpoint %d\n"),
11319 old_loc
->owner
->number
);
11327 if (removed
&& target_is_non_stop_p ()
11328 && need_moribund_for_location_type (old_loc
))
11330 /* This location was removed from the target. In
11331 non-stop mode, a race condition is possible where
11332 we've removed a breakpoint, but stop events for that
11333 breakpoint are already queued and will arrive later.
11334 We apply an heuristic to be able to distinguish such
11335 SIGTRAPs from other random SIGTRAPs: we keep this
11336 breakpoint location for a bit, and will retire it
11337 after we see some number of events. The theory here
11338 is that reporting of events should, "on the average",
11339 be fair, so after a while we'll see events from all
11340 threads that have anything of interest, and no longer
11341 need to keep this breakpoint location around. We
11342 don't hold locations forever so to reduce chances of
11343 mistaking a non-breakpoint SIGTRAP for a breakpoint
11346 The heuristic failing can be disastrous on
11347 decr_pc_after_break targets.
11349 On decr_pc_after_break targets, like e.g., x86-linux,
11350 if we fail to recognize a late breakpoint SIGTRAP,
11351 because events_till_retirement has reached 0 too
11352 soon, we'll fail to do the PC adjustment, and report
11353 a random SIGTRAP to the user. When the user resumes
11354 the inferior, it will most likely immediately crash
11355 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
11356 corrupted, because of being resumed e.g., in the
11357 middle of a multi-byte instruction, or skipped a
11358 one-byte instruction. This was actually seen happen
11359 on native x86-linux, and should be less rare on
11360 targets that do not support new thread events, like
11361 remote, due to the heuristic depending on
11364 Mistaking a random SIGTRAP for a breakpoint trap
11365 causes similar symptoms (PC adjustment applied when
11366 it shouldn't), but then again, playing with SIGTRAPs
11367 behind the debugger's back is asking for trouble.
11369 Since hardware watchpoint traps are always
11370 distinguishable from other traps, so we don't need to
11371 apply keep hardware watchpoint moribund locations
11372 around. We simply always ignore hardware watchpoint
11373 traps we can no longer explain. */
11375 process_stratum_target
*proc_target
= nullptr;
11376 for (inferior
*inf
: all_inferiors ())
11377 if (inf
->pspace
== old_loc
->pspace
)
11379 proc_target
= inf
->process_target ();
11382 if (proc_target
!= nullptr)
11383 old_loc
->events_till_retirement
11384 = 3 * (thread_count (proc_target
) + 1);
11386 old_loc
->events_till_retirement
= 1;
11387 old_loc
->owner
= NULL
;
11389 moribund_locations
.push_back (old_loc
);
11393 old_loc
->owner
= NULL
;
11394 decref_bp_location (&old_loc
);
11399 /* Rescan breakpoints at the same address and section, marking the
11400 first one as "first" and any others as "duplicates". This is so
11401 that the bpt instruction is only inserted once. If we have a
11402 permanent breakpoint at the same place as BPT, make that one the
11403 official one, and the rest as duplicates. Permanent breakpoints
11404 are sorted first for the same address.
11406 Do the same for hardware watchpoints, but also considering the
11407 watchpoint's type (regular/access/read) and length. */
11409 bp_loc_first
= NULL
;
11410 wp_loc_first
= NULL
;
11411 awp_loc_first
= NULL
;
11412 rwp_loc_first
= NULL
;
11414 for (bp_location
*loc
: all_bp_locations ())
11416 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
11418 struct bp_location
**loc_first_p
;
11419 breakpoint
*b
= loc
->owner
;
11421 if (!unduplicated_should_be_inserted (loc
)
11422 || !bl_address_is_meaningful (loc
)
11423 /* Don't detect duplicate for tracepoint locations because they are
11424 never duplicated. See the comments in field `duplicate' of
11425 `struct bp_location'. */
11426 || is_tracepoint (b
))
11428 /* Clear the condition modification flag. */
11429 loc
->condition_changed
= condition_unchanged
;
11433 if (b
->type
== bp_hardware_watchpoint
)
11434 loc_first_p
= &wp_loc_first
;
11435 else if (b
->type
== bp_read_watchpoint
)
11436 loc_first_p
= &rwp_loc_first
;
11437 else if (b
->type
== bp_access_watchpoint
)
11438 loc_first_p
= &awp_loc_first
;
11440 loc_first_p
= &bp_loc_first
;
11442 if (*loc_first_p
== NULL
11443 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
11444 || !breakpoint_locations_match (loc
, *loc_first_p
))
11446 *loc_first_p
= loc
;
11447 loc
->duplicate
= 0;
11449 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
11451 loc
->needs_update
= 1;
11452 /* Clear the condition modification flag. */
11453 loc
->condition_changed
= condition_unchanged
;
11459 /* This and the above ensure the invariant that the first location
11460 is not duplicated, and is the inserted one.
11461 All following are marked as duplicated, and are not inserted. */
11463 swap_insertion (loc
, *loc_first_p
);
11464 loc
->duplicate
= 1;
11466 /* Clear the condition modification flag. */
11467 loc
->condition_changed
= condition_unchanged
;
11470 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
11472 if (insert_mode
!= UGLL_DONT_INSERT
)
11473 insert_breakpoint_locations ();
11476 /* Even though the caller told us to not insert new
11477 locations, we may still need to update conditions on the
11478 target's side of breakpoints that were already inserted
11479 if the target is evaluating breakpoint conditions. We
11480 only update conditions for locations that are marked
11482 update_inserted_breakpoint_locations ();
11486 if (insert_mode
!= UGLL_DONT_INSERT
)
11487 download_tracepoint_locations ();
11491 breakpoint_retire_moribund (void)
11493 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
11495 struct bp_location
*loc
= moribund_locations
[ix
];
11496 if (--(loc
->events_till_retirement
) == 0)
11498 decref_bp_location (&loc
);
11499 unordered_remove (moribund_locations
, ix
);
11506 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
11511 update_global_location_list (insert_mode
);
11513 catch (const gdb_exception_error
&e
)
11518 /* Clear BKP from a BPS. */
11521 bpstat_remove_bp_location (bpstat
*bps
, struct breakpoint
*bpt
)
11525 for (bs
= bps
; bs
; bs
= bs
->next
)
11526 if (bs
->breakpoint_at
== bpt
)
11528 bs
->breakpoint_at
= NULL
;
11529 bs
->old_val
= NULL
;
11530 /* bs->commands will be freed later. */
11534 /* Callback for iterate_over_threads. */
11536 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
11538 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
11540 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
11544 /* See breakpoint.h. */
11547 code_breakpoint::say_where () const
11549 struct value_print_options opts
;
11551 get_user_print_options (&opts
);
11553 /* i18n: cagney/2005-02-11: Below needs to be merged into a
11557 /* For pending locations, the output differs slightly based
11558 on extra_string. If this is non-NULL, it contains either
11559 a condition or dprintf arguments. */
11560 if (extra_string
== NULL
)
11562 gdb_printf (_(" (%s) pending."), locspec
->to_string ());
11564 else if (type
== bp_dprintf
)
11566 gdb_printf (_(" (%s,%s) pending."),
11567 locspec
->to_string (),
11568 extra_string
.get ());
11572 gdb_printf (_(" (%s %s) pending."),
11573 locspec
->to_string (),
11574 extra_string
.get ());
11579 if (opts
.addressprint
|| loc
->symtab
== NULL
)
11580 gdb_printf (" at %ps",
11581 styled_string (address_style
.style (),
11582 paddress (loc
->gdbarch
,
11584 if (loc
->symtab
!= NULL
)
11586 /* If there is a single location, we can print the location
11588 if (loc
->next
== NULL
)
11590 const char *filename
11591 = symtab_to_filename_for_display (loc
->symtab
);
11592 gdb_printf (": file %ps, line %d.",
11593 styled_string (file_name_style
.style (),
11598 /* This is not ideal, but each location may have a
11599 different file name, and this at least reflects the
11600 real situation somewhat. */
11601 gdb_printf (": %s.", locspec
->to_string ());
11606 struct bp_location
*iter
= loc
;
11608 for (; iter
; iter
= iter
->next
)
11610 gdb_printf (" (%d locations)", n
);
11615 /* See breakpoint.h. */
11617 bp_location_range
breakpoint::locations () const
11619 return bp_location_range (this->loc
);
11622 struct bp_location
*
11623 breakpoint::allocate_location ()
11625 return new bp_location (this);
11628 #define internal_error_pure_virtual_called() \
11629 gdb_assert_not_reached ("pure virtual function called")
11632 breakpoint::insert_location (struct bp_location
*bl
)
11634 internal_error_pure_virtual_called ();
11638 breakpoint::remove_location (struct bp_location
*bl
,
11639 enum remove_bp_reason reason
)
11641 internal_error_pure_virtual_called ();
11645 breakpoint::breakpoint_hit (const struct bp_location
*bl
,
11646 const address_space
*aspace
,
11648 const target_waitstatus
&ws
)
11650 internal_error_pure_virtual_called ();
11654 breakpoint::resources_needed (const struct bp_location
*bl
)
11656 internal_error_pure_virtual_called ();
11659 enum print_stop_action
11660 breakpoint::print_it (const bpstat
*bs
) const
11662 internal_error_pure_virtual_called ();
11666 breakpoint::print_mention () const
11668 internal_error_pure_virtual_called ();
11672 breakpoint::print_recreate (struct ui_file
*fp
) const
11674 internal_error_pure_virtual_called ();
11677 /* Default breakpoint_ops methods. */
11680 code_breakpoint::re_set ()
11682 /* FIXME: is this still reachable? */
11683 if (breakpoint_location_spec_empty_p (this))
11685 /* Anything without a location can't be re-set. */
11686 delete_breakpoint (this);
11694 code_breakpoint::insert_location (struct bp_location
*bl
)
11696 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
11698 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
11699 bl
->target_info
.placed_address
= addr
;
11702 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11703 result
= target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11705 result
= target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11707 if (result
== 0 && bl
->probe
.prob
!= nullptr)
11709 /* The insertion was successful, now let's set the probe's semaphore
11711 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
11718 code_breakpoint::remove_location (struct bp_location
*bl
,
11719 enum remove_bp_reason reason
)
11721 if (bl
->probe
.prob
!= nullptr)
11723 /* Let's clear the semaphore before removing the location. */
11724 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
11727 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11728 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11730 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
11734 code_breakpoint::breakpoint_hit (const struct bp_location
*bl
,
11735 const address_space
*aspace
,
11737 const target_waitstatus
&ws
)
11739 if (ws
.kind () != TARGET_WAITKIND_STOPPED
11740 || ws
.sig () != GDB_SIGNAL_TRAP
)
11743 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
11747 if (overlay_debugging
/* unmapped overlay section */
11748 && section_is_overlay (bl
->section
)
11749 && !section_is_mapped (bl
->section
))
11756 dprintf_breakpoint::breakpoint_hit (const struct bp_location
*bl
,
11757 const address_space
*aspace
,
11759 const target_waitstatus
&ws
)
11761 if (dprintf_style
== dprintf_style_agent
11762 && target_can_run_breakpoint_commands ())
11764 /* An agent-style dprintf never causes a stop. If we see a trap
11765 for this address it must be for a breakpoint that happens to
11766 be set at the same address. */
11770 return this->ordinary_breakpoint::breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
11774 ordinary_breakpoint::resources_needed (const struct bp_location
*bl
)
11776 gdb_assert (type
== bp_hardware_breakpoint
);
11781 enum print_stop_action
11782 ordinary_breakpoint::print_it (const bpstat
*bs
) const
11784 const struct bp_location
*bl
;
11786 struct ui_out
*uiout
= current_uiout
;
11788 bl
= bs
->bp_location_at
.get ();
11790 bp_temp
= disposition
== disp_del
;
11791 if (bl
->address
!= bl
->requested_address
)
11792 breakpoint_adjustment_warning (bl
->requested_address
,
11795 annotate_breakpoint (number
);
11796 maybe_print_thread_hit_breakpoint (uiout
);
11798 if (uiout
->is_mi_like_p ())
11800 uiout
->field_string ("reason",
11801 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
11802 uiout
->field_string ("disp", bpdisp_text (disposition
));
11806 uiout
->text ("Temporary breakpoint ");
11808 uiout
->text ("Breakpoint ");
11809 print_num_locno (bs
, uiout
);
11810 uiout
->text (", ");
11812 return PRINT_SRC_AND_LOC
;
11816 ordinary_breakpoint::print_mention () const
11818 if (current_uiout
->is_mi_like_p ())
11823 case bp_breakpoint
:
11824 case bp_gnu_ifunc_resolver
:
11825 if (disposition
== disp_del
)
11826 gdb_printf (_("Temporary breakpoint"));
11828 gdb_printf (_("Breakpoint"));
11829 gdb_printf (_(" %d"), number
);
11830 if (type
== bp_gnu_ifunc_resolver
)
11831 gdb_printf (_(" at gnu-indirect-function resolver"));
11833 case bp_hardware_breakpoint
:
11834 gdb_printf (_("Hardware assisted breakpoint %d"), number
);
11837 gdb_printf (_("Dprintf %d"), number
);
11845 ordinary_breakpoint::print_recreate (struct ui_file
*fp
) const
11847 if (type
== bp_breakpoint
&& disposition
== disp_del
)
11848 gdb_printf (fp
, "tbreak");
11849 else if (type
== bp_breakpoint
)
11850 gdb_printf (fp
, "break");
11851 else if (type
== bp_hardware_breakpoint
11852 && disposition
== disp_del
)
11853 gdb_printf (fp
, "thbreak");
11854 else if (type
== bp_hardware_breakpoint
)
11855 gdb_printf (fp
, "hbreak");
11857 internal_error (_("unhandled breakpoint type %d"), (int) type
);
11859 gdb_printf (fp
, " %s", locspec
->to_string ());
11861 /* Print out extra_string if this breakpoint is pending. It might
11862 contain, for example, conditions that were set by the user. */
11863 if (loc
== NULL
&& extra_string
!= NULL
)
11864 gdb_printf (fp
, " %s", extra_string
.get ());
11866 print_recreate_thread (fp
);
11869 std::vector
<symtab_and_line
>
11870 code_breakpoint::decode_location_spec (location_spec
*locspec
,
11871 program_space
*search_pspace
)
11873 if (locspec
->type () == PROBE_LOCATION_SPEC
)
11874 return bkpt_probe_decode_location_spec (this, locspec
, search_pspace
);
11876 struct linespec_result canonical
;
11878 decode_line_full (locspec
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
11879 NULL
, 0, &canonical
, multiple_symbols_all
,
11882 /* We should get 0 or 1 resulting SALs. */
11883 gdb_assert (canonical
.lsals
.size () < 2);
11885 if (!canonical
.lsals
.empty ())
11887 const linespec_sals
&lsal
= canonical
.lsals
[0];
11888 return std::move (lsal
.sals
);
11893 /* Virtual table for internal breakpoints. */
11896 internal_breakpoint::re_set ()
11900 /* Delete overlay event and longjmp master breakpoints; they
11901 will be reset later by breakpoint_re_set. */
11902 case bp_overlay_event
:
11903 case bp_longjmp_master
:
11904 case bp_std_terminate_master
:
11905 case bp_exception_master
:
11906 delete_breakpoint (this);
11909 /* This breakpoint is special, it's set up when the inferior
11910 starts and we really don't want to touch it. */
11911 case bp_shlib_event
:
11913 /* Like bp_shlib_event, this breakpoint type is special. Once
11914 it is set up, we do not want to touch it. */
11915 case bp_thread_event
:
11921 internal_breakpoint::check_status (bpstat
*bs
)
11923 if (type
== bp_shlib_event
)
11925 /* If requested, stop when the dynamic linker notifies GDB of
11926 events. This allows the user to get control and place
11927 breakpoints in initializer routines for dynamically loaded
11928 objects (among other things). */
11929 bs
->stop
= stop_on_solib_events
!= 0;
11930 bs
->print
= stop_on_solib_events
!= 0;
11936 enum print_stop_action
11937 internal_breakpoint::print_it (const bpstat
*bs
) const
11941 case bp_shlib_event
:
11942 /* Did we stop because the user set the stop_on_solib_events
11943 variable? (If so, we report this as a generic, "Stopped due
11944 to shlib event" message.) */
11945 print_solib_event (false);
11948 case bp_thread_event
:
11949 /* Not sure how we will get here.
11950 GDB should not stop for these breakpoints. */
11951 gdb_printf (_("Thread Event Breakpoint: gdb should not stop!\n"));
11954 case bp_overlay_event
:
11955 /* By analogy with the thread event, GDB should not stop for these. */
11956 gdb_printf (_("Overlay Event Breakpoint: gdb should not stop!\n"));
11959 case bp_longjmp_master
:
11960 /* These should never be enabled. */
11961 gdb_printf (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
11964 case bp_std_terminate_master
:
11965 /* These should never be enabled. */
11966 gdb_printf (_("std::terminate Master Breakpoint: "
11967 "gdb should not stop!\n"));
11970 case bp_exception_master
:
11971 /* These should never be enabled. */
11972 gdb_printf (_("Exception Master Breakpoint: "
11973 "gdb should not stop!\n"));
11977 return PRINT_NOTHING
;
11981 internal_breakpoint::print_mention () const
11983 /* Nothing to mention. These breakpoints are internal. */
11986 /* Virtual table for momentary breakpoints */
11989 momentary_breakpoint::re_set ()
11991 /* Keep temporary breakpoints, which can be encountered when we step
11992 over a dlopen call and solib_add is resetting the breakpoints.
11993 Otherwise these should have been blown away via the cleanup chain
11994 or by breakpoint_init_inferior when we rerun the executable. */
11998 momentary_breakpoint::check_status (bpstat
*bs
)
12000 /* Nothing. The point of these breakpoints is causing a stop. */
12003 enum print_stop_action
12004 momentary_breakpoint::print_it (const bpstat
*bs
) const
12006 return PRINT_UNKNOWN
;
12010 momentary_breakpoint::print_mention () const
12012 /* Nothing to mention. These breakpoints are internal. */
12015 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12017 It gets cleared already on the removal of the first one of such placed
12018 breakpoints. This is OK as they get all removed altogether. */
12020 longjmp_breakpoint::~longjmp_breakpoint ()
12022 thread_info
*tp
= find_thread_global_id (this->thread
);
12025 tp
->initiating_frame
= null_frame_id
;
12029 bkpt_probe_create_sals_from_location_spec (location_spec
*locspec
,
12030 struct linespec_result
*canonical
)
12033 struct linespec_sals lsal
;
12035 lsal
.sals
= parse_probes (locspec
, NULL
, canonical
);
12036 lsal
.canonical
= xstrdup (canonical
->locspec
->to_string ());
12037 canonical
->lsals
.push_back (std::move (lsal
));
12040 static std::vector
<symtab_and_line
>
12041 bkpt_probe_decode_location_spec (struct breakpoint
*b
,
12042 location_spec
*locspec
,
12043 program_space
*search_pspace
)
12045 std::vector
<symtab_and_line
> sals
12046 = parse_probes (locspec
, search_pspace
, NULL
);
12048 error (_("probe not found"));
12053 tracepoint::breakpoint_hit (const struct bp_location
*bl
,
12054 const address_space
*aspace
, CORE_ADDR bp_addr
,
12055 const target_waitstatus
&ws
)
12057 /* By definition, the inferior does not report stops at
12063 tracepoint::print_one_detail (struct ui_out
*uiout
) const
12065 if (!static_trace_marker_id
.empty ())
12067 gdb_assert (type
== bp_static_tracepoint
12068 || type
== bp_static_marker_tracepoint
);
12070 uiout
->message ("\tmarker id is %pF\n",
12071 string_field ("static-tracepoint-marker-string-id",
12072 static_trace_marker_id
.c_str ()));
12077 tracepoint::print_mention () const
12079 if (current_uiout
->is_mi_like_p ())
12084 case bp_tracepoint
:
12085 gdb_printf (_("Tracepoint"));
12086 gdb_printf (_(" %d"), number
);
12088 case bp_fast_tracepoint
:
12089 gdb_printf (_("Fast tracepoint"));
12090 gdb_printf (_(" %d"), number
);
12092 case bp_static_tracepoint
:
12093 case bp_static_marker_tracepoint
:
12094 gdb_printf (_("Static tracepoint"));
12095 gdb_printf (_(" %d"), number
);
12098 internal_error (_("unhandled tracepoint type %d"), (int) type
);
12105 tracepoint::print_recreate (struct ui_file
*fp
) const
12107 if (type
== bp_fast_tracepoint
)
12108 gdb_printf (fp
, "ftrace");
12109 else if (type
== bp_static_tracepoint
12110 || type
== bp_static_marker_tracepoint
)
12111 gdb_printf (fp
, "strace");
12112 else if (type
== bp_tracepoint
)
12113 gdb_printf (fp
, "trace");
12115 internal_error (_("unhandled tracepoint type %d"), (int) type
);
12117 gdb_printf (fp
, " %s", locspec
->to_string ());
12118 print_recreate_thread (fp
);
12121 gdb_printf (fp
, " passcount %d\n", pass_count
);
12124 /* Virtual table for tracepoints on static probes. */
12127 tracepoint_probe_create_sals_from_location_spec
12128 (location_spec
*locspec
,
12129 struct linespec_result
*canonical
)
12131 /* We use the same method for breakpoint on probes. */
12132 bkpt_probe_create_sals_from_location_spec (locspec
, canonical
);
12136 dprintf_breakpoint::re_set ()
12140 /* extra_string should never be non-NULL for dprintf. */
12141 gdb_assert (extra_string
!= NULL
);
12143 /* 1 - connect to target 1, that can run breakpoint commands.
12144 2 - create a dprintf, which resolves fine.
12145 3 - disconnect from target 1
12146 4 - connect to target 2, that can NOT run breakpoint commands.
12148 After steps #3/#4, you'll want the dprintf command list to
12149 be updated, because target 1 and 2 may well return different
12150 answers for target_can_run_breakpoint_commands().
12151 Given absence of finer grained resetting, we get to do
12152 it all the time. */
12153 if (extra_string
!= NULL
)
12154 update_dprintf_command_list (this);
12157 /* Implement the "print_recreate" method for dprintf. */
12160 dprintf_breakpoint::print_recreate (struct ui_file
*fp
) const
12162 gdb_printf (fp
, "dprintf %s,%s", locspec
->to_string (), extra_string
.get ());
12163 print_recreate_thread (fp
);
12166 /* Implement the "after_condition_true" method for dprintf.
12168 dprintf's are implemented with regular commands in their command
12169 list, but we run the commands here instead of before presenting the
12170 stop to the user, as dprintf's don't actually cause a stop. This
12171 also makes it so that the commands of multiple dprintfs at the same
12172 address are all handled. */
12175 dprintf_breakpoint::after_condition_true (struct bpstat
*bs
)
12177 /* dprintf's never cause a stop. This wasn't set in the
12178 check_status hook instead because that would make the dprintf's
12179 condition not be evaluated. */
12182 /* Run the command list here. Take ownership of it instead of
12183 copying. We never want these commands to run later in
12184 bpstat_do_actions, if a breakpoint that causes a stop happens to
12185 be set at same address as this dprintf, or even if running the
12186 commands here throws. */
12187 counted_command_line cmds
= std::move (bs
->commands
);
12188 gdb_assert (cmds
!= nullptr);
12189 execute_control_commands (cmds
.get (), 0);
12192 /* The breakpoint_ops structure to be used on static tracepoints with
12196 strace_marker_create_sals_from_location_spec (location_spec
*locspec
,
12197 struct linespec_result
*canonical
)
12199 struct linespec_sals lsal
;
12200 const char *arg_start
, *arg
;
12202 arg
= arg_start
= as_linespec_location_spec (locspec
)->spec_string
;
12203 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
12205 std::string
str (arg_start
, arg
- arg_start
);
12206 const char *ptr
= str
.c_str ();
12208 = new_linespec_location_spec (&ptr
, symbol_name_match_type::FULL
);
12210 lsal
.canonical
= xstrdup (canonical
->locspec
->to_string ());
12211 canonical
->lsals
.push_back (std::move (lsal
));
12215 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12216 struct linespec_result
*canonical
,
12217 gdb::unique_xmalloc_ptr
<char> cond_string
,
12218 gdb::unique_xmalloc_ptr
<char> extra_string
,
12219 enum bptype type_wanted
,
12220 enum bpdisp disposition
,
12222 int task
, int ignore_count
,
12223 int from_tty
, int enabled
,
12224 int internal
, unsigned flags
)
12226 const linespec_sals
&lsal
= canonical
->lsals
[0];
12228 /* If the user is creating a static tracepoint by marker id
12229 (strace -m MARKER_ID), then store the sals index, so that
12230 breakpoint_re_set can try to match up which of the newly
12231 found markers corresponds to this one, and, don't try to
12232 expand multiple locations for each sal, given than SALS
12233 already should contain all sals for MARKER_ID. */
12235 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
12237 location_spec_up locspec
= canonical
->locspec
->clone ();
12239 std::unique_ptr
<tracepoint
> tp
12240 (new tracepoint (gdbarch
,
12243 std::move (locspec
),
12245 std::move (cond_string
),
12246 std::move (extra_string
),
12248 thread
, task
, ignore_count
,
12249 from_tty
, enabled
, flags
,
12250 canonical
->special_display
));
12252 /* Given that its possible to have multiple markers with
12253 the same string id, if the user is creating a static
12254 tracepoint by marker id ("strace -m MARKER_ID"), then
12255 store the sals index, so that breakpoint_re_set can
12256 try to match up which of the newly found markers
12257 corresponds to this one */
12258 tp
->static_trace_marker_id_idx
= i
;
12260 install_breakpoint (internal
, std::move (tp
), 0);
12264 std::vector
<symtab_and_line
>
12265 static_marker_tracepoint::decode_location_spec (location_spec
*locspec
,
12266 program_space
*search_pspace
)
12268 const char *s
= as_linespec_location_spec (locspec
)->spec_string
;
12270 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
12271 if (sals
.size () > static_trace_marker_id_idx
)
12273 sals
[0] = sals
[static_trace_marker_id_idx
];
12278 error (_("marker %s not found"), static_trace_marker_id
.c_str ());
12281 /* Static tracepoints with marker (`-m'). */
12282 static struct breakpoint_ops strace_marker_breakpoint_ops
=
12284 strace_marker_create_sals_from_location_spec
,
12285 strace_marker_create_breakpoints_sal
,
12289 strace_marker_p (struct breakpoint
*b
)
12291 return b
->type
== bp_static_marker_tracepoint
;
12294 /* Delete a breakpoint and clean up all traces of it in the data
12298 delete_breakpoint (struct breakpoint
*bpt
)
12300 gdb_assert (bpt
!= NULL
);
12302 /* Has this bp already been deleted? This can happen because
12303 multiple lists can hold pointers to bp's. bpstat lists are
12306 One example of this happening is a watchpoint's scope bp. When
12307 the scope bp triggers, we notice that the watchpoint is out of
12308 scope, and delete it. We also delete its scope bp. But the
12309 scope bp is marked "auto-deleting", and is already on a bpstat.
12310 That bpstat is then checked for auto-deleting bp's, which are
12313 A real solution to this problem might involve reference counts in
12314 bp's, and/or giving them pointers back to their referencing
12315 bpstat's, and teaching delete_breakpoint to only free a bp's
12316 storage when no more references were extent. A cheaper bandaid
12318 if (bpt
->type
== bp_none
)
12321 /* At least avoid this stale reference until the reference counting
12322 of breakpoints gets resolved. */
12323 if (bpt
->related_breakpoint
!= bpt
)
12325 struct breakpoint
*related
;
12326 struct watchpoint
*w
;
12328 if (bpt
->type
== bp_watchpoint_scope
)
12329 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
12330 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
12331 w
= (struct watchpoint
*) bpt
;
12335 watchpoint_del_at_next_stop (w
);
12337 /* Unlink bpt from the bpt->related_breakpoint ring. */
12338 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
12339 related
= related
->related_breakpoint
);
12340 related
->related_breakpoint
= bpt
->related_breakpoint
;
12341 bpt
->related_breakpoint
= bpt
;
12344 /* watch_command_1 creates a watchpoint but only sets its number if
12345 update_watchpoint succeeds in creating its bp_locations. If there's
12346 a problem in that process, we'll be asked to delete the half-created
12347 watchpoint. In that case, don't announce the deletion. */
12349 gdb::observers::breakpoint_deleted
.notify (bpt
);
12351 if (breakpoint_chain
== bpt
)
12352 breakpoint_chain
= bpt
->next
;
12354 for (breakpoint
*b
: all_breakpoints ())
12355 if (b
->next
== bpt
)
12357 b
->next
= bpt
->next
;
12361 /* Be sure no bpstat's are pointing at the breakpoint after it's
12363 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
12364 in all threads for now. Note that we cannot just remove bpstats
12365 pointing at bpt from the stop_bpstat list entirely, as breakpoint
12366 commands are associated with the bpstat; if we remove it here,
12367 then the later call to bpstat_do_actions (&stop_bpstat); in
12368 event-top.c won't do anything, and temporary breakpoints with
12369 commands won't work. */
12371 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
12373 /* Now that breakpoint is removed from breakpoint list, update the
12374 global location list. This will remove locations that used to
12375 belong to this breakpoint. Do this before freeing the breakpoint
12376 itself, since remove_breakpoint looks at location's owner. It
12377 might be better design to have location completely
12378 self-contained, but it's not the case now. */
12379 update_global_location_list (UGLL_DONT_INSERT
);
12381 /* On the chance that someone will soon try again to delete this
12382 same bp, we mark it as deleted before freeing its storage. */
12383 bpt
->type
= bp_none
;
12387 /* Iterator function to call a user-provided callback function once
12388 for each of B and its related breakpoints. */
12391 iterate_over_related_breakpoints (struct breakpoint
*b
,
12392 gdb::function_view
<void (breakpoint
*)> function
)
12394 struct breakpoint
*related
;
12399 struct breakpoint
*next
;
12401 /* FUNCTION may delete RELATED. */
12402 next
= related
->related_breakpoint
;
12404 if (next
== related
)
12406 /* RELATED is the last ring entry. */
12407 function (related
);
12409 /* FUNCTION may have deleted it, so we'd never reach back to
12410 B. There's nothing left to do anyway, so just break
12415 function (related
);
12419 while (related
!= b
);
12423 delete_command (const char *arg
, int from_tty
)
12429 int breaks_to_delete
= 0;
12431 /* Delete all breakpoints if no argument. Do not delete
12432 internal breakpoints, these have to be deleted with an
12433 explicit breakpoint number argument. */
12434 for (breakpoint
*b
: all_breakpoints ())
12435 if (user_breakpoint_p (b
))
12437 breaks_to_delete
= 1;
12441 /* Ask user only if there are some breakpoints to delete. */
12443 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
12444 for (breakpoint
*b
: all_breakpoints_safe ())
12445 if (user_breakpoint_p (b
))
12446 delete_breakpoint (b
);
12449 map_breakpoint_numbers
12450 (arg
, [&] (breakpoint
*br
)
12452 iterate_over_related_breakpoints (br
, delete_breakpoint
);
12456 /* Return true if all locations of B bound to PSPACE are pending. If
12457 PSPACE is NULL, all locations of all program spaces are
12461 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
12463 for (bp_location
*loc
: b
->locations ())
12464 if ((pspace
== NULL
12465 || loc
->pspace
== pspace
)
12466 && !loc
->shlib_disabled
12467 && !loc
->pspace
->executing_startup
)
12472 /* Subroutine of update_breakpoint_locations to simplify it.
12473 Return true if multiple fns in list LOC have the same name.
12474 Null names are ignored. */
12477 ambiguous_names_p (struct bp_location
*loc
)
12479 struct bp_location
*l
;
12480 htab_up
htab (htab_create_alloc (13, htab_hash_string
, htab_eq_string
, NULL
,
12483 for (l
= loc
; l
!= NULL
; l
= l
->next
)
12486 const char *name
= l
->function_name
.get ();
12488 /* Allow for some names to be NULL, ignore them. */
12492 slot
= (const char **) htab_find_slot (htab
.get (), (const void *) name
,
12494 /* NOTE: We can assume slot != NULL here because xcalloc never
12504 /* When symbols change, it probably means the sources changed as well,
12505 and it might mean the static tracepoint markers are no longer at
12506 the same address or line numbers they used to be at last we
12507 checked. Losing your static tracepoints whenever you rebuild is
12508 undesirable. This function tries to resync/rematch gdb static
12509 tracepoints with the markers on the target, for static tracepoints
12510 that have not been set by marker id. Static tracepoint that have
12511 been set by marker id are reset by marker id in breakpoint_re_set.
12514 1) For a tracepoint set at a specific address, look for a marker at
12515 the old PC. If one is found there, assume to be the same marker.
12516 If the name / string id of the marker found is different from the
12517 previous known name, assume that means the user renamed the marker
12518 in the sources, and output a warning.
12520 2) For a tracepoint set at a given line number, look for a marker
12521 at the new address of the old line number. If one is found there,
12522 assume to be the same marker. If the name / string id of the
12523 marker found is different from the previous known name, assume that
12524 means the user renamed the marker in the sources, and output a
12527 3) If a marker is no longer found at the same address or line, it
12528 may mean the marker no longer exists. But it may also just mean
12529 the code changed a bit. Maybe the user added a few lines of code
12530 that made the marker move up or down (in line number terms). Ask
12531 the target for info about the marker with the string id as we knew
12532 it. If found, update line number and address in the matching
12533 static tracepoint. This will get confused if there's more than one
12534 marker with the same ID (possible in UST, although unadvised
12535 precisely because it confuses tools). */
12537 static struct symtab_and_line
12538 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
12540 struct tracepoint
*tp
= (struct tracepoint
*) b
;
12541 struct static_tracepoint_marker marker
;
12546 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
12548 if (target_static_tracepoint_marker_at (pc
, &marker
))
12550 if (tp
->static_trace_marker_id
!= marker
.str_id
)
12551 warning (_("static tracepoint %d changed probed marker from %s to %s"),
12552 b
->number
, tp
->static_trace_marker_id
.c_str (),
12553 marker
.str_id
.c_str ());
12555 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
12560 /* Old marker wasn't found on target at lineno. Try looking it up
12562 if (!sal
.explicit_pc
12564 && sal
.symtab
!= NULL
12565 && !tp
->static_trace_marker_id
.empty ())
12567 std::vector
<static_tracepoint_marker
> markers
12568 = target_static_tracepoint_markers_by_strid
12569 (tp
->static_trace_marker_id
.c_str ());
12571 if (!markers
.empty ())
12573 struct symbol
*sym
;
12574 struct static_tracepoint_marker
*tpmarker
;
12575 struct ui_out
*uiout
= current_uiout
;
12577 tpmarker
= &markers
[0];
12579 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
12581 warning (_("marker for static tracepoint %d (%s) not "
12582 "found at previous line number"),
12583 b
->number
, tp
->static_trace_marker_id
.c_str ());
12585 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
12586 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
12587 uiout
->text ("Now in ");
12590 uiout
->field_string ("func", sym
->print_name (),
12591 function_name_style
.style ());
12592 uiout
->text (" at ");
12594 uiout
->field_string ("file",
12595 symtab_to_filename_for_display (sal2
.symtab
),
12596 file_name_style
.style ());
12599 if (uiout
->is_mi_like_p ())
12601 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
12603 uiout
->field_string ("fullname", fullname
);
12606 uiout
->field_signed ("line", sal2
.line
);
12607 uiout
->text ("\n");
12609 b
->loc
->line_number
= sal2
.line
;
12610 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
12612 std::unique_ptr
<explicit_location_spec
> els
12613 (new explicit_location_spec ());
12614 els
->source_filename
12615 = xstrdup (symtab_to_filename_for_display (sal2
.symtab
));
12616 els
->line_offset
.offset
= b
->loc
->line_number
;
12617 els
->line_offset
.sign
= LINE_OFFSET_NONE
;
12619 b
->locspec
= std::move (els
);
12621 /* Might be nice to check if function changed, and warn if
12628 /* Returns true iff locations A and B are sufficiently same that
12629 we don't need to report breakpoint as changed. */
12632 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
12636 if (a
->address
!= b
->address
)
12639 if (a
->shlib_disabled
!= b
->shlib_disabled
)
12642 if (a
->enabled
!= b
->enabled
)
12645 if (a
->disabled_by_cond
!= b
->disabled_by_cond
)
12652 if ((a
== NULL
) != (b
== NULL
))
12658 /* Split all locations of B that are bound to PSPACE out of B's
12659 location list to a separate list and return that list's head. If
12660 PSPACE is NULL, hoist out all locations of B. */
12662 static struct bp_location
*
12663 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
12665 struct bp_location head
;
12666 struct bp_location
*i
= b
->loc
;
12667 struct bp_location
**i_link
= &b
->loc
;
12668 struct bp_location
*hoisted
= &head
;
12670 if (pspace
== NULL
)
12681 if (i
->pspace
== pspace
)
12696 /* Create new breakpoint locations for B (a hardware or software
12697 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
12698 zero, then B is a ranged breakpoint. Only recreates locations for
12699 FILTER_PSPACE. Locations of other program spaces are left
12703 update_breakpoint_locations (code_breakpoint
*b
,
12704 struct program_space
*filter_pspace
,
12705 gdb::array_view
<const symtab_and_line
> sals
,
12706 gdb::array_view
<const symtab_and_line
> sals_end
)
12708 struct bp_location
*existing_locations
;
12710 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
12712 /* Ranged breakpoints have only one start location and one end
12714 b
->enable_state
= bp_disabled
;
12715 gdb_printf (gdb_stderr
,
12716 _("Could not reset ranged breakpoint %d: "
12717 "multiple locations found\n"),
12722 /* If there's no new locations, and all existing locations are
12723 pending, don't do anything. This optimizes the common case where
12724 all locations are in the same shared library, that was unloaded.
12725 We'd like to retain the location, so that when the library is
12726 loaded again, we don't loose the enabled/disabled status of the
12727 individual locations. */
12728 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
12731 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
12733 for (const auto &sal
: sals
)
12735 struct bp_location
*new_loc
;
12737 switch_to_program_space_and_thread (sal
.pspace
);
12739 new_loc
= b
->add_location (sal
);
12741 /* Reparse conditions, they might contain references to the
12743 if (b
->cond_string
!= NULL
)
12747 s
= b
->cond_string
.get ();
12750 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
12751 block_for_pc (sal
.pc
),
12754 catch (const gdb_exception_error
&e
)
12756 new_loc
->disabled_by_cond
= true;
12760 if (!sals_end
.empty ())
12762 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
12764 new_loc
->length
= end
- sals
[0].pc
+ 1;
12768 /* If possible, carry over 'disable' status from existing
12771 struct bp_location
*e
= existing_locations
;
12772 /* If there are multiple breakpoints with the same function name,
12773 e.g. for inline functions, comparing function names won't work.
12774 Instead compare pc addresses; this is just a heuristic as things
12775 may have moved, but in practice it gives the correct answer
12776 often enough until a better solution is found. */
12777 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
12779 for (; e
; e
= e
->next
)
12781 if ((!e
->enabled
|| e
->disabled_by_cond
) && e
->function_name
)
12783 if (have_ambiguous_names
)
12785 for (bp_location
*l
: b
->locations ())
12787 /* Ignore software vs hardware location type at
12788 this point, because with "set breakpoint
12789 auto-hw", after a re-set, locations that were
12790 hardware can end up as software, or vice versa.
12791 As mentioned above, this is an heuristic and in
12792 practice should give the correct answer often
12794 if (breakpoint_locations_match (e
, l
, true))
12796 l
->enabled
= e
->enabled
;
12797 l
->disabled_by_cond
= e
->disabled_by_cond
;
12804 for (bp_location
*l
: b
->locations ())
12805 if (l
->function_name
12806 && strcmp (e
->function_name
.get (),
12807 l
->function_name
.get ()) == 0)
12809 l
->enabled
= e
->enabled
;
12810 l
->disabled_by_cond
= e
->disabled_by_cond
;
12818 if (!locations_are_equal (existing_locations
, b
->loc
))
12819 gdb::observers::breakpoint_modified
.notify (b
);
12822 /* Find the SaL locations corresponding to the given LOCSPEC.
12823 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
12825 std::vector
<symtab_and_line
>
12826 code_breakpoint::location_spec_to_sals (location_spec
*locspec
,
12827 struct program_space
*search_pspace
,
12830 struct gdb_exception exception
;
12832 std::vector
<symtab_and_line
> sals
;
12836 sals
= decode_location_spec (locspec
, search_pspace
);
12838 catch (gdb_exception_error
&e
)
12840 int not_found_and_ok
= false;
12842 /* For pending breakpoints, it's expected that parsing will
12843 fail until the right shared library is loaded. User has
12844 already told to create pending breakpoints and don't need
12845 extra messages. If breakpoint is in bp_shlib_disabled
12846 state, then user already saw the message about that
12847 breakpoint being disabled, and don't want to see more
12849 if (e
.error
== NOT_FOUND_ERROR
12850 && (condition_not_parsed
12852 && search_pspace
!= NULL
12853 && loc
->pspace
!= search_pspace
)
12854 || (loc
&& loc
->shlib_disabled
)
12855 || (loc
&& loc
->pspace
->executing_startup
)
12856 || enable_state
== bp_disabled
))
12857 not_found_and_ok
= true;
12859 if (!not_found_and_ok
)
12861 /* We surely don't want to warn about the same breakpoint
12862 10 times. One solution, implemented here, is disable
12863 the breakpoint on error. Another solution would be to
12864 have separate 'warning emitted' flag. Since this
12865 happens only when a binary has changed, I don't know
12866 which approach is better. */
12867 enable_state
= bp_disabled
;
12871 exception
= std::move (e
);
12874 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
12876 for (auto &sal
: sals
)
12877 resolve_sal_pc (&sal
);
12878 if (condition_not_parsed
&& extra_string
!= NULL
)
12880 gdb::unique_xmalloc_ptr
<char> local_cond
, local_extra
;
12881 int local_thread
, local_task
;
12883 find_condition_and_thread_for_sals (sals
, extra_string
.get (),
12884 &local_cond
, &local_thread
,
12885 &local_task
, &local_extra
);
12886 gdb_assert (cond_string
== nullptr);
12887 if (local_cond
!= nullptr)
12888 cond_string
= std::move (local_cond
);
12889 thread
= local_thread
;
12891 if (local_extra
!= nullptr)
12892 extra_string
= std::move (local_extra
);
12893 condition_not_parsed
= 0;
12896 if (type
== bp_static_tracepoint
)
12897 sals
[0] = update_static_tracepoint (this, sals
[0]);
12907 /* The default re_set method, for typical hardware or software
12908 breakpoints. Reevaluate the breakpoint and recreate its
12912 code_breakpoint::re_set_default ()
12914 struct program_space
*filter_pspace
= current_program_space
;
12915 std::vector
<symtab_and_line
> expanded
, expanded_end
;
12918 std::vector
<symtab_and_line
> sals
= location_spec_to_sals (locspec
.get (),
12922 expanded
= std::move (sals
);
12924 if (locspec_range_end
!= nullptr)
12926 std::vector
<symtab_and_line
> sals_end
12927 = location_spec_to_sals (locspec_range_end
.get (),
12928 filter_pspace
, &found
);
12930 expanded_end
= std::move (sals_end
);
12933 update_breakpoint_locations (this, filter_pspace
, expanded
, expanded_end
);
12936 /* Default method for creating SALs from an address string. It basically
12937 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
12940 create_sals_from_location_spec_default (location_spec
*locspec
,
12941 struct linespec_result
*canonical
)
12943 parse_breakpoint_sals (locspec
, canonical
);
12946 /* Reset a breakpoint. */
12949 breakpoint_re_set_one (breakpoint
*b
)
12951 input_radix
= b
->input_radix
;
12952 set_language (b
->language
);
12957 /* Re-set breakpoint locations for the current program space.
12958 Locations bound to other program spaces are left untouched. */
12961 breakpoint_re_set (void)
12964 scoped_restore_current_language save_language
;
12965 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
12966 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
12968 /* breakpoint_re_set_one sets the current_language to the language
12969 of the breakpoint it is resetting (see prepare_re_set_context)
12970 before re-evaluating the breakpoint's location. This change can
12971 unfortunately get undone by accident if the language_mode is set
12972 to auto, and we either switch frames, or more likely in this context,
12973 we select the current frame.
12975 We prevent this by temporarily turning the language_mode to
12976 language_mode_manual. We restore it once all breakpoints
12977 have been reset. */
12978 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
12979 language_mode
= language_mode_manual
;
12981 /* Note: we must not try to insert locations until after all
12982 breakpoints have been re-set. Otherwise, e.g., when re-setting
12983 breakpoint 1, we'd insert the locations of breakpoint 2, which
12984 hadn't been re-set yet, and thus may have stale locations. */
12986 for (breakpoint
*b
: all_breakpoints_safe ())
12990 breakpoint_re_set_one (b
);
12992 catch (const gdb_exception
&ex
)
12994 exception_fprintf (gdb_stderr
, ex
,
12995 "Error in re-setting breakpoint %d: ",
13000 jit_breakpoint_re_set ();
13003 create_overlay_event_breakpoint ();
13004 create_longjmp_master_breakpoint ();
13005 create_std_terminate_master_breakpoint ();
13006 create_exception_master_breakpoint ();
13008 /* Now we can insert. */
13009 update_global_location_list (UGLL_MAY_INSERT
);
13012 /* Reset the thread number of this breakpoint:
13014 - If the breakpoint is for all threads, leave it as-is.
13015 - Else, reset it to the current thread for inferior_ptid. */
13017 breakpoint_re_set_thread (struct breakpoint
*b
)
13019 if (b
->thread
!= -1)
13021 b
->thread
= inferior_thread ()->global_num
;
13023 /* We're being called after following a fork. The new fork is
13024 selected as current, and unless this was a vfork will have a
13025 different program space from the original thread. Reset that
13027 b
->loc
->pspace
= current_program_space
;
13031 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13032 If from_tty is nonzero, it prints a message to that effect,
13033 which ends with a period (no newline). */
13036 set_ignore_count (int bptnum
, int count
, int from_tty
)
13041 for (breakpoint
*b
: all_breakpoints ())
13042 if (b
->number
== bptnum
)
13044 if (is_tracepoint (b
))
13046 if (from_tty
&& count
!= 0)
13047 gdb_printf (_("Ignore count ignored for tracepoint %d."),
13052 b
->ignore_count
= count
;
13056 gdb_printf (_("Will stop next time "
13057 "breakpoint %d is reached."),
13059 else if (count
== 1)
13060 gdb_printf (_("Will ignore next crossing of breakpoint %d."),
13063 gdb_printf (_("Will ignore next %d "
13064 "crossings of breakpoint %d."),
13067 gdb::observers::breakpoint_modified
.notify (b
);
13071 error (_("No breakpoint number %d."), bptnum
);
13074 /* Command to set ignore-count of breakpoint N to COUNT. */
13077 ignore_command (const char *args
, int from_tty
)
13079 const char *p
= args
;
13083 error_no_arg (_("a breakpoint number"));
13085 num
= get_number (&p
);
13087 error (_("bad breakpoint number: '%s'"), args
);
13089 error (_("Second argument (specified ignore-count) is missing."));
13091 set_ignore_count (num
,
13092 longest_to_int (value_as_long (parse_and_eval (p
))),
13099 /* Call FUNCTION on each of the breakpoints with numbers in the range
13100 defined by BP_NUM_RANGE (an inclusive range). */
13103 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
13104 gdb::function_view
<void (breakpoint
*)> function
)
13106 if (bp_num_range
.first
== 0)
13108 warning (_("bad breakpoint number at or near '%d'"),
13109 bp_num_range
.first
);
13113 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
13115 bool match
= false;
13117 for (breakpoint
*b
: all_breakpoints_safe ())
13118 if (b
->number
== i
)
13125 gdb_printf (_("No breakpoint number %d.\n"), i
);
13130 /* Call FUNCTION on each of the breakpoints whose numbers are given in
13134 map_breakpoint_numbers (const char *args
,
13135 gdb::function_view
<void (breakpoint
*)> function
)
13137 if (args
== NULL
|| *args
== '\0')
13138 error_no_arg (_("one or more breakpoint numbers"));
13140 number_or_range_parser
parser (args
);
13142 while (!parser
.finished ())
13144 int num
= parser
.get_number ();
13145 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
13149 /* Return the breakpoint location structure corresponding to the
13150 BP_NUM and LOC_NUM values. */
13152 static struct bp_location
*
13153 find_location_by_number (int bp_num
, int loc_num
)
13155 breakpoint
*b
= get_breakpoint (bp_num
);
13157 if (!b
|| b
->number
!= bp_num
)
13158 error (_("Bad breakpoint number '%d'"), bp_num
);
13161 error (_("Bad breakpoint location number '%d'"), loc_num
);
13164 for (bp_location
*loc
: b
->locations ())
13165 if (++n
== loc_num
)
13168 error (_("Bad breakpoint location number '%d'"), loc_num
);
13171 /* Modes of operation for extract_bp_num. */
13172 enum class extract_bp_kind
13174 /* Extracting a breakpoint number. */
13177 /* Extracting a location number. */
13181 /* Extract a breakpoint or location number (as determined by KIND)
13182 from the string starting at START. TRAILER is a character which
13183 can be found after the number. If you don't want a trailer, use
13184 '\0'. If END_OUT is not NULL, it is set to point after the parsed
13185 string. This always returns a positive integer. */
13188 extract_bp_num (extract_bp_kind kind
, const char *start
,
13189 int trailer
, const char **end_out
= NULL
)
13191 const char *end
= start
;
13192 int num
= get_number_trailer (&end
, trailer
);
13194 error (kind
== extract_bp_kind::bp
13195 ? _("Negative breakpoint number '%.*s'")
13196 : _("Negative breakpoint location number '%.*s'"),
13197 int (end
- start
), start
);
13199 error (kind
== extract_bp_kind::bp
13200 ? _("Bad breakpoint number '%.*s'")
13201 : _("Bad breakpoint location number '%.*s'"),
13202 int (end
- start
), start
);
13204 if (end_out
!= NULL
)
13209 /* Extract a breakpoint or location range (as determined by KIND) in
13210 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
13211 representing the (inclusive) range. The returned pair's elements
13212 are always positive integers. */
13214 static std::pair
<int, int>
13215 extract_bp_or_bp_range (extract_bp_kind kind
,
13216 const std::string
&arg
,
13217 std::string::size_type arg_offset
)
13219 std::pair
<int, int> range
;
13220 const char *bp_loc
= &arg
[arg_offset
];
13221 std::string::size_type dash
= arg
.find ('-', arg_offset
);
13222 if (dash
!= std::string::npos
)
13224 /* bp_loc is a range (x-z). */
13225 if (arg
.length () == dash
+ 1)
13226 error (kind
== extract_bp_kind::bp
13227 ? _("Bad breakpoint number at or near: '%s'")
13228 : _("Bad breakpoint location number at or near: '%s'"),
13232 const char *start_first
= bp_loc
;
13233 const char *start_second
= &arg
[dash
+ 1];
13234 range
.first
= extract_bp_num (kind
, start_first
, '-');
13235 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
13237 if (range
.first
> range
.second
)
13238 error (kind
== extract_bp_kind::bp
13239 ? _("Inverted breakpoint range at '%.*s'")
13240 : _("Inverted breakpoint location range at '%.*s'"),
13241 int (end
- start_first
), start_first
);
13245 /* bp_loc is a single value. */
13246 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
13247 range
.second
= range
.first
;
13252 /* Extract the breakpoint/location range specified by ARG. Returns
13253 the breakpoint range in BP_NUM_RANGE, and the location range in
13256 ARG may be in any of the following forms:
13258 x where 'x' is a breakpoint number.
13259 x-y where 'x' and 'y' specify a breakpoint numbers range.
13260 x.y where 'x' is a breakpoint number and 'y' a location number.
13261 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
13262 location number range.
13266 extract_bp_number_and_location (const std::string
&arg
,
13267 std::pair
<int, int> &bp_num_range
,
13268 std::pair
<int, int> &bp_loc_range
)
13270 std::string::size_type dot
= arg
.find ('.');
13272 if (dot
!= std::string::npos
)
13274 /* Handle 'x.y' and 'x.y-z' cases. */
13276 if (arg
.length () == dot
+ 1 || dot
== 0)
13277 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
13280 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
13281 bp_num_range
.second
= bp_num_range
.first
;
13283 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
13288 /* Handle x and x-y cases. */
13290 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
13291 bp_loc_range
.first
= 0;
13292 bp_loc_range
.second
= 0;
13296 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
13297 specifies whether to enable or disable. */
13300 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
13302 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
13305 if (loc
->disabled_by_cond
&& enable
)
13306 error (_("Breakpoint %d's condition is invalid at location %d, "
13307 "cannot enable."), bp_num
, loc_num
);
13309 if (loc
->enabled
!= enable
)
13311 loc
->enabled
= enable
;
13312 mark_breakpoint_location_modified (loc
);
13314 if (target_supports_enable_disable_tracepoint ()
13315 && current_trace_status ()->running
&& loc
->owner
13316 && is_tracepoint (loc
->owner
))
13317 target_disable_tracepoint (loc
);
13319 update_global_location_list (UGLL_DONT_INSERT
);
13321 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
13324 /* Calculates LOC_NUM for LOC by traversing the bp_location chain of LOC's
13325 owner. 1-based indexing. -1 signals NOT FOUND. */
13328 find_loc_num_by_location (const bp_location
*loc
)
13330 if (loc
!= nullptr && loc
->owner
!= nullptr)
13332 /* Locations use 1-based indexing. */
13334 for (bp_location
*it
: loc
->owner
->locations ())
13344 /* Enable or disable a breakpoint location LOC. ENABLE
13345 specifies whether to enable or disable. */
13348 enable_disable_bp_location (bp_location
*loc
, bool enable
)
13350 if (loc
== nullptr)
13351 error (_("Breakpoint location is invalid."));
13353 if (loc
->owner
== nullptr)
13354 error (_("Breakpoint location does not have an owner breakpoint."));
13356 if (loc
->disabled_by_cond
&& enable
)
13358 int loc_num
= find_loc_num_by_location (loc
);
13360 error (_("Breakpoint location LOC_NUM could not be found."));
13362 error (_("Breakpoint %d's condition is invalid at location %d, "
13363 "cannot enable."), loc
->owner
->number
, loc_num
);
13366 if (loc
->enabled
!= enable
)
13368 loc
->enabled
= enable
;
13369 mark_breakpoint_location_modified (loc
);
13372 if (target_supports_enable_disable_tracepoint ()
13373 && current_trace_status ()->running
&& loc
->owner
13374 && is_tracepoint (loc
->owner
))
13375 target_disable_tracepoint (loc
);
13377 update_global_location_list (UGLL_DONT_INSERT
);
13378 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
13381 /* Enable or disable a range of breakpoint locations. BP_NUM is the
13382 number of the breakpoint, and BP_LOC_RANGE specifies the
13383 (inclusive) range of location numbers of that breakpoint to
13384 enable/disable. ENABLE specifies whether to enable or disable the
13388 enable_disable_breakpoint_location_range (int bp_num
,
13389 std::pair
<int, int> &bp_loc_range
,
13392 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
13393 enable_disable_bp_num_loc (bp_num
, i
, enable
);
13396 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13397 If from_tty is nonzero, it prints a message to that effect,
13398 which ends with a period (no newline). */
13401 disable_breakpoint (struct breakpoint
*bpt
)
13403 /* Never disable a watchpoint scope breakpoint; we want to
13404 hit them when we leave scope so we can delete both the
13405 watchpoint and its scope breakpoint at that time. */
13406 if (bpt
->type
== bp_watchpoint_scope
)
13409 bpt
->enable_state
= bp_disabled
;
13411 /* Mark breakpoint locations modified. */
13412 mark_breakpoint_modified (bpt
);
13414 if (target_supports_enable_disable_tracepoint ()
13415 && current_trace_status ()->running
&& is_tracepoint (bpt
))
13417 for (bp_location
*location
: bpt
->locations ())
13418 target_disable_tracepoint (location
);
13421 update_global_location_list (UGLL_DONT_INSERT
);
13423 gdb::observers::breakpoint_modified
.notify (bpt
);
13426 /* Enable or disable the breakpoint(s) or breakpoint location(s)
13427 specified in ARGS. ARGS may be in any of the formats handled by
13428 extract_bp_number_and_location. ENABLE specifies whether to enable
13429 or disable the breakpoints/locations. */
13432 enable_disable_command (const char *args
, int from_tty
, bool enable
)
13436 for (breakpoint
*bpt
: all_breakpoints ())
13437 if (user_breakpoint_p (bpt
))
13440 enable_breakpoint (bpt
);
13442 disable_breakpoint (bpt
);
13447 std::string num
= extract_arg (&args
);
13449 while (!num
.empty ())
13451 std::pair
<int, int> bp_num_range
, bp_loc_range
;
13453 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
13455 if (bp_loc_range
.first
== bp_loc_range
.second
13456 && (bp_loc_range
.first
== 0
13457 || (bp_loc_range
.first
== 1
13458 && bp_num_range
.first
== bp_num_range
.second
13459 && !has_multiple_locations (bp_num_range
.first
))))
13461 /* Handle breakpoint ids with formats 'x' or 'x-z'
13462 or 'y.1' where y has only one code location. */
13463 map_breakpoint_number_range (bp_num_range
,
13465 ? enable_breakpoint
13466 : disable_breakpoint
);
13470 /* Handle breakpoint ids with formats 'x.y' or
13472 enable_disable_breakpoint_location_range
13473 (bp_num_range
.first
, bp_loc_range
, enable
);
13475 num
= extract_arg (&args
);
13480 /* The disable command disables the specified breakpoints/locations
13481 (or all defined breakpoints) so they're no longer effective in
13482 stopping the inferior. ARGS may be in any of the forms defined in
13483 extract_bp_number_and_location. */
13486 disable_command (const char *args
, int from_tty
)
13488 enable_disable_command (args
, from_tty
, false);
13492 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
13495 int target_resources_ok
;
13497 if (bpt
->type
== bp_hardware_breakpoint
)
13500 i
= hw_breakpoint_used_count ();
13501 target_resources_ok
=
13502 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
13504 if (target_resources_ok
== 0)
13505 error (_("No hardware breakpoint support in the target."));
13506 else if (target_resources_ok
< 0)
13507 error (_("Hardware breakpoints used exceeds limit."));
13510 if (is_watchpoint (bpt
))
13512 /* Initialize it just to avoid a GCC false warning. */
13513 enum enable_state orig_enable_state
= bp_disabled
;
13517 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
13519 orig_enable_state
= bpt
->enable_state
;
13520 bpt
->enable_state
= bp_enabled
;
13521 update_watchpoint (w
, true /* reparse */);
13523 catch (const gdb_exception
&e
)
13525 bpt
->enable_state
= orig_enable_state
;
13526 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
13532 bpt
->enable_state
= bp_enabled
;
13534 /* Mark breakpoint locations modified. */
13535 mark_breakpoint_modified (bpt
);
13537 if (target_supports_enable_disable_tracepoint ()
13538 && current_trace_status ()->running
&& is_tracepoint (bpt
))
13540 for (bp_location
*location
: bpt
->locations ())
13541 target_enable_tracepoint (location
);
13544 bpt
->disposition
= disposition
;
13545 bpt
->enable_count
= count
;
13546 update_global_location_list (UGLL_MAY_INSERT
);
13548 gdb::observers::breakpoint_modified
.notify (bpt
);
13553 enable_breakpoint (struct breakpoint
*bpt
)
13555 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
13558 /* The enable command enables the specified breakpoints/locations (or
13559 all defined breakpoints) so they once again become (or continue to
13560 be) effective in stopping the inferior. ARGS may be in any of the
13561 forms defined in extract_bp_number_and_location. */
13564 enable_command (const char *args
, int from_tty
)
13566 enable_disable_command (args
, from_tty
, true);
13570 enable_once_command (const char *args
, int from_tty
)
13572 map_breakpoint_numbers
13573 (args
, [&] (breakpoint
*b
)
13575 iterate_over_related_breakpoints
13576 (b
, [&] (breakpoint
*bpt
)
13578 enable_breakpoint_disp (bpt
, disp_disable
, 1);
13584 enable_count_command (const char *args
, int from_tty
)
13589 error_no_arg (_("hit count"));
13591 count
= get_number (&args
);
13593 map_breakpoint_numbers
13594 (args
, [&] (breakpoint
*b
)
13596 iterate_over_related_breakpoints
13597 (b
, [&] (breakpoint
*bpt
)
13599 enable_breakpoint_disp (bpt
, disp_disable
, count
);
13605 enable_delete_command (const char *args
, int from_tty
)
13607 map_breakpoint_numbers
13608 (args
, [&] (breakpoint
*b
)
13610 iterate_over_related_breakpoints
13611 (b
, [&] (breakpoint
*bpt
)
13613 enable_breakpoint_disp (bpt
, disp_del
, 1);
13618 /* Invalidate last known value of any hardware watchpoint if
13619 the memory which that value represents has been written to by
13623 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
13624 CORE_ADDR addr
, ssize_t len
,
13625 const bfd_byte
*data
)
13627 for (breakpoint
*bp
: all_breakpoints ())
13628 if (bp
->enable_state
== bp_enabled
13629 && bp
->type
== bp_hardware_watchpoint
)
13631 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
13633 if (wp
->val_valid
&& wp
->val
!= nullptr)
13635 for (bp_location
*loc
: bp
->locations ())
13636 if (loc
->loc_type
== bp_loc_hardware_watchpoint
13637 && loc
->address
+ loc
->length
> addr
13638 && addr
+ len
> loc
->address
)
13641 wp
->val_valid
= false;
13647 /* Create and insert a breakpoint for software single step. */
13650 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
13651 const address_space
*aspace
,
13654 struct thread_info
*tp
= inferior_thread ();
13655 struct symtab_and_line sal
;
13656 CORE_ADDR pc
= next_pc
;
13658 if (tp
->control
.single_step_breakpoints
== NULL
)
13660 std::unique_ptr
<breakpoint
> b
13661 (new momentary_breakpoint (gdbarch
, bp_single_step
,
13662 current_program_space
,
13666 tp
->control
.single_step_breakpoints
13667 = add_to_breakpoint_chain (std::move (b
));
13670 sal
= find_pc_line (pc
, 0);
13672 sal
.section
= find_pc_overlay (pc
);
13673 sal
.explicit_pc
= 1;
13676 = (gdb::checked_static_cast
<momentary_breakpoint
*>
13677 (tp
->control
.single_step_breakpoints
));
13678 ss_bp
->add_location (sal
);
13680 update_global_location_list (UGLL_INSERT
);
13683 /* Insert single step breakpoints according to the current state. */
13686 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
13688 struct regcache
*regcache
= get_current_regcache ();
13689 std::vector
<CORE_ADDR
> next_pcs
;
13691 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
13693 if (!next_pcs
.empty ())
13695 frame_info_ptr frame
= get_current_frame ();
13696 const address_space
*aspace
= get_frame_address_space (frame
);
13698 for (CORE_ADDR pc
: next_pcs
)
13699 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
13707 /* See breakpoint.h. */
13710 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
13711 const address_space
*aspace
,
13714 for (bp_location
*loc
: bp
->locations ())
13716 && breakpoint_location_address_match (loc
, aspace
, pc
))
13722 /* Check whether a software single-step breakpoint is inserted at
13726 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
13729 for (breakpoint
*bpt
: all_breakpoints ())
13731 if (bpt
->type
== bp_single_step
13732 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
13738 /* Tracepoint-specific operations. */
13740 /* Set tracepoint count to NUM. */
13742 set_tracepoint_count (int num
)
13744 tracepoint_count
= num
;
13745 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
13749 trace_command (const char *arg
, int from_tty
)
13751 location_spec_up locspec
= string_to_location_spec (&arg
,
13753 const struct breakpoint_ops
*ops
= breakpoint_ops_for_location_spec
13754 (locspec
.get (), true /* is_tracepoint */);
13756 create_breakpoint (get_current_arch (),
13758 NULL
, 0, arg
, false, 1 /* parse arg */,
13760 bp_tracepoint
/* type_wanted */,
13761 0 /* Ignore count */,
13762 pending_break_support
,
13766 0 /* internal */, 0);
13770 ftrace_command (const char *arg
, int from_tty
)
13772 location_spec_up locspec
= string_to_location_spec (&arg
,
13774 create_breakpoint (get_current_arch (),
13776 NULL
, 0, arg
, false, 1 /* parse arg */,
13778 bp_fast_tracepoint
/* type_wanted */,
13779 0 /* Ignore count */,
13780 pending_break_support
,
13781 &code_breakpoint_ops
,
13784 0 /* internal */, 0);
13787 /* strace command implementation. Creates a static tracepoint. */
13790 strace_command (const char *arg
, int from_tty
)
13792 const struct breakpoint_ops
*ops
;
13793 location_spec_up locspec
;
13796 /* Decide if we are dealing with a static tracepoint marker (`-m'),
13797 or with a normal static tracepoint. */
13798 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
13800 ops
= &strace_marker_breakpoint_ops
;
13801 locspec
= new_linespec_location_spec (&arg
,
13802 symbol_name_match_type::FULL
);
13803 type
= bp_static_marker_tracepoint
;
13807 ops
= &code_breakpoint_ops
;
13808 locspec
= string_to_location_spec (&arg
, current_language
);
13809 type
= bp_static_tracepoint
;
13812 create_breakpoint (get_current_arch (),
13814 NULL
, 0, arg
, false, 1 /* parse arg */,
13816 type
/* type_wanted */,
13817 0 /* Ignore count */,
13818 pending_break_support
,
13822 0 /* internal */, 0);
13825 /* Set up a fake reader function that gets command lines from a linked
13826 list that was acquired during tracepoint uploading. */
13828 static struct uploaded_tp
*this_utp
;
13829 static int next_cmd
;
13831 static const char *
13832 read_uploaded_action (std::string
&buffer
)
13834 char *rslt
= nullptr;
13836 if (next_cmd
< this_utp
->cmd_strings
.size ())
13838 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
13845 /* Given information about a tracepoint as recorded on a target (which
13846 can be either a live system or a trace file), attempt to create an
13847 equivalent GDB tracepoint. This is not a reliable process, since
13848 the target does not necessarily have all the information used when
13849 the tracepoint was originally defined. */
13851 struct tracepoint
*
13852 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
13854 const char *addr_str
;
13855 char small_buf
[100];
13856 struct tracepoint
*tp
;
13858 if (utp
->at_string
)
13859 addr_str
= utp
->at_string
.get ();
13862 /* In the absence of a source location, fall back to raw
13863 address. Since there is no way to confirm that the address
13864 means the same thing as when the trace was started, warn the
13866 warning (_("Uploaded tracepoint %d has no "
13867 "source location, using raw address"),
13869 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
13870 addr_str
= small_buf
;
13873 /* There's not much we can do with a sequence of bytecodes. */
13874 if (utp
->cond
&& !utp
->cond_string
)
13875 warning (_("Uploaded tracepoint %d condition "
13876 "has no source form, ignoring it"),
13879 location_spec_up locspec
= string_to_location_spec (&addr_str
,
13881 if (!create_breakpoint (get_current_arch (),
13883 utp
->cond_string
.get (), -1, addr_str
,
13884 false /* force_condition */,
13885 0 /* parse cond/thread */,
13887 utp
->type
/* type_wanted */,
13888 0 /* Ignore count */,
13889 pending_break_support
,
13890 &code_breakpoint_ops
,
13892 utp
->enabled
/* enabled */,
13894 CREATE_BREAKPOINT_FLAGS_INSERTED
))
13897 /* Get the tracepoint we just created. */
13898 tp
= get_tracepoint (tracepoint_count
);
13899 gdb_assert (tp
!= NULL
);
13903 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
13906 trace_pass_command (small_buf
, 0);
13909 /* If we have uploaded versions of the original commands, set up a
13910 special-purpose "reader" function and call the usual command line
13911 reader, then pass the result to the breakpoint command-setting
13913 if (!utp
->cmd_strings
.empty ())
13915 counted_command_line cmd_list
;
13920 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
13922 breakpoint_set_commands (tp
, std::move (cmd_list
));
13924 else if (!utp
->actions
.empty ()
13925 || !utp
->step_actions
.empty ())
13926 warning (_("Uploaded tracepoint %d actions "
13927 "have no source form, ignoring them"),
13930 /* Copy any status information that might be available. */
13931 tp
->hit_count
= utp
->hit_count
;
13932 tp
->traceframe_usage
= utp
->traceframe_usage
;
13937 /* Print information on tracepoint number TPNUM_EXP, or all if
13941 info_tracepoints_command (const char *args
, int from_tty
)
13943 struct ui_out
*uiout
= current_uiout
;
13946 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
13948 if (num_printed
== 0)
13950 if (args
== NULL
|| *args
== '\0')
13951 uiout
->message ("No tracepoints.\n");
13953 uiout
->message ("No tracepoint matching '%s'.\n", args
);
13956 default_collect_info ();
13959 /* The 'enable trace' command enables tracepoints.
13960 Not supported by all targets. */
13962 enable_trace_command (const char *args
, int from_tty
)
13964 enable_command (args
, from_tty
);
13967 /* The 'disable trace' command disables tracepoints.
13968 Not supported by all targets. */
13970 disable_trace_command (const char *args
, int from_tty
)
13972 disable_command (args
, from_tty
);
13975 /* Remove a tracepoint (or all if no argument). */
13977 delete_trace_command (const char *arg
, int from_tty
)
13983 int breaks_to_delete
= 0;
13985 /* Delete all breakpoints if no argument.
13986 Do not delete internal or call-dummy breakpoints, these
13987 have to be deleted with an explicit breakpoint number
13989 for (breakpoint
*tp
: all_tracepoints ())
13990 if (is_tracepoint (tp
) && user_breakpoint_p (tp
))
13992 breaks_to_delete
= 1;
13996 /* Ask user only if there are some breakpoints to delete. */
13998 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14000 for (breakpoint
*b
: all_breakpoints_safe ())
14001 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14002 delete_breakpoint (b
);
14006 map_breakpoint_numbers
14007 (arg
, [&] (breakpoint
*br
)
14009 iterate_over_related_breakpoints (br
, delete_breakpoint
);
14013 /* Helper function for trace_pass_command. */
14016 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14018 tp
->pass_count
= count
;
14019 gdb::observers::breakpoint_modified
.notify (tp
);
14021 gdb_printf (_("Setting tracepoint %d's passcount to %d\n"),
14022 tp
->number
, count
);
14025 /* Set passcount for tracepoint.
14027 First command argument is passcount, second is tracepoint number.
14028 If tracepoint number omitted, apply to most recently defined.
14029 Also accepts special argument "all". */
14032 trace_pass_command (const char *args
, int from_tty
)
14034 struct tracepoint
*t1
;
14037 if (args
== 0 || *args
== 0)
14038 error (_("passcount command requires an "
14039 "argument (count + optional TP num)"));
14041 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14043 args
= skip_spaces (args
);
14044 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14046 args
+= 3; /* Skip special argument "all". */
14048 error (_("Junk at end of arguments."));
14050 for (breakpoint
*b
: all_tracepoints ())
14052 t1
= (struct tracepoint
*) b
;
14053 trace_pass_set_count (t1
, count
, from_tty
);
14056 else if (*args
== '\0')
14058 t1
= get_tracepoint_by_number (&args
, NULL
);
14060 trace_pass_set_count (t1
, count
, from_tty
);
14064 number_or_range_parser
parser (args
);
14065 while (!parser
.finished ())
14067 t1
= get_tracepoint_by_number (&args
, &parser
);
14069 trace_pass_set_count (t1
, count
, from_tty
);
14074 struct tracepoint
*
14075 get_tracepoint (int num
)
14077 for (breakpoint
*t
: all_tracepoints ())
14078 if (t
->number
== num
)
14079 return (struct tracepoint
*) t
;
14084 /* Find the tracepoint with the given target-side number (which may be
14085 different from the tracepoint number after disconnecting and
14088 struct tracepoint
*
14089 get_tracepoint_by_number_on_target (int num
)
14091 for (breakpoint
*b
: all_tracepoints ())
14093 struct tracepoint
*t
= (struct tracepoint
*) b
;
14095 if (t
->number_on_target
== num
)
14102 /* Utility: parse a tracepoint number and look it up in the list.
14103 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14104 If the argument is missing, the most recent tracepoint
14105 (tracepoint_count) is returned. */
14107 struct tracepoint
*
14108 get_tracepoint_by_number (const char **arg
,
14109 number_or_range_parser
*parser
)
14112 const char *instring
= arg
== NULL
? NULL
: *arg
;
14114 if (parser
!= NULL
)
14116 gdb_assert (!parser
->finished ());
14117 tpnum
= parser
->get_number ();
14119 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
14120 tpnum
= tracepoint_count
;
14122 tpnum
= get_number (arg
);
14126 if (instring
&& *instring
)
14127 gdb_printf (_("bad tracepoint number at or near '%s'\n"),
14130 gdb_printf (_("No previous tracepoint\n"));
14134 for (breakpoint
*t
: all_tracepoints ())
14135 if (t
->number
== tpnum
)
14136 return (struct tracepoint
*) t
;
14138 gdb_printf ("No tracepoint number %d.\n", tpnum
);
14143 breakpoint::print_recreate_thread (struct ui_file
*fp
) const
14146 gdb_printf (fp
, " thread %d", thread
);
14149 gdb_printf (fp
, " task %d", task
);
14151 gdb_printf (fp
, "\n");
14154 /* Save information on user settable breakpoints (watchpoints, etc) to
14155 a new script file named FILENAME. If FILTER is non-NULL, call it
14156 on each breakpoint and only include the ones for which it returns
14160 save_breakpoints (const char *filename
, int from_tty
,
14161 bool (*filter
) (const struct breakpoint
*))
14164 int extra_trace_bits
= 0;
14166 if (filename
== 0 || *filename
== 0)
14167 error (_("Argument required (file name in which to save)"));
14169 /* See if we have anything to save. */
14170 for (breakpoint
*tp
: all_breakpoints ())
14172 /* Skip internal and momentary breakpoints. */
14173 if (!user_breakpoint_p (tp
))
14176 /* If we have a filter, only save the breakpoints it accepts. */
14177 if (filter
&& !filter (tp
))
14182 if (is_tracepoint (tp
))
14184 extra_trace_bits
= 1;
14186 /* We can stop searching. */
14193 warning (_("Nothing to save."));
14197 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
14201 if (!fp
.open (expanded_filename
.get (), "w"))
14202 error (_("Unable to open file '%s' for saving (%s)"),
14203 expanded_filename
.get (), safe_strerror (errno
));
14205 if (extra_trace_bits
)
14206 save_trace_state_variables (&fp
);
14208 for (breakpoint
*tp
: all_breakpoints ())
14210 /* Skip internal and momentary breakpoints. */
14211 if (!user_breakpoint_p (tp
))
14214 /* If we have a filter, only save the breakpoints it accepts. */
14215 if (filter
&& !filter (tp
))
14218 tp
->print_recreate (&fp
);
14220 /* Note, we can't rely on tp->number for anything, as we can't
14221 assume the recreated breakpoint numbers will match. Use $bpnum
14224 if (tp
->cond_string
)
14225 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
.get ());
14227 if (tp
->ignore_count
)
14228 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
14230 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
14232 fp
.puts (" commands\n");
14234 ui_out_redirect_pop
redir (current_uiout
, &fp
);
14235 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
14237 fp
.puts (" end\n");
14240 if (tp
->enable_state
== bp_disabled
)
14241 fp
.puts ("disable $bpnum\n");
14243 /* If this is a multi-location breakpoint, check if the locations
14244 should be individually disabled. Watchpoint locations are
14245 special, and not user visible. */
14246 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
14250 for (bp_location
*loc
: tp
->locations ())
14253 fp
.printf ("disable $bpnum.%d\n", n
);
14260 if (extra_trace_bits
&& !default_collect
.empty ())
14261 fp
.printf ("set default-collect %s\n", default_collect
.c_str ());
14264 gdb_printf (_("Saved to file '%s'.\n"), expanded_filename
.get ());
14267 /* The `save breakpoints' command. */
14270 save_breakpoints_command (const char *args
, int from_tty
)
14272 save_breakpoints (args
, from_tty
, NULL
);
14275 /* The `save tracepoints' command. */
14278 save_tracepoints_command (const char *args
, int from_tty
)
14280 save_breakpoints (args
, from_tty
, is_tracepoint
);
14284 /* This help string is used to consolidate all the help string for specifying
14285 locations used by several commands. */
14287 #define LOCATION_SPEC_HELP_STRING \
14288 "Linespecs are colon-separated lists of location parameters, such as\n\
14289 source filename, function name, label name, and line number.\n\
14290 Example: To specify the start of a label named \"the_top\" in the\n\
14291 function \"fact\" in the file \"factorial.c\", use\n\
14292 \"factorial.c:fact:the_top\".\n\
14294 Address locations begin with \"*\" and specify an exact address in the\n\
14295 program. Example: To specify the fourth byte past the start function\n\
14296 \"main\", use \"*main + 4\".\n\
14298 Explicit locations are similar to linespecs but use an option/argument\n\
14299 syntax to specify location parameters.\n\
14300 Example: To specify the start of the label named \"the_top\" in the\n\
14301 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
14302 -function fact -label the_top\".\n\
14304 By default, a specified function is matched against the program's\n\
14305 functions in all scopes. For C++, this means in all namespaces and\n\
14306 classes. For Ada, this means in all packages. E.g., in C++,\n\
14307 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
14308 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
14309 specified name as a complete fully-qualified name instead."
14311 /* This help string is used for the break, hbreak, tbreak and thbreak
14312 commands. It is defined as a macro to prevent duplication.
14313 COMMAND should be a string constant containing the name of the
14316 #define BREAK_ARGS_HELP(command) \
14317 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM]\n\
14318 \t[-force-condition] [if CONDITION]\n\
14319 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
14320 probe point. Accepted values are `-probe' (for a generic, automatically\n\
14321 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
14322 `-probe-dtrace' (for a DTrace probe).\n\
14323 LOCATION may be a linespec, address, or explicit location as described\n\
14326 With no LOCATION, uses current execution address of the selected\n\
14327 stack frame. This is useful for breaking on return to a stack frame.\n\
14329 THREADNUM is the number from \"info threads\".\n\
14330 CONDITION is a boolean expression.\n\
14332 With the \"-force-condition\" flag, the condition is defined even when\n\
14333 it is invalid for all current locations.\n\
14334 \n" LOCATION_SPEC_HELP_STRING "\n\n\
14335 Multiple breakpoints at one place are permitted, and useful if their\n\
14336 conditions are different.\n\
14338 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
14340 /* List of subcommands for "catch". */
14341 static struct cmd_list_element
*catch_cmdlist
;
14343 /* List of subcommands for "tcatch". */
14344 static struct cmd_list_element
*tcatch_cmdlist
;
14347 add_catch_command (const char *name
, const char *docstring
,
14348 cmd_func_ftype
*func
,
14349 completer_ftype
*completer
,
14350 void *user_data_catch
,
14351 void *user_data_tcatch
)
14353 struct cmd_list_element
*command
;
14355 command
= add_cmd (name
, class_breakpoint
, docstring
,
14357 command
->func
= func
;
14358 command
->set_context (user_data_catch
);
14359 set_cmd_completer (command
, completer
);
14361 command
= add_cmd (name
, class_breakpoint
, docstring
,
14363 command
->func
= func
;
14364 command
->set_context (user_data_tcatch
);
14365 set_cmd_completer (command
, completer
);
14368 /* False if any of the breakpoint's locations could be a location where
14369 functions have been inlined, true otherwise. */
14372 is_non_inline_function (struct breakpoint
*b
)
14374 /* The shared library event breakpoint is set on the address of a
14375 non-inline function. */
14376 return (b
->type
== bp_shlib_event
);
14379 /* Nonzero if the specified PC cannot be a location where functions
14380 have been inlined. */
14383 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
14384 const target_waitstatus
&ws
)
14386 for (breakpoint
*b
: all_breakpoints ())
14388 if (!is_non_inline_function (b
))
14391 for (bp_location
*bl
: b
->locations ())
14393 if (!bl
->shlib_disabled
14394 && bpstat_check_location (bl
, aspace
, pc
, ws
))
14402 /* Remove any references to OBJFILE which is going to be freed. */
14405 breakpoint_free_objfile (struct objfile
*objfile
)
14407 for (bp_location
*loc
: all_bp_locations ())
14408 if (loc
->symtab
!= NULL
&& loc
->symtab
->compunit ()->objfile () == objfile
)
14409 loc
->symtab
= NULL
;
14412 /* Chain containing all defined "enable breakpoint" subcommands. */
14414 static struct cmd_list_element
*enablebreaklist
= NULL
;
14416 /* See breakpoint.h. */
14418 cmd_list_element
*commands_cmd_element
= nullptr;
14420 void _initialize_breakpoint ();
14422 _initialize_breakpoint ()
14424 struct cmd_list_element
*c
;
14426 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
,
14428 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
,
14430 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
,
14433 breakpoint_chain
= 0;
14434 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
14435 before a breakpoint is set. */
14436 breakpoint_count
= 0;
14438 tracepoint_count
= 0;
14440 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
14441 Set ignore-count of breakpoint number N to COUNT.\n\
14442 Usage is `ignore N COUNT'."));
14444 commands_cmd_element
= add_com ("commands", class_breakpoint
,
14445 commands_command
, _("\
14446 Set commands to be executed when the given breakpoints are hit.\n\
14447 Give a space-separated breakpoint list as argument after \"commands\".\n\
14448 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
14450 With no argument, the targeted breakpoint is the last one set.\n\
14451 The commands themselves follow starting on the next line.\n\
14452 Type a line containing \"end\" to indicate the end of them.\n\
14453 Give \"silent\" as the first line to make the breakpoint silent;\n\
14454 then no output is printed when it is hit, except what the commands print."));
14456 const auto cc_opts
= make_condition_command_options_def_group (nullptr);
14457 static std::string condition_command_help
14458 = gdb::option::build_help (_("\
14459 Specify breakpoint number N to break only if COND is true.\n\
14460 Usage is `condition [OPTION] N COND', where N is an integer and COND\n\
14461 is an expression to be evaluated whenever breakpoint N is reached.\n\
14464 %OPTIONS%"), cc_opts
);
14466 c
= add_com ("condition", class_breakpoint
, condition_command
,
14467 condition_command_help
.c_str ());
14468 set_cmd_completer_handle_brkchars (c
, condition_completer
);
14470 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
14471 Set a temporary breakpoint.\n\
14472 Like \"break\" except the breakpoint is only temporary,\n\
14473 so it will be deleted when hit. Equivalent to \"break\" followed\n\
14474 by using \"enable delete\" on the breakpoint number.\n\
14476 BREAK_ARGS_HELP ("tbreak")));
14477 set_cmd_completer (c
, location_completer
);
14479 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
14480 Set a hardware assisted breakpoint.\n\
14481 Like \"break\" except the breakpoint requires hardware support,\n\
14482 some target hardware may not have this support.\n\
14484 BREAK_ARGS_HELP ("hbreak")));
14485 set_cmd_completer (c
, location_completer
);
14487 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
14488 Set a temporary hardware assisted breakpoint.\n\
14489 Like \"hbreak\" except the breakpoint is only temporary,\n\
14490 so it will be deleted when hit.\n\
14492 BREAK_ARGS_HELP ("thbreak")));
14493 set_cmd_completer (c
, location_completer
);
14495 cmd_list_element
*enable_cmd
14496 = add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
14497 Enable all or some breakpoints.\n\
14498 Usage: enable [BREAKPOINTNUM]...\n\
14499 Give breakpoint numbers (separated by spaces) as arguments.\n\
14500 With no subcommand, breakpoints are enabled until you command otherwise.\n\
14501 This is used to cancel the effect of the \"disable\" command.\n\
14502 With a subcommand you can enable temporarily."),
14503 &enablelist
, 1, &cmdlist
);
14505 add_com_alias ("en", enable_cmd
, class_breakpoint
, 1);
14507 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
14508 Enable all or some breakpoints.\n\
14509 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
14510 Give breakpoint numbers (separated by spaces) as arguments.\n\
14511 This is used to cancel the effect of the \"disable\" command.\n\
14512 May be abbreviated to simply \"enable\"."),
14513 &enablebreaklist
, 1, &enablelist
);
14515 add_cmd ("once", no_class
, enable_once_command
, _("\
14516 Enable some breakpoints for one hit.\n\
14517 Usage: enable breakpoints once BREAKPOINTNUM...\n\
14518 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
14521 add_cmd ("delete", no_class
, enable_delete_command
, _("\
14522 Enable some breakpoints and delete when hit.\n\
14523 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
14524 If a breakpoint is hit while enabled in this fashion, it is deleted."),
14527 add_cmd ("count", no_class
, enable_count_command
, _("\
14528 Enable some breakpoints for COUNT hits.\n\
14529 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
14530 If a breakpoint is hit while enabled in this fashion,\n\
14531 the count is decremented; when it reaches zero, the breakpoint is disabled."),
14534 add_cmd ("delete", no_class
, enable_delete_command
, _("\
14535 Enable some breakpoints and delete when hit.\n\
14536 Usage: enable delete BREAKPOINTNUM...\n\
14537 If a breakpoint is hit while enabled in this fashion, it is deleted."),
14540 add_cmd ("once", no_class
, enable_once_command
, _("\
14541 Enable some breakpoints for one hit.\n\
14542 Usage: enable once BREAKPOINTNUM...\n\
14543 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
14546 add_cmd ("count", no_class
, enable_count_command
, _("\
14547 Enable some breakpoints for COUNT hits.\n\
14548 Usage: enable count COUNT BREAKPOINTNUM...\n\
14549 If a breakpoint is hit while enabled in this fashion,\n\
14550 the count is decremented; when it reaches zero, the breakpoint is disabled."),
14553 cmd_list_element
*disable_cmd
14554 = add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
14555 Disable all or some breakpoints.\n\
14556 Usage: disable [BREAKPOINTNUM]...\n\
14557 Arguments are breakpoint numbers with spaces in between.\n\
14558 To disable all breakpoints, give no argument.\n\
14559 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
14560 &disablelist
, 1, &cmdlist
);
14561 add_com_alias ("dis", disable_cmd
, class_breakpoint
, 1);
14562 add_com_alias ("disa", disable_cmd
, class_breakpoint
, 1);
14564 add_cmd ("breakpoints", class_breakpoint
, disable_command
, _("\
14565 Disable all or some breakpoints.\n\
14566 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
14567 Arguments are breakpoint numbers with spaces in between.\n\
14568 To disable all breakpoints, give no argument.\n\
14569 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
14570 This command may be abbreviated \"disable\"."),
14573 cmd_list_element
*delete_cmd
14574 = add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
14575 Delete all or some breakpoints.\n\
14576 Usage: delete [BREAKPOINTNUM]...\n\
14577 Arguments are breakpoint numbers with spaces in between.\n\
14578 To delete all breakpoints, give no argument.\n\
14580 Also a prefix command for deletion of other GDB objects."),
14581 &deletelist
, 1, &cmdlist
);
14582 add_com_alias ("d", delete_cmd
, class_breakpoint
, 1);
14583 add_com_alias ("del", delete_cmd
, class_breakpoint
, 1);
14585 add_cmd ("breakpoints", class_breakpoint
, delete_command
, _("\
14586 Delete all or some breakpoints or auto-display expressions.\n\
14587 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
14588 Arguments are breakpoint numbers with spaces in between.\n\
14589 To delete all breakpoints, give no argument.\n\
14590 This command may be abbreviated \"delete\"."),
14593 cmd_list_element
*clear_cmd
14594 = add_com ("clear", class_breakpoint
, clear_command
, _("\
14595 Clear breakpoint at specified location.\n\
14596 Argument may be a linespec, explicit, or address location as described below.\n\
14598 With no argument, clears all breakpoints in the line that the selected frame\n\
14599 is executing in.\n"
14600 "\n" LOCATION_SPEC_HELP_STRING
"\n\n\
14601 See also the \"delete\" command which clears breakpoints by number."));
14602 add_com_alias ("cl", clear_cmd
, class_breakpoint
, 1);
14604 cmd_list_element
*break_cmd
14605 = add_com ("break", class_breakpoint
, break_command
, _("\
14606 Set breakpoint at specified location.\n"
14607 BREAK_ARGS_HELP ("break")));
14608 set_cmd_completer (break_cmd
, location_completer
);
14610 add_com_alias ("b", break_cmd
, class_run
, 1);
14611 add_com_alias ("br", break_cmd
, class_run
, 1);
14612 add_com_alias ("bre", break_cmd
, class_run
, 1);
14613 add_com_alias ("brea", break_cmd
, class_run
, 1);
14615 cmd_list_element
*info_breakpoints_cmd
14616 = add_info ("breakpoints", info_breakpoints_command
, _("\
14617 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
14618 The \"Type\" column indicates one of:\n\
14619 \tbreakpoint - normal breakpoint\n\
14620 \twatchpoint - watchpoint\n\
14621 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14622 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14623 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14624 address and file/line number respectively.\n\
14626 Convenience variable \"$_\" and default examine address for \"x\"\n\
14627 are set to the address of the last breakpoint listed unless the command\n\
14628 is prefixed with \"server \".\n\n\
14629 Convenience variable \"$bpnum\" contains the number of the last\n\
14630 breakpoint set."));
14632 add_info_alias ("b", info_breakpoints_cmd
, 1);
14634 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
14635 Status of all breakpoints, or breakpoint number NUMBER.\n\
14636 The \"Type\" column indicates one of:\n\
14637 \tbreakpoint - normal breakpoint\n\
14638 \twatchpoint - watchpoint\n\
14639 \tlongjmp - internal breakpoint used to step through longjmp()\n\
14640 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
14641 \tuntil - internal breakpoint used by the \"until\" command\n\
14642 \tfinish - internal breakpoint used by the \"finish\" command\n\
14643 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14644 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14645 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14646 address and file/line number respectively.\n\
14648 Convenience variable \"$_\" and default examine address for \"x\"\n\
14649 are set to the address of the last breakpoint listed unless the command\n\
14650 is prefixed with \"server \".\n\n\
14651 Convenience variable \"$bpnum\" contains the number of the last\n\
14653 &maintenanceinfolist
);
14655 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
14656 Set catchpoints to catch events."),
14658 0/*allow-unknown*/, &cmdlist
);
14660 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
14661 Set temporary catchpoints to catch events."),
14663 0/*allow-unknown*/, &cmdlist
);
14665 const auto opts
= make_watch_options_def_group (nullptr);
14667 static const std::string watch_help
= gdb::option::build_help (_("\
14668 Set a watchpoint for EXPRESSION.\n\
14669 Usage: watch [-location] EXPRESSION\n\
14674 A watchpoint stops execution of your program whenever the value of\n\
14675 an expression changes."), opts
);
14676 c
= add_com ("watch", class_breakpoint
, watch_command
,
14677 watch_help
.c_str ());
14678 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
14680 static const std::string rwatch_help
= gdb::option::build_help (_("\
14681 Set a read watchpoint for EXPRESSION.\n\
14682 Usage: rwatch [-location] EXPRESSION\n\
14687 A read watchpoint stops execution of your program whenever the value of\n\
14688 an expression is read."), opts
);
14689 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
,
14690 rwatch_help
.c_str ());
14691 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
14693 static const std::string awatch_help
= gdb::option::build_help (_("\
14694 Set an access watchpoint for EXPRESSION.\n\
14695 Usage: awatch [-location] EXPRESSION\n\
14700 An access watchpoint stops execution of your program whenever the value\n\
14701 of an expression is either read or written."), opts
);
14702 c
= add_com ("awatch", class_breakpoint
, awatch_command
,
14703 awatch_help
.c_str ());
14704 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
14706 add_info ("watchpoints", info_watchpoints_command
, _("\
14707 Status of specified watchpoints (all watchpoints if no argument)."));
14709 /* XXX: cagney/2005-02-23: This should be a boolean, and should
14710 respond to changes - contrary to the description. */
14711 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
14712 &can_use_hw_watchpoints
, _("\
14713 Set debugger's willingness to use watchpoint hardware."), _("\
14714 Show debugger's willingness to use watchpoint hardware."), _("\
14715 If zero, gdb will not use hardware for new watchpoints, even if\n\
14716 such is available. (However, any hardware watchpoints that were\n\
14717 created before setting this to nonzero, will continue to use watchpoint\n\
14720 show_can_use_hw_watchpoints
,
14721 &setlist
, &showlist
);
14723 can_use_hw_watchpoints
= 1;
14725 /* Tracepoint manipulation commands. */
14727 cmd_list_element
*trace_cmd
14728 = add_com ("trace", class_breakpoint
, trace_command
, _("\
14729 Set a tracepoint at specified location.\n\
14731 BREAK_ARGS_HELP ("trace") "\n\
14732 Do \"help tracepoints\" for info on other tracepoint commands."));
14733 set_cmd_completer (trace_cmd
, location_completer
);
14735 add_com_alias ("tp", trace_cmd
, class_breakpoint
, 0);
14736 add_com_alias ("tr", trace_cmd
, class_breakpoint
, 1);
14737 add_com_alias ("tra", trace_cmd
, class_breakpoint
, 1);
14738 add_com_alias ("trac", trace_cmd
, class_breakpoint
, 1);
14740 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
14741 Set a fast tracepoint at specified location.\n\
14743 BREAK_ARGS_HELP ("ftrace") "\n\
14744 Do \"help tracepoints\" for info on other tracepoint commands."));
14745 set_cmd_completer (c
, location_completer
);
14747 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
14748 Set a static tracepoint at location or marker.\n\
14750 strace [LOCATION] [if CONDITION]\n\
14751 LOCATION may be a linespec, explicit, or address location (described below) \n\
14752 or -m MARKER_ID.\n\n\
14753 If a marker id is specified, probe the marker with that name. With\n\
14754 no LOCATION, uses current execution address of the selected stack frame.\n\
14755 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
14756 This collects arbitrary user data passed in the probe point call to the\n\
14757 tracing library. You can inspect it when analyzing the trace buffer,\n\
14758 by printing the $_sdata variable like any other convenience variable.\n\
14760 CONDITION is a boolean expression.\n\
14761 \n" LOCATION_SPEC_HELP_STRING
"\n\n\
14762 Multiple tracepoints at one place are permitted, and useful if their\n\
14763 conditions are different.\n\
14765 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
14766 Do \"help tracepoints\" for info on other tracepoint commands."));
14767 set_cmd_completer (c
, location_completer
);
14769 cmd_list_element
*info_tracepoints_cmd
14770 = add_info ("tracepoints", info_tracepoints_command
, _("\
14771 Status of specified tracepoints (all tracepoints if no argument).\n\
14772 Convenience variable \"$tpnum\" contains the number of the\n\
14773 last tracepoint set."));
14775 add_info_alias ("tp", info_tracepoints_cmd
, 1);
14777 cmd_list_element
*delete_tracepoints_cmd
14778 = add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
14779 Delete specified tracepoints.\n\
14780 Arguments are tracepoint numbers, separated by spaces.\n\
14781 No argument means delete all tracepoints."),
14783 add_alias_cmd ("tr", delete_tracepoints_cmd
, class_trace
, 1, &deletelist
);
14785 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
14786 Disable specified tracepoints.\n\
14787 Arguments are tracepoint numbers, separated by spaces.\n\
14788 No argument means disable all tracepoints."),
14790 deprecate_cmd (c
, "disable");
14792 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
14793 Enable specified tracepoints.\n\
14794 Arguments are tracepoint numbers, separated by spaces.\n\
14795 No argument means enable all tracepoints."),
14797 deprecate_cmd (c
, "enable");
14799 add_com ("passcount", class_trace
, trace_pass_command
, _("\
14800 Set the passcount for a tracepoint.\n\
14801 The trace will end when the tracepoint has been passed 'count' times.\n\
14802 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
14803 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
14805 add_basic_prefix_cmd ("save", class_breakpoint
,
14806 _("Save breakpoint definitions as a script."),
14808 0/*allow-unknown*/, &cmdlist
);
14810 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
14811 Save current breakpoint definitions as a script.\n\
14812 This includes all types of breakpoints (breakpoints, watchpoints,\n\
14813 catchpoints, tracepoints). Use the 'source' command in another debug\n\
14814 session to restore them."),
14816 set_cmd_completer (c
, filename_completer
);
14818 cmd_list_element
*save_tracepoints_cmd
14819 = add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
14820 Save current tracepoint definitions as a script.\n\
14821 Use the 'source' command in another debug session to restore them."),
14823 set_cmd_completer (save_tracepoints_cmd
, filename_completer
);
14825 c
= add_com_alias ("save-tracepoints", save_tracepoints_cmd
, class_trace
, 0);
14826 deprecate_cmd (c
, "save tracepoints");
14828 add_setshow_prefix_cmd ("breakpoint", class_maintenance
,
14830 Breakpoint specific settings.\n\
14831 Configure various breakpoint-specific variables such as\n\
14832 pending breakpoint behavior."),
14834 Breakpoint specific settings.\n\
14835 Configure various breakpoint-specific variables such as\n\
14836 pending breakpoint behavior."),
14837 &breakpoint_set_cmdlist
, &breakpoint_show_cmdlist
,
14838 &setlist
, &showlist
);
14840 add_setshow_auto_boolean_cmd ("pending", no_class
,
14841 &pending_break_support
, _("\
14842 Set debugger's behavior regarding pending breakpoints."), _("\
14843 Show debugger's behavior regarding pending breakpoints."), _("\
14844 If on, an unrecognized breakpoint location will cause gdb to create a\n\
14845 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
14846 an error. If auto, an unrecognized breakpoint location results in a\n\
14847 user-query to see if a pending breakpoint should be created."),
14849 show_pending_break_support
,
14850 &breakpoint_set_cmdlist
,
14851 &breakpoint_show_cmdlist
);
14853 pending_break_support
= AUTO_BOOLEAN_AUTO
;
14855 add_setshow_boolean_cmd ("auto-hw", no_class
,
14856 &automatic_hardware_breakpoints
, _("\
14857 Set automatic usage of hardware breakpoints."), _("\
14858 Show automatic usage of hardware breakpoints."), _("\
14859 If set, the debugger will automatically use hardware breakpoints for\n\
14860 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
14861 a warning will be emitted for such breakpoints."),
14863 show_automatic_hardware_breakpoints
,
14864 &breakpoint_set_cmdlist
,
14865 &breakpoint_show_cmdlist
);
14867 add_setshow_boolean_cmd ("always-inserted", class_support
,
14868 &always_inserted_mode
, _("\
14869 Set mode for inserting breakpoints."), _("\
14870 Show mode for inserting breakpoints."), _("\
14871 When this mode is on, breakpoints are inserted immediately as soon as\n\
14872 they're created, kept inserted even when execution stops, and removed\n\
14873 only when the user deletes them. When this mode is off (the default),\n\
14874 breakpoints are inserted only when execution continues, and removed\n\
14875 when execution stops."),
14877 &show_always_inserted_mode
,
14878 &breakpoint_set_cmdlist
,
14879 &breakpoint_show_cmdlist
);
14881 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
14882 condition_evaluation_enums
,
14883 &condition_evaluation_mode_1
, _("\
14884 Set mode of breakpoint condition evaluation."), _("\
14885 Show mode of breakpoint condition evaluation."), _("\
14886 When this is set to \"host\", breakpoint conditions will be\n\
14887 evaluated on the host's side by GDB. When it is set to \"target\",\n\
14888 breakpoint conditions will be downloaded to the target (if the target\n\
14889 supports such feature) and conditions will be evaluated on the target's side.\n\
14890 If this is set to \"auto\" (default), this will be automatically set to\n\
14891 \"target\" if it supports condition evaluation, otherwise it will\n\
14892 be set to \"host\"."),
14893 &set_condition_evaluation_mode
,
14894 &show_condition_evaluation_mode
,
14895 &breakpoint_set_cmdlist
,
14896 &breakpoint_show_cmdlist
);
14898 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
14899 Set a breakpoint for an address range.\n\
14900 break-range START-LOCATION, END-LOCATION\n\
14901 where START-LOCATION and END-LOCATION can be one of the following:\n\
14902 LINENUM, for that line in the current file,\n\
14903 FILE:LINENUM, for that line in that file,\n\
14904 +OFFSET, for that number of lines after the current line\n\
14905 or the start of the range\n\
14906 FUNCTION, for the first line in that function,\n\
14907 FILE:FUNCTION, to distinguish among like-named static functions.\n\
14908 *ADDRESS, for the instruction at that address.\n\
14910 The breakpoint will stop execution of the inferior whenever it executes\n\
14911 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
14912 range (including START-LOCATION and END-LOCATION)."));
14914 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
14915 Set a dynamic printf at specified location.\n\
14916 dprintf location,format string,arg1,arg2,...\n\
14917 location may be a linespec, explicit, or address location.\n"
14918 "\n" LOCATION_SPEC_HELP_STRING
));
14919 set_cmd_completer (c
, location_completer
);
14921 add_setshow_enum_cmd ("dprintf-style", class_support
,
14922 dprintf_style_enums
, &dprintf_style
, _("\
14923 Set the style of usage for dynamic printf."), _("\
14924 Show the style of usage for dynamic printf."), _("\
14925 This setting chooses how GDB will do a dynamic printf.\n\
14926 If the value is \"gdb\", then the printing is done by GDB to its own\n\
14927 console, as with the \"printf\" command.\n\
14928 If the value is \"call\", the print is done by calling a function in your\n\
14929 program; by default printf(), but you can choose a different function or\n\
14930 output stream by setting dprintf-function and dprintf-channel."),
14931 update_dprintf_commands
, NULL
,
14932 &setlist
, &showlist
);
14934 add_setshow_string_cmd ("dprintf-function", class_support
,
14935 &dprintf_function
, _("\
14936 Set the function to use for dynamic printf."), _("\
14937 Show the function to use for dynamic printf."), NULL
,
14938 update_dprintf_commands
, NULL
,
14939 &setlist
, &showlist
);
14941 add_setshow_string_cmd ("dprintf-channel", class_support
,
14942 &dprintf_channel
, _("\
14943 Set the channel to use for dynamic printf."), _("\
14944 Show the channel to use for dynamic printf."), NULL
,
14945 update_dprintf_commands
, NULL
,
14946 &setlist
, &showlist
);
14948 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
14949 &disconnected_dprintf
, _("\
14950 Set whether dprintf continues after GDB disconnects."), _("\
14951 Show whether dprintf continues after GDB disconnects."), _("\
14952 Use this to let dprintf commands continue to hit and produce output\n\
14953 even if GDB disconnects or detaches from the target."),
14956 &setlist
, &showlist
);
14958 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
14959 Target agent only formatted printing, like the C \"printf\" function.\n\
14960 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
14961 This supports most C printf format specifications, like %s, %d, etc.\n\
14962 This is useful for formatted output in user-defined commands."));
14964 automatic_hardware_breakpoints
= true;
14966 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
,
14968 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
,