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
= value::allocate (val
->type ());
1869 val
->unpack_bitfield (bit_val
,
1872 val
->contents_for_printing ().data (),
1878 /* Allocate a dummy location and add it to B. This is required
1879 because bpstat_stop_status requires a location to be able to report
1883 add_dummy_location (struct breakpoint
*b
,
1884 struct program_space
*pspace
)
1886 gdb_assert (b
->loc
== NULL
);
1888 b
->loc
= new bp_location (b
, bp_loc_other
);
1889 b
->loc
->pspace
= pspace
;
1892 /* Assuming that B is a watchpoint:
1893 - Reparse watchpoint expression, if REPARSE is true
1894 - Evaluate expression and store the result in B->val
1895 - Evaluate the condition if there is one, and store the result
1897 - Update the list of values that must be watched in B->loc.
1899 If the watchpoint disposition is disp_del_at_next_stop, then do
1900 nothing. If this is local watchpoint that is out of scope, delete
1903 Even with `set breakpoint always-inserted on' the watchpoints are
1904 removed + inserted on each stop here. Normal breakpoints must
1905 never be removed because they might be missed by a running thread
1906 when debugging in non-stop mode. On the other hand, hardware
1907 watchpoints (is_hardware_watchpoint; processed here) are specific
1908 to each LWP since they are stored in each LWP's hardware debug
1909 registers. Therefore, such LWP must be stopped first in order to
1910 be able to modify its hardware watchpoints.
1912 Hardware watchpoints must be reset exactly once after being
1913 presented to the user. It cannot be done sooner, because it would
1914 reset the data used to present the watchpoint hit to the user. And
1915 it must not be done later because it could display the same single
1916 watchpoint hit during multiple GDB stops. Note that the latter is
1917 relevant only to the hardware watchpoint types bp_read_watchpoint
1918 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1919 not user-visible - its hit is suppressed if the memory content has
1922 The following constraints influence the location where we can reset
1923 hardware watchpoints:
1925 * target_stopped_by_watchpoint and target_stopped_data_address are
1926 called several times when GDB stops.
1929 * Multiple hardware watchpoints can be hit at the same time,
1930 causing GDB to stop. GDB only presents one hardware watchpoint
1931 hit at a time as the reason for stopping, and all the other hits
1932 are presented later, one after the other, each time the user
1933 requests the execution to be resumed. Execution is not resumed
1934 for the threads still having pending hit event stored in
1935 LWP_INFO->STATUS. While the watchpoint is already removed from
1936 the inferior on the first stop the thread hit event is kept being
1937 reported from its cached value by linux_nat_stopped_data_address
1938 until the real thread resume happens after the watchpoint gets
1939 presented and thus its LWP_INFO->STATUS gets reset.
1941 Therefore the hardware watchpoint hit can get safely reset on the
1942 watchpoint removal from inferior. */
1945 update_watchpoint (struct watchpoint
*b
, bool reparse
)
1947 bool within_current_scope
;
1949 /* If this is a local watchpoint, we only want to check if the
1950 watchpoint frame is in scope if the current thread is the thread
1951 that was used to create the watchpoint. */
1952 if (!watchpoint_in_thread_scope (b
))
1955 if (b
->disposition
== disp_del_at_next_stop
)
1958 gdb::optional
<scoped_restore_selected_frame
> restore_frame
;
1960 /* Determine if the watchpoint is within scope. */
1961 if (b
->exp_valid_block
== NULL
)
1962 within_current_scope
= true;
1965 frame_info_ptr fi
= get_current_frame ();
1966 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1967 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1969 /* If we're at a point where the stack has been destroyed
1970 (e.g. in a function epilogue), unwinding may not work
1971 properly. Do not attempt to recreate locations at this
1972 point. See similar comments in watchpoint_check. */
1973 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1976 /* Save the current frame's ID so we can restore it after
1977 evaluating the watchpoint expression on its own frame. */
1978 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1979 took a frame parameter, so that we didn't have to change the
1981 restore_frame
.emplace ();
1983 fi
= frame_find_by_id (b
->watchpoint_frame
);
1984 within_current_scope
= (fi
!= NULL
);
1985 if (within_current_scope
)
1989 /* We don't free locations. They are stored in the bp_location array
1990 and update_global_location_list will eventually delete them and
1991 remove breakpoints if needed. */
1994 if (within_current_scope
&& reparse
)
1999 s
= (b
->exp_string_reparse
2000 ? b
->exp_string_reparse
.get ()
2001 : b
->exp_string
.get ());
2002 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
2003 /* If the meaning of expression itself changed, the old value is
2004 no longer relevant. We don't want to report a watchpoint hit
2005 to the user when the old value and the new value may actually
2006 be completely different objects. */
2008 b
->val_valid
= false;
2010 /* Note that unlike with breakpoints, the watchpoint's condition
2011 expression is stored in the breakpoint object, not in the
2012 locations (re)created below. */
2013 if (b
->cond_string
!= NULL
)
2015 b
->cond_exp
.reset ();
2017 s
= b
->cond_string
.get ();
2018 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
2022 /* If we failed to parse the expression, for example because
2023 it refers to a global variable in a not-yet-loaded shared library,
2024 don't try to insert watchpoint. We don't automatically delete
2025 such watchpoint, though, since failure to parse expression
2026 is different from out-of-scope watchpoint. */
2027 if (!target_has_execution ())
2029 /* Without execution, memory can't change. No use to try and
2030 set watchpoint locations. The watchpoint will be reset when
2031 the target gains execution, through breakpoint_re_set. */
2032 if (!can_use_hw_watchpoints
)
2034 if (b
->works_in_software_mode ())
2035 b
->type
= bp_watchpoint
;
2037 error (_("Can't set read/access watchpoint when "
2038 "hardware watchpoints are disabled."));
2041 else if (within_current_scope
&& b
->exp
)
2043 std::vector
<value_ref_ptr
> val_chain
;
2044 struct value
*v
, *result
;
2045 struct program_space
*frame_pspace
;
2047 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &v
, &result
,
2050 /* Avoid setting b->val if it's already set. The meaning of
2051 b->val is 'the last value' user saw, and we should update
2052 it only if we reported that last value to user. As it
2053 happens, the code that reports it updates b->val directly.
2054 We don't keep track of the memory value for masked
2056 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
2058 if (b
->val_bitsize
!= 0)
2059 v
= extract_bitfield_from_watchpoint_value (b
, v
);
2060 b
->val
= release_value (v
);
2061 b
->val_valid
= true;
2064 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
2066 /* Look at each value on the value chain. */
2067 gdb_assert (!val_chain
.empty ());
2068 for (const value_ref_ptr
&iter
: val_chain
)
2072 /* If it's a memory location, and GDB actually needed
2073 its contents to evaluate the expression, then we
2074 must watch it. If the first value returned is
2075 still lazy, that means an error occurred reading it;
2076 watch it anyway in case it becomes readable. */
2077 if (v
->lval () == lval_memory
2078 && (v
== val_chain
[0] || ! v
->lazy ()))
2080 struct type
*vtype
= check_typedef (v
->type ());
2082 /* We only watch structs and arrays if user asked
2083 for it explicitly, never if they just happen to
2084 appear in the middle of some value chain. */
2086 || (vtype
->code () != TYPE_CODE_STRUCT
2087 && vtype
->code () != TYPE_CODE_ARRAY
))
2090 enum target_hw_bp_type type
;
2091 struct bp_location
*loc
, **tmp
;
2092 int bitpos
= 0, bitsize
= 0;
2094 if (v
->bitsize () != 0)
2096 /* Extract the bit parameters out from the bitfield
2098 bitpos
= v
->bitpos ();
2099 bitsize
= v
->bitsize ();
2101 else if (v
== result
&& b
->val_bitsize
!= 0)
2103 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
2104 lvalue whose bit parameters are saved in the fields
2105 VAL_BITPOS and VAL_BITSIZE. */
2106 bitpos
= b
->val_bitpos
;
2107 bitsize
= b
->val_bitsize
;
2110 addr
= v
->address ();
2113 /* Skip the bytes that don't contain the bitfield. */
2118 if (b
->type
== bp_read_watchpoint
)
2120 else if (b
->type
== bp_access_watchpoint
)
2123 loc
= b
->allocate_location ();
2124 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
2127 loc
->gdbarch
= v
->type ()->arch ();
2129 loc
->pspace
= frame_pspace
;
2131 = gdbarch_remove_non_address_bits (loc
->gdbarch
, addr
);
2135 /* Just cover the bytes that make up the bitfield. */
2136 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
2139 loc
->length
= v
->type ()->length ();
2141 loc
->watchpoint_type
= type
;
2146 /* Change the type of breakpoint between hardware assisted or
2147 an ordinary watchpoint depending on the hardware support and
2148 free hardware slots. Recheck the number of free hardware slots
2149 as the value chain may have changed. */
2152 enum bp_loc_type loc_type
;
2154 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2158 int i
, target_resources_ok
, other_type_used
;
2161 /* Use an exact watchpoint when there's only one memory region to be
2162 watched, and only one debug register is needed to watch it. */
2163 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2165 /* We need to determine how many resources are already
2166 used for all other hardware watchpoints plus this one
2167 to see if we still have enough resources to also fit
2168 this watchpoint in as well. */
2170 /* If this is a software watchpoint, we try to turn it
2171 to a hardware one -- count resources as if B was of
2172 hardware watchpoint type. */
2174 if (type
== bp_watchpoint
)
2175 type
= bp_hardware_watchpoint
;
2177 /* This watchpoint may or may not have been placed on
2178 the list yet at this point (it won't be in the list
2179 if we're trying to create it for the first time,
2180 through watch_command), so always account for it
2183 /* Count resources used by all watchpoints except B. */
2184 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
2186 /* Add in the resources needed for B. */
2187 i
+= hw_watchpoint_use_count (b
);
2190 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2191 if (target_resources_ok
<= 0)
2193 bool sw_mode
= b
->works_in_software_mode ();
2195 if (target_resources_ok
== 0 && !sw_mode
)
2196 error (_("Target does not support this type of "
2197 "hardware watchpoint."));
2198 else if (target_resources_ok
< 0 && !sw_mode
)
2199 error (_("There are not enough available hardware "
2200 "resources for this watchpoint."));
2202 /* Downgrade to software watchpoint. */
2203 b
->type
= bp_watchpoint
;
2207 /* If this was a software watchpoint, we've just
2208 found we have enough resources to turn it to a
2209 hardware watchpoint. Otherwise, this is a
2214 else if (!b
->works_in_software_mode ())
2216 if (!can_use_hw_watchpoints
)
2217 error (_("Can't set read/access watchpoint when "
2218 "hardware watchpoints are disabled."));
2220 error (_("Expression cannot be implemented with "
2221 "read/access watchpoint."));
2224 b
->type
= bp_watchpoint
;
2226 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_software_watchpoint
2227 : bp_loc_hardware_watchpoint
);
2228 for (bp_location
*bl
: b
->locations ())
2229 bl
->loc_type
= loc_type
;
2232 /* If a software watchpoint is not watching any memory, then the
2233 above left it without any location set up. But,
2234 bpstat_stop_status requires a location to be able to report
2235 stops, so make sure there's at least a dummy one. */
2236 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2237 add_dummy_location (b
, frame_pspace
);
2239 else if (!within_current_scope
)
2242 Watchpoint %d deleted because the program has left the block\n\
2243 in which its expression is valid.\n"),
2245 watchpoint_del_at_next_stop (b
);
2249 /* Returns true iff breakpoint location should be
2250 inserted in the inferior. We don't differentiate the type of BL's owner
2251 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2252 breakpoint_ops is not defined, because in insert_bp_location,
2253 tracepoint's insert_location will not be called. */
2256 should_be_inserted (struct bp_location
*bl
)
2258 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2261 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2264 if (!bl
->enabled
|| bl
->disabled_by_cond
2265 || bl
->shlib_disabled
|| bl
->duplicate
)
2268 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2271 /* This is set for example, when we're attached to the parent of a
2272 vfork, and have detached from the child. The child is running
2273 free, and we expect it to do an exec or exit, at which point the
2274 OS makes the parent schedulable again (and the target reports
2275 that the vfork is done). Until the child is done with the shared
2276 memory region, do not insert breakpoints in the parent, otherwise
2277 the child could still trip on the parent's breakpoints. Since
2278 the parent is blocked anyway, it won't miss any breakpoint. */
2279 if (bl
->pspace
->breakpoints_not_allowed
)
2282 /* Don't insert a breakpoint if we're trying to step past its
2283 location, except if the breakpoint is a single-step breakpoint,
2284 and the breakpoint's thread is the thread which is stepping past
2286 if ((bl
->loc_type
== bp_loc_software_breakpoint
2287 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2288 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2290 /* The single-step breakpoint may be inserted at the location
2291 we're trying to step if the instruction branches to itself.
2292 However, the instruction won't be executed at all and it may
2293 break the semantics of the instruction, for example, the
2294 instruction is a conditional branch or updates some flags.
2295 We can't fix it unless GDB is able to emulate the instruction
2296 or switch to displaced stepping. */
2297 && !(bl
->owner
->type
== bp_single_step
2298 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2300 infrun_debug_printf ("skipping breakpoint: stepping past insn at: %s",
2301 paddress (bl
->gdbarch
, bl
->address
));
2305 /* Don't insert watchpoints if we're trying to step past the
2306 instruction that triggered one. */
2307 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2308 && stepping_past_nonsteppable_watchpoint ())
2310 infrun_debug_printf ("stepping past non-steppable watchpoint. "
2311 "skipping watchpoint at %s:%d",
2312 paddress (bl
->gdbarch
, bl
->address
), bl
->length
);
2319 /* Same as should_be_inserted but does the check assuming
2320 that the location is not duplicated. */
2323 unduplicated_should_be_inserted (struct bp_location
*bl
)
2325 scoped_restore restore_bl_duplicate
2326 = make_scoped_restore (&bl
->duplicate
, 0);
2328 return should_be_inserted (bl
);
2331 /* Parses a conditional described by an expression COND into an
2332 agent expression bytecode suitable for evaluation
2333 by the bytecode interpreter. Return NULL if there was
2334 any error during parsing. */
2336 static agent_expr_up
2337 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2342 agent_expr_up aexpr
;
2344 /* We don't want to stop processing, so catch any errors
2345 that may show up. */
2348 aexpr
= gen_eval_for_expr (scope
, cond
);
2351 catch (const gdb_exception_error
&ex
)
2353 /* If we got here, it means the condition could not be parsed to a valid
2354 bytecode expression and thus can't be evaluated on the target's side.
2355 It's no use iterating through the conditions. */
2358 /* We have a valid agent expression. */
2362 /* Based on location BL, create a list of breakpoint conditions to be
2363 passed on to the target. If we have duplicated locations with different
2364 conditions, we will add such conditions to the list. The idea is that the
2365 target will evaluate the list of conditions and will only notify GDB when
2366 one of them is true. */
2369 build_target_condition_list (struct bp_location
*bl
)
2371 bool null_condition_or_parse_error
= false;
2372 int modified
= bl
->needs_update
;
2374 /* Release conditions left over from a previous insert. */
2375 bl
->target_info
.conditions
.clear ();
2377 /* This is only meaningful if the target is
2378 evaluating conditions and if the user has
2379 opted for condition evaluation on the target's
2381 if (gdb_evaluates_breakpoint_condition_p ()
2382 || !target_supports_evaluation_of_breakpoint_conditions ())
2385 auto loc_range
= all_bp_locations_at_addr (bl
->address
);
2387 /* Do a first pass to check for locations with no assigned
2388 conditions or conditions that fail to parse to a valid agent
2389 expression bytecode. If any of these happen, then it's no use to
2390 send conditions to the target since this location will always
2391 trigger and generate a response back to GDB. Note we consider
2392 all locations at the same address irrespective of type, i.e.,
2393 even if the locations aren't considered duplicates (e.g.,
2394 software breakpoint and hardware breakpoint at the same
2396 for (bp_location
*loc
: loc_range
)
2398 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2402 /* Re-parse the conditions since something changed. In that
2403 case we already freed the condition bytecodes (see
2404 force_breakpoint_reinsertion). We just
2405 need to parse the condition to bytecodes again. */
2406 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2410 /* If we have a NULL bytecode expression, it means something
2411 went wrong or we have a null condition expression. */
2412 if (!loc
->cond_bytecode
)
2414 null_condition_or_parse_error
= true;
2420 /* If any of these happened, it means we will have to evaluate the conditions
2421 for the location's address on gdb's side. It is no use keeping bytecodes
2422 for all the other duplicate locations, thus we free all of them here.
2424 This is so we have a finer control over which locations' conditions are
2425 being evaluated by GDB or the remote stub. */
2426 if (null_condition_or_parse_error
)
2428 for (bp_location
*loc
: loc_range
)
2430 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2432 /* Only go as far as the first NULL bytecode is
2434 if (!loc
->cond_bytecode
)
2437 loc
->cond_bytecode
.reset ();
2442 /* No NULL conditions or failed bytecode generation. Build a
2443 condition list for this location's address. If we have software
2444 and hardware locations at the same address, they aren't
2445 considered duplicates, but we still marge all the conditions
2446 anyway, as it's simpler, and doesn't really make a practical
2448 for (bp_location
*loc
: loc_range
)
2450 && is_breakpoint (loc
->owner
)
2451 && loc
->pspace
->num
== bl
->pspace
->num
2452 && loc
->owner
->enable_state
== bp_enabled
2454 && !loc
->disabled_by_cond
)
2456 /* Add the condition to the vector. This will be used later
2457 to send the conditions to the target. */
2458 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2464 /* Parses a command described by string CMD into an agent expression
2465 bytecode suitable for evaluation by the bytecode interpreter.
2466 Return NULL if there was any error during parsing. */
2468 static agent_expr_up
2469 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2471 const char *cmdrest
;
2472 const char *format_start
, *format_end
;
2473 struct gdbarch
*gdbarch
= get_current_arch ();
2480 if (*cmdrest
== ',')
2482 cmdrest
= skip_spaces (cmdrest
);
2484 if (*cmdrest
++ != '"')
2485 error (_("No format string following the location"));
2487 format_start
= cmdrest
;
2489 format_pieces
fpieces (&cmdrest
);
2491 format_end
= cmdrest
;
2493 if (*cmdrest
++ != '"')
2494 error (_("Bad format string, non-terminated '\"'."));
2496 cmdrest
= skip_spaces (cmdrest
);
2498 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2499 error (_("Invalid argument syntax"));
2501 if (*cmdrest
== ',')
2503 cmdrest
= skip_spaces (cmdrest
);
2505 /* For each argument, make an expression. */
2507 std::vector
<struct expression
*> argvec
;
2508 while (*cmdrest
!= '\0')
2513 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2514 argvec
.push_back (expr
.release ());
2516 if (*cmdrest
== ',')
2520 agent_expr_up aexpr
;
2522 /* We don't want to stop processing, so catch any errors
2523 that may show up. */
2526 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2527 format_start
, format_end
- format_start
,
2528 argvec
.size (), argvec
.data ());
2530 catch (const gdb_exception_error
&ex
)
2532 /* If we got here, it means the command could not be parsed to a valid
2533 bytecode expression and thus can't be evaluated on the target's side.
2534 It's no use iterating through the other commands. */
2537 /* We have a valid agent expression, return it. */
2541 /* Based on location BL, create a list of breakpoint commands to be
2542 passed on to the target. If we have duplicated locations with
2543 different commands, we will add any such to the list. */
2546 build_target_command_list (struct bp_location
*bl
)
2548 bool null_command_or_parse_error
= false;
2549 int modified
= bl
->needs_update
;
2551 /* Clear commands left over from a previous insert. */
2552 bl
->target_info
.tcommands
.clear ();
2554 if (!target_can_run_breakpoint_commands ())
2557 /* For now, limit to agent-style dprintf breakpoints. */
2558 if (dprintf_style
!= dprintf_style_agent
)
2561 auto loc_range
= all_bp_locations_at_addr (bl
->address
);
2563 /* For now, if we have any location at the same address that isn't a
2564 dprintf, don't install the target-side commands, as that would
2565 make the breakpoint not be reported to the core, and we'd lose
2567 for (bp_location
*loc
: loc_range
)
2568 if (is_breakpoint (loc
->owner
)
2569 && loc
->pspace
->num
== bl
->pspace
->num
2570 && loc
->owner
->type
!= bp_dprintf
)
2573 /* Do a first pass to check for locations with no assigned
2574 conditions or conditions that fail to parse to a valid agent expression
2575 bytecode. If any of these happen, then it's no use to send conditions
2576 to the target since this location will always trigger and generate a
2577 response back to GDB. */
2578 for (bp_location
*loc
: loc_range
)
2580 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2584 /* Re-parse the commands since something changed. In that
2585 case we already freed the command bytecodes (see
2586 force_breakpoint_reinsertion). We just
2587 need to parse the command to bytecodes again. */
2589 = parse_cmd_to_aexpr (bl
->address
,
2590 loc
->owner
->extra_string
.get ());
2593 /* If we have a NULL bytecode expression, it means something
2594 went wrong or we have a null command expression. */
2595 if (!loc
->cmd_bytecode
)
2597 null_command_or_parse_error
= true;
2603 /* If anything failed, then we're not doing target-side commands,
2605 if (null_command_or_parse_error
)
2607 for (bp_location
*loc
: loc_range
)
2608 if (is_breakpoint (loc
->owner
)
2609 && loc
->pspace
->num
== bl
->pspace
->num
)
2611 /* Only go as far as the first NULL bytecode is
2613 if (loc
->cmd_bytecode
== NULL
)
2616 loc
->cmd_bytecode
.reset ();
2620 /* No NULL commands or failed bytecode generation. Build a command
2621 list for all duplicate locations at this location's address.
2622 Note that here we must care for whether the breakpoint location
2623 types are considered duplicates, otherwise, say, if we have a
2624 software and hardware location at the same address, the target
2625 could end up running the commands twice. For the moment, we only
2626 support targets-side commands with dprintf, but it doesn't hurt
2627 to be pedantically correct in case that changes. */
2628 for (bp_location
*loc
: loc_range
)
2629 if (breakpoint_locations_match (bl
, loc
)
2630 && loc
->owner
->extra_string
2631 && is_breakpoint (loc
->owner
)
2632 && loc
->pspace
->num
== bl
->pspace
->num
2633 && loc
->owner
->enable_state
== bp_enabled
2635 && !loc
->disabled_by_cond
)
2637 /* Add the command to the vector. This will be used later
2638 to send the commands to the target. */
2639 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2642 bl
->target_info
.persist
= 0;
2643 /* Maybe flag this location as persistent. */
2644 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2645 bl
->target_info
.persist
= 1;
2648 /* Return the kind of breakpoint on address *ADDR. Get the kind
2649 of breakpoint according to ADDR except single-step breakpoint.
2650 Get the kind of single-step breakpoint according to the current
2654 breakpoint_kind (const struct bp_location
*bl
, CORE_ADDR
*addr
)
2656 if (bl
->owner
->type
== bp_single_step
)
2658 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2659 struct regcache
*regcache
;
2661 regcache
= get_thread_regcache (thr
);
2663 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2667 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2670 /* Rethrow the currently handled exception, if it's a TARGET_CLOSE_ERROR.
2671 E is either the currently handled exception, or a copy, or a sliced copy,
2672 so we can't rethrow that one, but we can use it to inspect the properties
2673 of the currently handled exception. */
2676 rethrow_on_target_close_error (const gdb_exception
&e
)
2680 /* Can't set the breakpoint. */
2682 if (e
.error
!= TARGET_CLOSE_ERROR
)
2685 /* If the target has closed then it will have deleted any breakpoints
2686 inserted within the target inferior, as a result any further attempts
2687 to interact with the breakpoint objects is not possible. Just rethrow
2688 the error. Don't use e to rethrow, to prevent object slicing of the
2693 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2694 location. Any error messages are printed to TMP_ERROR_STREAM; and
2695 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2696 Returns 0 for success, 1 if the bp_location type is not supported or
2699 NOTE drow/2003-09-09: This routine could be broken down to an
2700 object-style method for each breakpoint or catchpoint type. */
2702 insert_bp_location (struct bp_location
*bl
,
2703 struct ui_file
*tmp_error_stream
,
2704 int *disabled_breaks
,
2705 int *hw_breakpoint_error
,
2706 int *hw_bp_error_explained_already
)
2708 gdb_exception bp_excpt
;
2710 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2713 /* Note we don't initialize bl->target_info, as that wipes out
2714 the breakpoint location's shadow_contents if the breakpoint
2715 is still inserted at that location. This in turn breaks
2716 target_read_memory which depends on these buffers when
2717 a memory read is requested at the breakpoint location:
2718 Once the target_info has been wiped, we fail to see that
2719 we have a breakpoint inserted at that address and thus
2720 read the breakpoint instead of returning the data saved in
2721 the breakpoint location's shadow contents. */
2722 bl
->target_info
.reqstd_address
= bl
->address
;
2723 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2724 bl
->target_info
.length
= bl
->length
;
2726 /* When working with target-side conditions, we must pass all the conditions
2727 for the same breakpoint address down to the target since GDB will not
2728 insert those locations. With a list of breakpoint conditions, the target
2729 can decide when to stop and notify GDB. */
2731 if (is_breakpoint (bl
->owner
))
2733 build_target_condition_list (bl
);
2734 build_target_command_list (bl
);
2735 /* Reset the modification marker. */
2736 bl
->needs_update
= 0;
2739 /* If "set breakpoint auto-hw" is "on" and a software breakpoint was
2740 set at a read-only address, then a breakpoint location will have
2741 been changed to hardware breakpoint before we get here. If it is
2742 "off" however, error out before actually trying to insert the
2743 breakpoint, with a nicer error message. */
2744 if (bl
->loc_type
== bp_loc_software_breakpoint
2745 && !automatic_hardware_breakpoints
)
2747 mem_region
*mr
= lookup_mem_region (bl
->address
);
2749 if (mr
!= nullptr && mr
->attrib
.mode
!= MEM_RW
)
2751 gdb_printf (tmp_error_stream
,
2752 _("Cannot insert breakpoint %d.\n"
2753 "Cannot set software breakpoint "
2754 "at read-only address %s\n"),
2756 paddress (bl
->gdbarch
, bl
->address
));
2761 if (bl
->loc_type
== bp_loc_software_breakpoint
2762 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2764 /* First check to see if we have to handle an overlay. */
2765 if (overlay_debugging
== ovly_off
2766 || bl
->section
== NULL
2767 || !(section_is_overlay (bl
->section
)))
2769 /* No overlay handling: just set the breakpoint. */
2774 val
= bl
->owner
->insert_location (bl
);
2776 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2778 catch (gdb_exception
&e
)
2780 rethrow_on_target_close_error (e
);
2781 bp_excpt
= std::move (e
);
2786 /* This breakpoint is in an overlay section.
2787 Shall we set a breakpoint at the LMA? */
2788 if (!overlay_events_enabled
)
2790 /* Yes -- overlay event support is not active,
2791 so we must try to set a breakpoint at the LMA.
2792 This will not work for a hardware breakpoint. */
2793 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2794 warning (_("hardware breakpoint %d not supported in overlay!"),
2798 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2800 /* Set a software (trap) breakpoint at the LMA. */
2801 bl
->overlay_target_info
= bl
->target_info
;
2802 bl
->overlay_target_info
.reqstd_address
= addr
;
2804 /* No overlay handling: just set the breakpoint. */
2809 bl
->overlay_target_info
.kind
2810 = breakpoint_kind (bl
, &addr
);
2811 bl
->overlay_target_info
.placed_address
= addr
;
2812 val
= target_insert_breakpoint (bl
->gdbarch
,
2813 &bl
->overlay_target_info
);
2816 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2818 catch (gdb_exception
&e
)
2820 rethrow_on_target_close_error (e
);
2821 bp_excpt
= std::move (e
);
2824 if (bp_excpt
.reason
!= 0)
2825 gdb_printf (tmp_error_stream
,
2826 "Overlay breakpoint %d "
2827 "failed: in ROM?\n",
2831 /* Shall we set a breakpoint at the VMA? */
2832 if (section_is_mapped (bl
->section
))
2834 /* Yes. This overlay section is mapped into memory. */
2839 val
= bl
->owner
->insert_location (bl
);
2841 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2843 catch (gdb_exception
&e
)
2845 rethrow_on_target_close_error (e
);
2846 bp_excpt
= std::move (e
);
2851 /* No. This breakpoint will not be inserted.
2852 No error, but do not mark the bp as 'inserted'. */
2857 if (bp_excpt
.reason
!= 0)
2859 /* Can't set the breakpoint. */
2860 gdb_assert (bl
->owner
!= nullptr);
2862 /* In some cases, we might not be able to insert a
2863 breakpoint in a shared library that has already been
2864 removed, but we have not yet processed the shlib unload
2865 event. Unfortunately, some targets that implement
2866 breakpoint insertion themselves can't tell why the
2867 breakpoint insertion failed (e.g., the remote target
2868 doesn't define error codes), so we must treat generic
2869 errors as memory errors. */
2870 if (bp_excpt
.reason
== RETURN_ERROR
2871 && (bp_excpt
.error
== GENERIC_ERROR
2872 || bp_excpt
.error
== MEMORY_ERROR
)
2873 && bl
->loc_type
== bp_loc_software_breakpoint
2874 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2875 || shared_objfile_contains_address_p (bl
->pspace
,
2878 /* See also: disable_breakpoints_in_shlibs. */
2879 bl
->shlib_disabled
= 1;
2880 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2881 if (!*disabled_breaks
)
2883 gdb_printf (tmp_error_stream
,
2884 "Cannot insert breakpoint %d.\n",
2886 gdb_printf (tmp_error_stream
,
2887 "Temporarily disabling shared "
2888 "library breakpoints:\n");
2890 *disabled_breaks
= 1;
2891 gdb_printf (tmp_error_stream
,
2892 "breakpoint #%d\n", bl
->owner
->number
);
2897 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2899 *hw_breakpoint_error
= 1;
2900 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2901 gdb_printf (tmp_error_stream
,
2902 "Cannot insert hardware breakpoint %d%s",
2904 bp_excpt
.message
? ":" : ".\n");
2905 if (bp_excpt
.message
!= NULL
)
2906 gdb_printf (tmp_error_stream
, "%s.\n",
2911 if (bp_excpt
.message
== NULL
)
2914 = memory_error_message (TARGET_XFER_E_IO
,
2915 bl
->gdbarch
, bl
->address
);
2917 gdb_printf (tmp_error_stream
,
2918 "Cannot insert breakpoint %d.\n"
2920 bl
->owner
->number
, message
.c_str ());
2924 gdb_printf (tmp_error_stream
,
2925 "Cannot insert breakpoint %d: %s\n",
2940 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2941 /* NOTE drow/2003-09-08: This state only exists for removing
2942 watchpoints. It's not clear that it's necessary... */
2943 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2947 val
= bl
->owner
->insert_location (bl
);
2949 /* If trying to set a read-watchpoint, and it turns out it's not
2950 supported, try emulating one with an access watchpoint. */
2951 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2953 /* But don't try to insert it, if there's already another
2954 hw_access location that would be considered a duplicate
2956 for (bp_location
*loc
: all_bp_locations ())
2958 && loc
->watchpoint_type
== hw_access
2959 && watchpoint_locations_match (bl
, loc
))
2963 bl
->target_info
= loc
->target_info
;
2964 bl
->watchpoint_type
= hw_access
;
2971 bl
->watchpoint_type
= hw_access
;
2972 val
= bl
->owner
->insert_location (bl
);
2975 /* Back to the original value. */
2976 bl
->watchpoint_type
= hw_read
;
2980 bl
->inserted
= (val
== 0);
2983 else if (bl
->owner
->type
== bp_catchpoint
)
2987 val
= bl
->owner
->insert_location (bl
);
2990 bl
->owner
->enable_state
= bp_disabled
;
2994 Error inserting catchpoint %d: Your system does not support this type\n\
2995 of catchpoint."), bl
->owner
->number
);
2997 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
3000 bl
->inserted
= (val
== 0);
3002 /* We've already printed an error message if there was a problem
3003 inserting this catchpoint, and we've disabled the catchpoint,
3004 so just return success. */
3011 /* This function is called when program space PSPACE is about to be
3012 deleted. It takes care of updating breakpoints to not reference
3016 breakpoint_program_space_exit (struct program_space
*pspace
)
3018 /* Remove any breakpoint that was set through this program space. */
3019 for (breakpoint
*b
: all_breakpoints_safe ())
3020 if (b
->pspace
== pspace
)
3021 delete_breakpoint (b
);
3023 /* Breakpoints set through other program spaces could have locations
3024 bound to PSPACE as well. Remove those. */
3025 for (bp_location
*loc
: all_bp_locations ())
3027 struct bp_location
*tmp
;
3029 if (loc
->pspace
== pspace
)
3031 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
3032 if (loc
->owner
->loc
== loc
)
3033 loc
->owner
->loc
= loc
->next
;
3035 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
3036 if (tmp
->next
== loc
)
3038 tmp
->next
= loc
->next
;
3044 /* Now update the global location list to permanently delete the
3045 removed locations above. */
3046 update_global_location_list (UGLL_DONT_INSERT
);
3049 /* Make sure all breakpoints are inserted in inferior.
3050 Throws exception on any error.
3051 A breakpoint that is already inserted won't be inserted
3052 again, so calling this function twice is safe. */
3054 insert_breakpoints (void)
3056 for (breakpoint
*bpt
: all_breakpoints ())
3057 if (is_hardware_watchpoint (bpt
))
3059 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
3061 update_watchpoint (w
, false /* don't reparse. */);
3064 /* Updating watchpoints creates new locations, so update the global
3065 location list. Explicitly tell ugll to insert locations and
3066 ignore breakpoints_always_inserted_mode. Also,
3067 update_global_location_list tries to "upgrade" software
3068 breakpoints to hardware breakpoints to handle "set breakpoint
3069 auto-hw", so we need to call it even if we don't have new
3071 update_global_location_list (UGLL_INSERT
);
3074 /* This is used when we need to synch breakpoint conditions between GDB and the
3075 target. It is the case with deleting and disabling of breakpoints when using
3076 always-inserted mode. */
3079 update_inserted_breakpoint_locations (void)
3083 int disabled_breaks
= 0;
3084 int hw_breakpoint_error
= 0;
3085 int hw_bp_details_reported
= 0;
3087 string_file tmp_error_stream
;
3089 /* Explicitly mark the warning -- this will only be printed if
3090 there was an error. */
3091 tmp_error_stream
.puts ("Warning:\n");
3093 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3095 for (bp_location
*bl
: all_bp_locations ())
3097 /* We only want to update software breakpoints and hardware
3099 if (!is_breakpoint (bl
->owner
))
3102 /* We only want to update locations that are already inserted
3103 and need updating. This is to avoid unwanted insertion during
3104 deletion of breakpoints. */
3105 if (!bl
->inserted
|| !bl
->needs_update
)
3108 switch_to_program_space_and_thread (bl
->pspace
);
3110 /* For targets that support global breakpoints, there's no need
3111 to select an inferior to insert breakpoint to. In fact, even
3112 if we aren't attached to any process yet, we should still
3113 insert breakpoints. */
3114 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3115 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3118 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3119 &hw_breakpoint_error
, &hw_bp_details_reported
);
3126 target_terminal::ours_for_output ();
3127 error_stream (tmp_error_stream
);
3131 /* Used when starting or continuing the program. */
3134 insert_breakpoint_locations (void)
3138 int disabled_breaks
= 0;
3139 int hw_breakpoint_error
= 0;
3140 int hw_bp_error_explained_already
= 0;
3142 string_file tmp_error_stream
;
3144 /* Explicitly mark the warning -- this will only be printed if
3145 there was an error. */
3146 tmp_error_stream
.puts ("Warning:\n");
3148 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3150 for (bp_location
*bl
: all_bp_locations ())
3152 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3155 /* There is no point inserting thread-specific breakpoints if
3156 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3157 has BL->OWNER always non-NULL. */
3158 if (bl
->owner
->thread
!= -1
3159 && !valid_global_thread_id (bl
->owner
->thread
))
3162 switch_to_program_space_and_thread (bl
->pspace
);
3164 /* For targets that support global breakpoints, there's no need
3165 to select an inferior to insert breakpoint to. In fact, even
3166 if we aren't attached to any process yet, we should still
3167 insert breakpoints. */
3168 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3169 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3172 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3173 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3178 /* If we failed to insert all locations of a watchpoint, remove
3179 them, as half-inserted watchpoint is of limited use. */
3180 for (breakpoint
*bpt
: all_breakpoints ())
3182 bool some_failed
= false;
3184 if (!is_hardware_watchpoint (bpt
))
3187 if (!breakpoint_enabled (bpt
))
3190 if (bpt
->disposition
== disp_del_at_next_stop
)
3193 for (bp_location
*loc
: bpt
->locations ())
3194 if (!loc
->inserted
&& should_be_inserted (loc
))
3202 for (bp_location
*loc
: bpt
->locations ())
3204 remove_breakpoint (loc
);
3206 hw_breakpoint_error
= 1;
3207 tmp_error_stream
.printf ("Could not insert "
3208 "hardware watchpoint %d.\n",
3216 /* If a hardware breakpoint or watchpoint was inserted, add a
3217 message about possibly exhausted resources. */
3218 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3220 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3221 You may have requested too many hardware breakpoints/watchpoints.\n");
3223 target_terminal::ours_for_output ();
3224 error_stream (tmp_error_stream
);
3228 /* Used when the program stops.
3229 Returns zero if successful, or non-zero if there was a problem
3230 removing a breakpoint location. */
3233 remove_breakpoints (void)
3237 for (bp_location
*bl
: all_bp_locations ())
3238 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3239 val
|= remove_breakpoint (bl
);
3244 /* When a thread exits, remove breakpoints that are related to
3248 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3250 for (breakpoint
*b
: all_breakpoints_safe ())
3252 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3254 b
->disposition
= disp_del_at_next_stop
;
3257 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3258 b
->number
, print_thread_id (tp
));
3260 /* Hide it from the user. */
3266 /* See breakpoint.h. */
3269 remove_breakpoints_inf (inferior
*inf
)
3273 for (bp_location
*bl
: all_bp_locations ())
3275 if (bl
->pspace
!= inf
->pspace
)
3278 if (bl
->inserted
&& !bl
->target_info
.persist
)
3280 val
= remove_breakpoint (bl
);
3287 static int internal_breakpoint_number
= -1;
3289 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3290 If INTERNAL is non-zero, the breakpoint number will be populated
3291 from internal_breakpoint_number and that variable decremented.
3292 Otherwise the breakpoint number will be populated from
3293 breakpoint_count and that value incremented. Internal breakpoints
3294 do not set the internal var bpnum. */
3296 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3299 b
->number
= internal_breakpoint_number
--;
3302 set_breakpoint_count (breakpoint_count
+ 1);
3303 b
->number
= breakpoint_count
;
3307 /* Create a TYPE breakpoint on ADDRESS from an object file with GDBARCH. */
3309 static struct breakpoint
*
3310 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3311 CORE_ADDR address
, enum bptype type
)
3313 std::unique_ptr
<internal_breakpoint
> b
3314 (new internal_breakpoint (gdbarch
, type
, address
));
3316 b
->number
= internal_breakpoint_number
--;
3318 return add_to_breakpoint_chain (std::move (b
));
3321 /* Create a TYPE breakpoint on minimal symbol MSYM from an object file with
3324 static struct breakpoint
*
3325 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3326 struct bound_minimal_symbol
&msym
, enum bptype type
)
3330 address
= msym
.value_address ();
3332 address
= gdbarch_convert_from_func_ptr_addr
3333 (gdbarch
, address
, current_inferior ()->top_target ());
3335 /* Note that we're not using gdbarch_addr_bits_remove here, because that's
3336 related to addresses in $pc. We're getting the address from the
3337 minimal symbol table. */
3339 /* Is gdbarch_deprecated_function_start_offset needed here? Or is that dealt
3340 with elsewhere? Needs testing on vax. */
3342 if (gdbarch_skip_entrypoint_p (gdbarch
))
3343 address
= gdbarch_skip_entrypoint (gdbarch
, address
);
3345 return create_internal_breakpoint (gdbarch
, address
, type
);
3348 static const char *const longjmp_names
[] =
3350 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3352 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3354 /* Per-objfile data private to breakpoint.c. */
3355 struct breakpoint_objfile_data
3357 /* Minimal symbol for "_ovly_debug_event" (if any). */
3358 struct bound_minimal_symbol overlay_msym
;
3360 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3361 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
];
3363 /* True if we have looked for longjmp probes. */
3364 int longjmp_searched
= 0;
3366 /* SystemTap probe points for longjmp (if any). These are non-owning
3368 std::vector
<probe
*> longjmp_probes
;
3370 /* Minimal symbol for "std::terminate()" (if any). */
3371 struct bound_minimal_symbol terminate_msym
;
3373 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3374 struct bound_minimal_symbol exception_msym
;
3376 /* True if we have looked for exception probes. */
3377 int exception_searched
= 0;
3379 /* SystemTap probe points for unwinding (if any). These are non-owning
3381 std::vector
<probe
*> exception_probes
;
3384 static const registry
<objfile
>::key
<breakpoint_objfile_data
>
3385 breakpoint_objfile_key
;
3387 /* Minimal symbol not found sentinel. */
3388 static struct minimal_symbol msym_not_found
;
3390 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3393 msym_not_found_p (const struct minimal_symbol
*msym
)
3395 return msym
== &msym_not_found
;
3398 /* Return per-objfile data needed by breakpoint.c.
3399 Allocate the data if necessary. */
3401 static struct breakpoint_objfile_data
*
3402 get_breakpoint_objfile_data (struct objfile
*objfile
)
3404 struct breakpoint_objfile_data
*bp_objfile_data
;
3406 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3407 if (bp_objfile_data
== NULL
)
3408 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3409 return bp_objfile_data
;
3413 create_overlay_event_breakpoint (void)
3415 const char *const func_name
= "_ovly_debug_event";
3417 for (objfile
*objfile
: current_program_space
->objfiles ())
3419 struct breakpoint
*b
;
3420 struct breakpoint_objfile_data
*bp_objfile_data
;
3423 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3425 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3428 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3430 struct bound_minimal_symbol m
;
3432 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3433 if (m
.minsym
== NULL
)
3435 /* Avoid future lookups in this objfile. */
3436 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3439 bp_objfile_data
->overlay_msym
= m
;
3442 addr
= bp_objfile_data
->overlay_msym
.value_address ();
3443 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3445 b
->locspec
= new_explicit_location_spec_function (func_name
);
3447 if (overlay_debugging
== ovly_auto
)
3449 b
->enable_state
= bp_enabled
;
3450 overlay_events_enabled
= 1;
3454 b
->enable_state
= bp_disabled
;
3455 overlay_events_enabled
= 0;
3460 /* Install a master longjmp breakpoint for OBJFILE using a probe. Return
3461 true if a breakpoint was installed. */
3464 create_longjmp_master_breakpoint_probe (objfile
*objfile
)
3466 struct gdbarch
*gdbarch
= objfile
->arch ();
3467 struct breakpoint_objfile_data
*bp_objfile_data
3468 = get_breakpoint_objfile_data (objfile
);
3470 if (!bp_objfile_data
->longjmp_searched
)
3472 std::vector
<probe
*> ret
3473 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3477 /* We are only interested in checking one element. */
3480 if (!p
->can_evaluate_arguments ())
3482 /* We cannot use the probe interface here,
3483 because it does not know how to evaluate
3488 bp_objfile_data
->longjmp_probes
= ret
;
3489 bp_objfile_data
->longjmp_searched
= 1;
3492 if (bp_objfile_data
->longjmp_probes
.empty ())
3495 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3497 struct breakpoint
*b
;
3499 b
= create_internal_breakpoint (gdbarch
,
3500 p
->get_relocated_address (objfile
),
3502 b
->locspec
= new_probe_location_spec ("-probe-stap libc:longjmp");
3503 b
->enable_state
= bp_disabled
;
3509 /* Install master longjmp breakpoints for OBJFILE using longjmp_names.
3510 Return true if at least one breakpoint was installed. */
3513 create_longjmp_master_breakpoint_names (objfile
*objfile
)
3515 struct gdbarch
*gdbarch
= objfile
->arch ();
3516 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3519 struct breakpoint_objfile_data
*bp_objfile_data
3520 = get_breakpoint_objfile_data (objfile
);
3521 unsigned int installed_bp
= 0;
3523 for (int i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3525 struct breakpoint
*b
;
3526 const char *func_name
;
3529 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3532 func_name
= longjmp_names
[i
];
3533 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3535 struct bound_minimal_symbol m
;
3537 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3538 if (m
.minsym
== NULL
)
3540 /* Prevent future lookups in this objfile. */
3541 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3544 bp_objfile_data
->longjmp_msym
[i
] = m
;
3547 addr
= bp_objfile_data
->longjmp_msym
[i
].value_address ();
3548 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
);
3549 b
->locspec
= new_explicit_location_spec_function (func_name
);
3550 b
->enable_state
= bp_disabled
;
3554 return installed_bp
> 0;
3557 /* Create a master longjmp breakpoint. */
3560 create_longjmp_master_breakpoint (void)
3562 scoped_restore_current_program_space restore_pspace
;
3564 for (struct program_space
*pspace
: program_spaces
)
3566 set_current_program_space (pspace
);
3568 for (objfile
*obj
: current_program_space
->objfiles ())
3570 /* Skip separate debug object, it's handled in the loop below. */
3571 if (obj
->separate_debug_objfile_backlink
!= nullptr)
3574 /* Try a probe kind breakpoint on main objfile. */
3575 if (create_longjmp_master_breakpoint_probe (obj
))
3578 /* Try longjmp_names kind breakpoints on main and separate_debug
3580 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3581 if (create_longjmp_master_breakpoint_names (debug_objfile
))
3587 /* Create a master std::terminate breakpoint. */
3589 create_std_terminate_master_breakpoint (void)
3591 const char *const func_name
= "std::terminate()";
3593 scoped_restore_current_program_space restore_pspace
;
3595 for (struct program_space
*pspace
: program_spaces
)
3597 set_current_program_space (pspace
);
3599 for (objfile
*objfile
: current_program_space
->objfiles ())
3601 struct breakpoint
*b
;
3602 struct breakpoint_objfile_data
*bp_objfile_data
;
3604 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3606 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3609 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3611 struct bound_minimal_symbol m
;
3613 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3614 if (m
.minsym
== NULL
|| (m
.minsym
->type () != mst_text
3615 && m
.minsym
->type () != mst_file_text
))
3617 /* Prevent future lookups in this objfile. */
3618 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3621 bp_objfile_data
->terminate_msym
= m
;
3624 b
= create_internal_breakpoint (objfile
->arch (),
3625 bp_objfile_data
->terminate_msym
,
3626 bp_std_terminate_master
);
3627 b
->locspec
= new_explicit_location_spec_function (func_name
);
3628 b
->enable_state
= bp_disabled
;
3633 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using a
3634 probe. Return true if a breakpoint was installed. */
3637 create_exception_master_breakpoint_probe (objfile
*objfile
)
3639 struct breakpoint
*b
;
3640 struct gdbarch
*gdbarch
;
3641 struct breakpoint_objfile_data
*bp_objfile_data
;
3643 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3645 /* We prefer the SystemTap probe point if it exists. */
3646 if (!bp_objfile_data
->exception_searched
)
3648 std::vector
<probe
*> ret
3649 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3653 /* We are only interested in checking one element. */
3656 if (!p
->can_evaluate_arguments ())
3658 /* We cannot use the probe interface here, because it does
3659 not know how to evaluate arguments. */
3663 bp_objfile_data
->exception_probes
= ret
;
3664 bp_objfile_data
->exception_searched
= 1;
3667 if (bp_objfile_data
->exception_probes
.empty ())
3670 gdbarch
= objfile
->arch ();
3672 for (probe
*p
: bp_objfile_data
->exception_probes
)
3674 b
= create_internal_breakpoint (gdbarch
,
3675 p
->get_relocated_address (objfile
),
3676 bp_exception_master
);
3677 b
->locspec
= new_probe_location_spec ("-probe-stap libgcc:unwind");
3678 b
->enable_state
= bp_disabled
;
3684 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using
3685 _Unwind_DebugHook. Return true if a breakpoint was installed. */
3688 create_exception_master_breakpoint_hook (objfile
*objfile
)
3690 const char *const func_name
= "_Unwind_DebugHook";
3691 struct breakpoint
*b
;
3692 struct gdbarch
*gdbarch
;
3693 struct breakpoint_objfile_data
*bp_objfile_data
;
3695 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3697 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3700 gdbarch
= objfile
->arch ();
3702 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3704 struct bound_minimal_symbol debug_hook
;
3706 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3707 if (debug_hook
.minsym
== NULL
)
3709 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3713 bp_objfile_data
->exception_msym
= debug_hook
;
3716 b
= create_internal_breakpoint (gdbarch
, bp_objfile_data
->exception_msym
,
3717 bp_exception_master
);
3718 b
->locspec
= new_explicit_location_spec_function (func_name
);
3719 b
->enable_state
= bp_disabled
;
3724 /* Install a master breakpoint on the unwinder's debug hook. */
3727 create_exception_master_breakpoint (void)
3729 for (objfile
*obj
: current_program_space
->objfiles ())
3731 /* Skip separate debug object. */
3732 if (obj
->separate_debug_objfile_backlink
)
3735 /* Try a probe kind breakpoint. */
3736 if (create_exception_master_breakpoint_probe (obj
))
3739 /* Iterate over main and separate debug objects and try an
3740 _Unwind_DebugHook kind breakpoint. */
3741 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3742 if (create_exception_master_breakpoint_hook (debug_objfile
))
3747 /* Does B have a location spec? */
3750 breakpoint_location_spec_empty_p (const struct breakpoint
*b
)
3752 return (b
->locspec
!= nullptr && b
->locspec
->empty_p ());
3756 update_breakpoints_after_exec (void)
3758 /* We're about to delete breakpoints from GDB's lists. If the
3759 INSERTED flag is true, GDB will try to lift the breakpoints by
3760 writing the breakpoints' "shadow contents" back into memory. The
3761 "shadow contents" are NOT valid after an exec, so GDB should not
3762 do that. Instead, the target is responsible from marking
3763 breakpoints out as soon as it detects an exec. We don't do that
3764 here instead, because there may be other attempts to delete
3765 breakpoints after detecting an exec and before reaching here. */
3766 for (bp_location
*bploc
: all_bp_locations ())
3767 if (bploc
->pspace
== current_program_space
)
3768 gdb_assert (!bploc
->inserted
);
3770 for (breakpoint
*b
: all_breakpoints_safe ())
3772 if (b
->pspace
!= current_program_space
)
3775 /* Solib breakpoints must be explicitly reset after an exec(). */
3776 if (b
->type
== bp_shlib_event
)
3778 delete_breakpoint (b
);
3782 /* JIT breakpoints must be explicitly reset after an exec(). */
3783 if (b
->type
== bp_jit_event
)
3785 delete_breakpoint (b
);
3789 /* Thread event breakpoints must be set anew after an exec(),
3790 as must overlay event and longjmp master breakpoints. */
3791 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3792 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3793 || b
->type
== bp_exception_master
)
3795 delete_breakpoint (b
);
3799 /* Step-resume breakpoints are meaningless after an exec(). */
3800 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3802 delete_breakpoint (b
);
3806 /* Just like single-step breakpoints. */
3807 if (b
->type
== bp_single_step
)
3809 delete_breakpoint (b
);
3813 /* Longjmp and longjmp-resume breakpoints are also meaningless
3815 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3816 || b
->type
== bp_longjmp_call_dummy
3817 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3819 delete_breakpoint (b
);
3823 if (b
->type
== bp_catchpoint
)
3825 /* For now, none of the bp_catchpoint breakpoints need to
3826 do anything at this point. In the future, if some of
3827 the catchpoints need to something, we will need to add
3828 a new method, and call this method from here. */
3832 /* bp_finish is a special case. The only way we ought to be able
3833 to see one of these when an exec() has happened, is if the user
3834 caught a vfork, and then said "finish". Ordinarily a finish just
3835 carries them to the call-site of the current callee, by setting
3836 a temporary bp there and resuming. But in this case, the finish
3837 will carry them entirely through the vfork & exec.
3839 We don't want to allow a bp_finish to remain inserted now. But
3840 we can't safely delete it, 'cause finish_command has a handle to
3841 the bp on a bpstat, and will later want to delete it. There's a
3842 chance (and I've seen it happen) that if we delete the bp_finish
3843 here, that its storage will get reused by the time finish_command
3844 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3845 We really must allow finish_command to delete a bp_finish.
3847 In the absence of a general solution for the "how do we know
3848 it's safe to delete something others may have handles to?"
3849 problem, what we'll do here is just uninsert the bp_finish, and
3850 let finish_command delete it.
3852 (We know the bp_finish is "doomed" in the sense that it's
3853 momentary, and will be deleted as soon as finish_command sees
3854 the inferior stopped. So it doesn't matter that the bp's
3855 address is probably bogus in the new a.out, unlike e.g., the
3856 solib breakpoints.) */
3858 if (b
->type
== bp_finish
)
3863 /* Without a symbolic address, we have little hope of the
3864 pre-exec() address meaning the same thing in the post-exec()
3866 if (breakpoint_location_spec_empty_p (b
))
3868 delete_breakpoint (b
);
3875 detach_breakpoints (ptid_t ptid
)
3878 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3879 struct inferior
*inf
= current_inferior ();
3881 if (ptid
.pid () == inferior_ptid
.pid ())
3882 error (_("Cannot detach breakpoints of inferior_ptid"));
3884 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3885 inferior_ptid
= ptid
;
3886 for (bp_location
*bl
: all_bp_locations ())
3888 if (bl
->pspace
!= inf
->pspace
)
3891 /* This function must physically remove breakpoints locations
3892 from the specified ptid, without modifying the breakpoint
3893 package's state. Locations of type bp_loc_other and
3894 bp_loc_software_watchpoint are only maintained at GDB side,
3895 so there is no need to remove them. Moreover, removing these
3896 would modify the breakpoint package's state. */
3897 if (bl
->loc_type
== bp_loc_other
3898 || bl
->loc_type
== bp_loc_software_watchpoint
)
3902 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3908 /* Remove the breakpoint location BL from the current address space.
3909 Note that this is used to detach breakpoints from a child fork.
3910 When we get here, the child isn't in the inferior list, and neither
3911 do we have objects to represent its address space --- we should
3912 *not* look at bl->pspace->aspace here. */
3915 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3919 /* BL is never in moribund_locations by our callers. */
3920 gdb_assert (bl
->owner
!= NULL
);
3922 /* The type of none suggests that owner is actually deleted.
3923 This should not ever happen. */
3924 gdb_assert (bl
->owner
->type
!= bp_none
);
3926 if (bl
->loc_type
== bp_loc_software_breakpoint
3927 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3929 /* "Normal" instruction breakpoint: either the standard
3930 trap-instruction bp (bp_breakpoint), or a
3931 bp_hardware_breakpoint. */
3933 /* First check to see if we have to handle an overlay. */
3934 if (overlay_debugging
== ovly_off
3935 || bl
->section
== NULL
3936 || !(section_is_overlay (bl
->section
)))
3938 /* No overlay handling: just remove the breakpoint. */
3940 /* If we're trying to uninsert a memory breakpoint that we
3941 know is set in a dynamic object that is marked
3942 shlib_disabled, then either the dynamic object was
3943 removed with "remove-symbol-file" or with
3944 "nosharedlibrary". In the former case, we don't know
3945 whether another dynamic object might have loaded over the
3946 breakpoint's address -- the user might well let us know
3947 about it next with add-symbol-file (the whole point of
3948 add-symbol-file is letting the user manually maintain a
3949 list of dynamically loaded objects). If we have the
3950 breakpoint's shadow memory, that is, this is a software
3951 breakpoint managed by GDB, check whether the breakpoint
3952 is still inserted in memory, to avoid overwriting wrong
3953 code with stale saved shadow contents. Note that HW
3954 breakpoints don't have shadow memory, as they're
3955 implemented using a mechanism that is not dependent on
3956 being able to modify the target's memory, and as such
3957 they should always be removed. */
3958 if (bl
->shlib_disabled
3959 && bl
->target_info
.shadow_len
!= 0
3960 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3963 val
= bl
->owner
->remove_location (bl
, reason
);
3967 /* This breakpoint is in an overlay section.
3968 Did we set a breakpoint at the LMA? */
3969 if (!overlay_events_enabled
)
3971 /* Yes -- overlay event support is not active, so we
3972 should have set a breakpoint at the LMA. Remove it.
3974 /* Ignore any failures: if the LMA is in ROM, we will
3975 have already warned when we failed to insert it. */
3976 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3977 target_remove_hw_breakpoint (bl
->gdbarch
,
3978 &bl
->overlay_target_info
);
3980 target_remove_breakpoint (bl
->gdbarch
,
3981 &bl
->overlay_target_info
,
3984 /* Did we set a breakpoint at the VMA?
3985 If so, we will have marked the breakpoint 'inserted'. */
3988 /* Yes -- remove it. Previously we did not bother to
3989 remove the breakpoint if the section had been
3990 unmapped, but let's not rely on that being safe. We
3991 don't know what the overlay manager might do. */
3993 /* However, we should remove *software* breakpoints only
3994 if the section is still mapped, or else we overwrite
3995 wrong code with the saved shadow contents. */
3996 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3997 || section_is_mapped (bl
->section
))
3998 val
= bl
->owner
->remove_location (bl
, reason
);
4004 /* No -- not inserted, so no need to remove. No error. */
4009 /* In some cases, we might not be able to remove a breakpoint in
4010 a shared library that has already been removed, but we have
4011 not yet processed the shlib unload event. Similarly for an
4012 unloaded add-symbol-file object - the user might not yet have
4013 had the chance to remove-symbol-file it. shlib_disabled will
4014 be set if the library/object has already been removed, but
4015 the breakpoint hasn't been uninserted yet, e.g., after
4016 "nosharedlibrary" or "remove-symbol-file" with breakpoints
4017 always-inserted mode. */
4019 && (bl
->loc_type
== bp_loc_software_breakpoint
4020 && (bl
->shlib_disabled
4021 || solib_name_from_address (bl
->pspace
, bl
->address
)
4022 || shared_objfile_contains_address_p (bl
->pspace
,
4028 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4030 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
4032 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4033 bl
->owner
->remove_location (bl
, reason
);
4035 /* Failure to remove any of the hardware watchpoints comes here. */
4036 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
4037 warning (_("Could not remove hardware watchpoint %d."),
4040 else if (bl
->owner
->type
== bp_catchpoint
4041 && breakpoint_enabled (bl
->owner
)
4044 val
= bl
->owner
->remove_location (bl
, reason
);
4048 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
4055 remove_breakpoint (struct bp_location
*bl
)
4057 /* BL is never in moribund_locations by our callers. */
4058 gdb_assert (bl
->owner
!= NULL
);
4060 /* The type of none suggests that owner is actually deleted.
4061 This should not ever happen. */
4062 gdb_assert (bl
->owner
->type
!= bp_none
);
4064 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
4066 switch_to_program_space_and_thread (bl
->pspace
);
4068 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
4071 /* Clear the "inserted" flag in all breakpoints. */
4074 mark_breakpoints_out (void)
4076 for (bp_location
*bl
: all_bp_locations ())
4077 if (bl
->pspace
== current_program_space
)
4081 /* Clear the "inserted" flag in all breakpoints and delete any
4082 breakpoints which should go away between runs of the program.
4084 Plus other such housekeeping that has to be done for breakpoints
4087 Note: this function gets called at the end of a run (by
4088 generic_mourn_inferior) and when a run begins (by
4089 init_wait_for_inferior). */
4094 breakpoint_init_inferior (enum inf_context context
)
4096 struct program_space
*pspace
= current_program_space
;
4098 /* If breakpoint locations are shared across processes, then there's
4100 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
4103 mark_breakpoints_out ();
4105 for (breakpoint
*b
: all_breakpoints_safe ())
4107 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
4113 case bp_longjmp_call_dummy
:
4115 /* If the call dummy breakpoint is at the entry point it will
4116 cause problems when the inferior is rerun, so we better get
4119 case bp_watchpoint_scope
:
4121 /* Also get rid of scope breakpoints. */
4123 case bp_shlib_event
:
4125 /* Also remove solib event breakpoints. Their addresses may
4126 have changed since the last time we ran the program.
4127 Actually we may now be debugging against different target;
4128 and so the solib backend that installed this breakpoint may
4129 not be used in by the target. E.g.,
4131 (gdb) file prog-linux
4132 (gdb) run # native linux target
4135 (gdb) file prog-win.exe
4136 (gdb) tar rem :9999 # remote Windows gdbserver.
4139 case bp_step_resume
:
4141 /* Also remove step-resume breakpoints. */
4143 case bp_single_step
:
4145 /* Also remove single-step breakpoints. */
4147 delete_breakpoint (b
);
4151 case bp_hardware_watchpoint
:
4152 case bp_read_watchpoint
:
4153 case bp_access_watchpoint
:
4155 struct watchpoint
*w
= (struct watchpoint
*) b
;
4157 /* Likewise for watchpoints on local expressions. */
4158 if (w
->exp_valid_block
!= NULL
)
4159 delete_breakpoint (b
);
4162 /* Get rid of existing locations, which are no longer
4163 valid. New ones will be created in
4164 update_watchpoint, when the inferior is restarted.
4165 The next update_global_location_list call will
4166 garbage collect them. */
4169 if (context
== inf_starting
)
4171 /* Reset val field to force reread of starting value in
4172 insert_breakpoints. */
4173 w
->val
.reset (nullptr);
4174 w
->val_valid
= false;
4184 /* Get rid of the moribund locations. */
4185 for (bp_location
*bl
: moribund_locations
)
4186 decref_bp_location (&bl
);
4187 moribund_locations
.clear ();
4190 /* These functions concern about actual breakpoints inserted in the
4191 target --- to e.g. check if we need to do decr_pc adjustment or if
4192 we need to hop over the bkpt --- so we check for address space
4193 match, not program space. */
4195 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4196 exists at PC. It returns ordinary_breakpoint_here if it's an
4197 ordinary breakpoint, or permanent_breakpoint_here if it's a
4198 permanent breakpoint.
4199 - When continuing from a location with an ordinary breakpoint, we
4200 actually single step once before calling insert_breakpoints.
4201 - When continuing from a location with a permanent breakpoint, we
4202 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4203 the target, to advance the PC past the breakpoint. */
4205 enum breakpoint_here
4206 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4208 bool any_breakpoint_here
= false;
4210 for (bp_location
*bl
: all_bp_locations ())
4212 if (bl
->loc_type
!= bp_loc_software_breakpoint
4213 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4216 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4217 if ((breakpoint_enabled (bl
->owner
)
4219 && breakpoint_location_address_match (bl
, aspace
, pc
))
4221 if (overlay_debugging
4222 && section_is_overlay (bl
->section
)
4223 && !section_is_mapped (bl
->section
))
4224 continue; /* unmapped overlay -- can't be a match */
4225 else if (bl
->permanent
)
4226 return permanent_breakpoint_here
;
4228 any_breakpoint_here
= true;
4232 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4235 /* See breakpoint.h. */
4238 breakpoint_in_range_p (const address_space
*aspace
,
4239 CORE_ADDR addr
, ULONGEST len
)
4241 for (bp_location
*bl
: all_bp_locations ())
4243 if (bl
->loc_type
!= bp_loc_software_breakpoint
4244 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4247 if ((breakpoint_enabled (bl
->owner
)
4249 && breakpoint_location_address_range_overlap (bl
, aspace
,
4252 if (overlay_debugging
4253 && section_is_overlay (bl
->section
)
4254 && !section_is_mapped (bl
->section
))
4256 /* Unmapped overlay -- can't be a match. */
4267 /* Return true if there's a moribund breakpoint at PC. */
4270 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4272 for (bp_location
*loc
: moribund_locations
)
4273 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4279 /* Returns true iff BL is inserted at PC, in address space ASPACE. */
4282 bp_location_inserted_here_p (const struct bp_location
*bl
,
4283 const address_space
*aspace
, CORE_ADDR pc
)
4286 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4289 /* An unmapped overlay can't be a match. */
4290 return !(overlay_debugging
4291 && section_is_overlay (bl
->section
)
4292 && !section_is_mapped (bl
->section
));
4297 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4300 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4302 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4304 if (bl
->loc_type
!= bp_loc_software_breakpoint
4305 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4308 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4314 /* This function returns non-zero iff there is a software breakpoint
4318 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4321 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4323 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4326 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4333 /* See breakpoint.h. */
4336 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4339 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4341 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4344 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4352 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4353 CORE_ADDR addr
, ULONGEST len
)
4355 for (breakpoint
*bpt
: all_breakpoints ())
4357 if (bpt
->type
!= bp_hardware_watchpoint
4358 && bpt
->type
!= bp_access_watchpoint
)
4361 if (!breakpoint_enabled (bpt
))
4364 for (bp_location
*loc
: bpt
->locations ())
4365 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4369 /* Check for intersection. */
4370 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4371 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4379 /* See breakpoint.h. */
4382 is_catchpoint (struct breakpoint
*b
)
4384 return (b
->type
== bp_catchpoint
);
4387 /* Clear a bpstat so that it says we are not at any breakpoint.
4388 Also free any storage that is part of a bpstat. */
4391 bpstat_clear (bpstat
**bsp
)
4408 bpstat::bpstat (const bpstat
&other
)
4410 bp_location_at (other
.bp_location_at
),
4411 breakpoint_at (other
.breakpoint_at
),
4412 commands (other
.commands
),
4413 print (other
.print
),
4415 print_it (other
.print_it
)
4417 if (other
.old_val
!= NULL
)
4418 old_val
= release_value (other
.old_val
.get ()->copy ());
4421 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4422 is part of the bpstat is copied as well. */
4425 bpstat_copy (bpstat
*bs
)
4427 bpstat
*p
= nullptr;
4429 bpstat
*retval
= nullptr;
4434 for (; bs
!= NULL
; bs
= bs
->next
)
4436 tmp
= new bpstat (*bs
);
4439 /* This is the first thing in the chain. */
4449 /* Find the bpstat associated with this breakpoint. */
4452 bpstat_find_breakpoint (bpstat
*bsp
, struct breakpoint
*breakpoint
)
4457 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4459 if (bsp
->breakpoint_at
== breakpoint
)
4465 /* See breakpoint.h. */
4468 bpstat_explains_signal (bpstat
*bsp
, enum gdb_signal sig
)
4470 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4472 if (bsp
->breakpoint_at
== NULL
)
4474 /* A moribund location can never explain a signal other than
4476 if (sig
== GDB_SIGNAL_TRAP
)
4481 if (bsp
->breakpoint_at
->explains_signal (sig
))
4489 /* See breakpoint.h. */
4492 bpstat_num (bpstat
**bsp
, int *num
)
4494 struct breakpoint
*b
;
4497 return 0; /* No more breakpoint values */
4499 /* We assume we'll never have several bpstats that correspond to a
4500 single breakpoint -- otherwise, this function might return the
4501 same number more than once and this will look ugly. */
4502 b
= (*bsp
)->breakpoint_at
;
4503 *bsp
= (*bsp
)->next
;
4505 return -1; /* breakpoint that's been deleted since */
4507 *num
= b
->number
; /* We have its number */
4511 /* See breakpoint.h */
4514 bpstat_locno (const bpstat
*bs
)
4516 const struct breakpoint
*b
= bs
->breakpoint_at
;
4517 const struct bp_location
*bl
= bs
->bp_location_at
.get ();
4521 if (b
!= nullptr && b
->loc
!= nullptr && b
->loc
->next
!= nullptr)
4523 const bp_location
*bl_i
;
4526 bl_i
!= bl
&& bl_i
->next
!= nullptr;
4534 warning (_("location number not found for breakpoint %d address %s."),
4535 b
->number
, paddress (bl
->gdbarch
, bl
->address
));
4543 /* See breakpoint.h. */
4546 print_num_locno (const bpstat
*bs
, struct ui_out
*uiout
)
4548 struct breakpoint
*b
= bs
->breakpoint_at
;
4551 uiout
->text (_("deleted breakpoint"));
4554 uiout
->field_signed ("bkptno", b
->number
);
4556 int locno
= bpstat_locno (bs
);
4558 uiout
->message (".%pF", signed_field ("locno", locno
));
4562 /* See breakpoint.h. */
4565 bpstat_clear_actions (void)
4569 if (inferior_ptid
== null_ptid
)
4572 thread_info
*tp
= inferior_thread ();
4573 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4575 bs
->commands
= NULL
;
4576 bs
->old_val
.reset (nullptr);
4580 /* Called when a command is about to proceed the inferior. */
4583 breakpoint_about_to_proceed (void)
4585 if (inferior_ptid
!= null_ptid
)
4587 struct thread_info
*tp
= inferior_thread ();
4589 /* Allow inferior function calls in breakpoint commands to not
4590 interrupt the command list. When the call finishes
4591 successfully, the inferior will be standing at the same
4592 breakpoint as if nothing happened. */
4593 if (tp
->control
.in_infcall
)
4597 breakpoint_proceeded
= 1;
4600 /* Return true iff CMD as the first line of a command sequence is `silent'
4601 or its equivalent. */
4604 command_line_is_silent (struct command_line
*cmd
)
4606 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4609 /* Sets the $_hit_bpnum and $_hit_locno to bpnum and locno.
4610 A locno 0 is changed to 1 to e.g. let the user do
4611 (gdb) disable $_hit_bpnum.$_hit_locno
4612 for a single location breakpoint. */
4615 set_hit_convenience_vars (int bpnum
, int locno
)
4617 set_internalvar_integer (lookup_internalvar ("_hit_bpnum"), bpnum
);
4618 set_internalvar_integer (lookup_internalvar ("_hit_locno"),
4619 (locno
> 0 ? locno
: 1));
4622 /* Execute all the commands associated with all the breakpoints at
4623 this location. Any of these commands could cause the process to
4624 proceed beyond this point, etc. We look out for such changes by
4625 checking the global "breakpoint_proceeded" after each command.
4627 Returns true if a breakpoint command resumed the inferior. In that
4628 case, it is the caller's responsibility to recall it again with the
4629 bpstat of the current thread. */
4632 bpstat_do_actions_1 (bpstat
**bsp
)
4637 /* Avoid endless recursion if a `source' command is contained
4639 if (executing_breakpoint_commands
)
4642 scoped_restore save_executing
4643 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4645 scoped_restore preventer
= prevent_dont_repeat ();
4647 /* This pointer will iterate over the list of bpstat's. */
4650 /* The $_hit_* convenience variables are set before running the
4651 commands of BS. In case we have several bs, after the loop,
4652 we set again the variables to the first printed bpnum and locno.
4653 For multiple breakpoints, this ensures the variables are set to the
4654 breakpoint printed for the user. */
4655 int printed_hit_bpnum
= -1;
4656 int printed_hit_locno
= -1;
4658 breakpoint_proceeded
= 0;
4659 for (; bs
!= NULL
; bs
= bs
->next
)
4661 struct command_line
*cmd
= NULL
;
4663 /* Set the _hit_* convenience variables before running BS's commands. */
4665 const struct breakpoint
*b
= bs
->breakpoint_at
;
4668 int locno
= bpstat_locno (bs
);
4670 set_hit_convenience_vars (b
->number
, locno
);
4671 if (printed_hit_locno
== -1 && bs
->print
)
4673 printed_hit_bpnum
= b
->number
;
4674 printed_hit_locno
= locno
;
4679 /* Take ownership of the BSP's command tree, if it has one.
4681 The command tree could legitimately contain commands like
4682 'step' and 'next', which call clear_proceed_status, which
4683 frees the bpstat BS and its command tree. To make sure this doesn't
4684 free the tree we're executing out from under us, we need to
4685 take ownership of the tree ourselves. Since a given bpstat's
4686 commands are only executed once, we don't need to copy it; we
4687 can clear the pointer in the bpstat, and make sure we free
4688 the tree when we're done. */
4689 counted_command_line ccmd
= bs
->commands
;
4690 bs
->commands
= NULL
;
4693 if (command_line_is_silent (cmd
))
4695 /* The action has been already done by bpstat_stop_status. */
4701 execute_control_command (cmd
);
4702 /* After execute_control_command, if breakpoint_proceeded is true,
4703 BS has been freed and cannot be accessed anymore. */
4705 if (breakpoint_proceeded
)
4711 if (breakpoint_proceeded
)
4713 if (current_ui
->async
)
4714 /* If we are in async mode, then the target might be still
4715 running, not stopped at any breakpoint, so nothing for
4716 us to do here -- just return to the event loop. */
4719 /* In sync mode, when execute_control_command returns
4720 we're already standing on the next breakpoint.
4721 Breakpoint commands for that stop were not run, since
4722 execute_command does not run breakpoint commands --
4723 only command_line_handler does, but that one is not
4724 involved in execution of breakpoint commands. So, we
4725 can now execute breakpoint commands. It should be
4726 noted that making execute_command do bpstat actions is
4727 not an option -- in this case we'll have recursive
4728 invocation of bpstat for each breakpoint with a
4729 command, and can easily blow up GDB stack. Instead, we
4730 return true, which will trigger the caller to recall us
4731 with the new stop_bpstat. */
4737 /* Now that we have executed the commands of all bs, set the _hit_*
4738 convenience variables to the printed values. */
4739 if (printed_hit_locno
!= -1)
4740 set_hit_convenience_vars (printed_hit_bpnum
, printed_hit_locno
);
4745 /* Helper for bpstat_do_actions. Get the current thread, if there's
4746 one, is alive and has execution. Return NULL otherwise. */
4748 static thread_info
*
4749 get_bpstat_thread ()
4751 if (inferior_ptid
== null_ptid
|| !target_has_execution ())
4754 thread_info
*tp
= inferior_thread ();
4755 if (tp
->state
== THREAD_EXITED
|| tp
->executing ())
4761 bpstat_do_actions (void)
4763 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4766 /* Do any commands attached to breakpoint we are stopped at. */
4767 while ((tp
= get_bpstat_thread ()) != NULL
)
4769 /* Since in sync mode, bpstat_do_actions may resume the
4770 inferior, and only return when it is stopped at the next
4771 breakpoint, we keep doing breakpoint actions until it returns
4772 false to indicate the inferior was not resumed. */
4773 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4777 cleanup_if_error
.release ();
4780 /* Print out the (old or new) value associated with a watchpoint. */
4783 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4786 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4789 struct value_print_options opts
;
4790 get_user_print_options (&opts
);
4791 value_print (val
, stream
, &opts
);
4795 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4796 debugging multiple threads. */
4799 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4801 if (uiout
->is_mi_like_p ())
4806 if (show_thread_that_caused_stop ())
4808 struct thread_info
*thr
= inferior_thread ();
4810 uiout
->text ("Thread ");
4811 uiout
->field_string ("thread-id", print_thread_id (thr
));
4813 const char *name
= thread_name (thr
);
4816 uiout
->text (" \"");
4817 uiout
->field_string ("name", name
);
4821 uiout
->text (" hit ");
4825 /* Generic routine for printing messages indicating why we
4826 stopped. The behavior of this function depends on the value
4827 'print_it' in the bpstat structure. Under some circumstances we
4828 may decide not to print anything here and delegate the task to
4831 static enum print_stop_action
4832 print_bp_stop_message (bpstat
*bs
)
4834 switch (bs
->print_it
)
4837 /* Nothing should be printed for this bpstat entry. */
4838 return PRINT_UNKNOWN
;
4842 /* We still want to print the frame, but we already printed the
4843 relevant messages. */
4844 return PRINT_SRC_AND_LOC
;
4847 case print_it_normal
:
4849 struct breakpoint
*b
= bs
->breakpoint_at
;
4851 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4852 which has since been deleted. */
4854 return PRINT_UNKNOWN
;
4856 /* Normal case. Call the breakpoint's print_it method. */
4857 return b
->print_it (bs
);
4862 internal_error (_("print_bp_stop_message: unrecognized enum value"));
4867 /* See breakpoint.h. */
4870 print_solib_event (bool is_catchpoint
)
4872 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4873 bool any_added
= !current_program_space
->added_solibs
.empty ();
4877 if (any_added
|| any_deleted
)
4878 current_uiout
->text (_("Stopped due to shared library event:\n"));
4880 current_uiout
->text (_("Stopped due to shared library event (no "
4881 "libraries added or removed)\n"));
4884 if (current_uiout
->is_mi_like_p ())
4885 current_uiout
->field_string ("reason",
4886 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4890 current_uiout
->text (_(" Inferior unloaded "));
4891 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4892 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4894 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4897 current_uiout
->text (" ");
4898 current_uiout
->field_string ("library", name
);
4899 current_uiout
->text ("\n");
4905 current_uiout
->text (_(" Inferior loaded "));
4906 ui_out_emit_list
list_emitter (current_uiout
, "added");
4908 for (so_list
*iter
: current_program_space
->added_solibs
)
4911 current_uiout
->text (" ");
4913 current_uiout
->field_string ("library", iter
->so_name
);
4914 current_uiout
->text ("\n");
4919 /* Print a message indicating what happened. This is called from
4920 normal_stop(). The input to this routine is the head of the bpstat
4921 list - a list of the eventpoints that caused this stop. KIND is
4922 the target_waitkind for the stopping event. This
4923 routine calls the generic print routine for printing a message
4924 about reasons for stopping. This will print (for example) the
4925 "Breakpoint n," part of the output. The return value of this
4928 PRINT_UNKNOWN: Means we printed nothing.
4929 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4930 code to print the location. An example is
4931 "Breakpoint 1, " which should be followed by
4933 PRINT_SRC_ONLY: Means we printed something, but there is no need
4934 to also print the location part of the message.
4935 An example is the catch/throw messages, which
4936 don't require a location appended to the end.
4937 PRINT_NOTHING: We have done some printing and we don't need any
4938 further info to be printed. */
4940 enum print_stop_action
4941 bpstat_print (bpstat
*bs
, target_waitkind kind
)
4943 enum print_stop_action val
;
4945 /* Maybe another breakpoint in the chain caused us to stop.
4946 (Currently all watchpoints go on the bpstat whether hit or not.
4947 That probably could (should) be changed, provided care is taken
4948 with respect to bpstat_explains_signal). */
4949 for (; bs
; bs
= bs
->next
)
4951 val
= print_bp_stop_message (bs
);
4952 if (val
== PRINT_SRC_ONLY
4953 || val
== PRINT_SRC_AND_LOC
4954 || val
== PRINT_NOTHING
)
4958 /* If we had hit a shared library event breakpoint,
4959 print_bp_stop_message would print out this message. If we hit an
4960 OS-level shared library event, do the same thing. */
4961 if (kind
== TARGET_WAITKIND_LOADED
)
4963 print_solib_event (false);
4964 return PRINT_NOTHING
;
4967 /* We reached the end of the chain, or we got a null BS to start
4968 with and nothing was printed. */
4969 return PRINT_UNKNOWN
;
4972 /* Evaluate the boolean expression EXP and return the result. */
4975 breakpoint_cond_eval (expression
*exp
)
4977 scoped_value_mark mark
;
4978 return value_true (evaluate_expression (exp
));
4981 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4983 bpstat::bpstat (struct bp_location
*bl
, bpstat
***bs_link_pointer
)
4985 bp_location_at (bp_location_ref_ptr::new_reference (bl
)),
4986 breakpoint_at (bl
->owner
),
4990 print_it (print_it_normal
)
4992 **bs_link_pointer
= this;
4993 *bs_link_pointer
= &next
;
4998 breakpoint_at (NULL
),
5002 print_it (print_it_normal
)
5006 /* The target has stopped with waitstatus WS. Check if any hardware
5007 watchpoints have triggered, according to the target. */
5010 watchpoints_triggered (const target_waitstatus
&ws
)
5012 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
5015 if (!stopped_by_watchpoint
)
5017 /* We were not stopped by a watchpoint. Mark all watchpoints
5018 as not triggered. */
5019 for (breakpoint
*b
: all_breakpoints ())
5020 if (is_hardware_watchpoint (b
))
5022 struct watchpoint
*w
= (struct watchpoint
*) b
;
5024 w
->watchpoint_triggered
= watch_triggered_no
;
5030 if (!target_stopped_data_address (current_inferior ()->top_target (), &addr
))
5032 /* We were stopped by a watchpoint, but we don't know where.
5033 Mark all watchpoints as unknown. */
5034 for (breakpoint
*b
: all_breakpoints ())
5035 if (is_hardware_watchpoint (b
))
5037 struct watchpoint
*w
= (struct watchpoint
*) b
;
5039 w
->watchpoint_triggered
= watch_triggered_unknown
;
5045 /* The target could report the data address. Mark watchpoints
5046 affected by this data address as triggered, and all others as not
5049 for (breakpoint
*b
: all_breakpoints ())
5050 if (is_hardware_watchpoint (b
))
5052 struct watchpoint
*w
= (struct watchpoint
*) b
;
5054 w
->watchpoint_triggered
= watch_triggered_no
;
5055 for (bp_location
*loc
: b
->locations ())
5057 if (is_masked_watchpoint (b
))
5059 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
5060 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
5062 if (newaddr
== start
)
5064 w
->watchpoint_triggered
= watch_triggered_yes
;
5068 /* Exact match not required. Within range is sufficient. */
5069 else if (target_watchpoint_addr_within_range
5070 (current_inferior ()->top_target (), addr
, loc
->address
,
5073 w
->watchpoint_triggered
= watch_triggered_yes
;
5082 /* Possible return values for watchpoint_check. */
5083 enum wp_check_result
5085 /* The watchpoint has been deleted. */
5088 /* The value has changed. */
5089 WP_VALUE_CHANGED
= 2,
5091 /* The value has not changed. */
5092 WP_VALUE_NOT_CHANGED
= 3,
5094 /* Ignore this watchpoint, no matter if the value changed or not. */
5098 #define BP_TEMPFLAG 1
5099 #define BP_HARDWAREFLAG 2
5101 /* Evaluate watchpoint condition expression and check if its value
5104 static wp_check_result
5105 watchpoint_check (bpstat
*bs
)
5107 struct watchpoint
*b
;
5109 bool within_current_scope
;
5111 /* BS is built from an existing struct breakpoint. */
5112 gdb_assert (bs
->breakpoint_at
!= NULL
);
5113 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5115 /* If this is a local watchpoint, we only want to check if the
5116 watchpoint frame is in scope if the current thread is the thread
5117 that was used to create the watchpoint. */
5118 if (!watchpoint_in_thread_scope (b
))
5121 if (b
->exp_valid_block
== NULL
)
5122 within_current_scope
= true;
5125 frame_info_ptr frame
= get_current_frame ();
5126 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
5127 CORE_ADDR frame_pc
= get_frame_pc (frame
);
5129 /* stack_frame_destroyed_p() returns a non-zero value if we're
5130 still in the function but the stack frame has already been
5131 invalidated. Since we can't rely on the values of local
5132 variables after the stack has been destroyed, we are treating
5133 the watchpoint in that state as `not changed' without further
5134 checking. Don't mark watchpoints as changed if the current
5135 frame is in an epilogue - even if they are in some other
5136 frame, our view of the stack is likely to be wrong and
5137 frame_find_by_id could error out. */
5138 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
5141 fr
= frame_find_by_id (b
->watchpoint_frame
);
5142 within_current_scope
= (fr
!= NULL
);
5144 /* If we've gotten confused in the unwinder, we might have
5145 returned a frame that can't describe this variable. */
5146 if (within_current_scope
)
5148 struct symbol
*function
;
5150 function
= get_frame_function (fr
);
5151 if (function
== NULL
5152 || !contained_in (b
->exp_valid_block
, function
->value_block ()))
5153 within_current_scope
= false;
5156 if (within_current_scope
)
5157 /* If we end up stopping, the current frame will get selected
5158 in normal_stop. So this call to select_frame won't affect
5163 if (within_current_scope
)
5165 /* We use value_{,free_to_}mark because it could be a *long*
5166 time before we return to the command level and call
5167 free_all_values. We can't call free_all_values because we
5168 might be in the middle of evaluating a function call. */
5171 struct value
*new_val
;
5173 if (is_masked_watchpoint (b
))
5174 /* Since we don't know the exact trigger address (from
5175 stopped_data_address), just tell the user we've triggered
5176 a mask watchpoint. */
5177 return WP_VALUE_CHANGED
;
5179 mark
= value_mark ();
5180 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &new_val
,
5183 if (b
->val_bitsize
!= 0)
5184 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
5186 /* We use value_equal_contents instead of value_equal because
5187 the latter coerces an array to a pointer, thus comparing just
5188 the address of the array instead of its contents. This is
5189 not what we want. */
5190 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
5191 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
5194 bs
->old_val
= b
->val
;
5195 b
->val
= release_value (new_val
);
5196 b
->val_valid
= true;
5197 if (new_val
!= NULL
)
5198 value_free_to_mark (mark
);
5199 return WP_VALUE_CHANGED
;
5203 /* Nothing changed. */
5204 value_free_to_mark (mark
);
5205 return WP_VALUE_NOT_CHANGED
;
5210 /* This seems like the only logical thing to do because
5211 if we temporarily ignored the watchpoint, then when
5212 we reenter the block in which it is valid it contains
5213 garbage (in the case of a function, it may have two
5214 garbage values, one before and one after the prologue).
5215 So we can't even detect the first assignment to it and
5216 watch after that (since the garbage may or may not equal
5217 the first value assigned). */
5218 /* We print all the stop information in
5219 breakpointprint_it, but in this case, by the time we
5220 call breakpoint->print_it this bp will be deleted
5221 already. So we have no choice but print the information
5224 SWITCH_THRU_ALL_UIS ()
5226 struct ui_out
*uiout
= current_uiout
;
5228 if (uiout
->is_mi_like_p ())
5230 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5231 uiout
->message ("\nWatchpoint %pF deleted because the program has "
5232 "left the block in\n"
5233 "which its expression is valid.\n",
5234 signed_field ("wpnum", b
->number
));
5237 /* Make sure the watchpoint's commands aren't executed. */
5239 watchpoint_del_at_next_stop (b
);
5245 /* Return true if it looks like target has stopped due to hitting
5246 breakpoint location BL. This function does not check if we should
5247 stop, only if BL explains the stop. */
5250 bpstat_check_location (const struct bp_location
*bl
,
5251 const address_space
*aspace
, CORE_ADDR bp_addr
,
5252 const target_waitstatus
&ws
)
5254 struct breakpoint
*b
= bl
->owner
;
5256 /* BL is from an existing breakpoint. */
5257 gdb_assert (b
!= NULL
);
5259 return b
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5262 /* Determine if the watched values have actually changed, and we
5263 should stop. If not, set BS->stop to false. */
5266 bpstat_check_watchpoint (bpstat
*bs
)
5268 const struct bp_location
*bl
;
5269 struct watchpoint
*b
;
5271 /* BS is built for existing struct breakpoint. */
5272 bl
= bs
->bp_location_at
.get ();
5273 gdb_assert (bl
!= NULL
);
5274 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5275 gdb_assert (b
!= NULL
);
5278 bool must_check_value
= false;
5280 if (b
->type
== bp_watchpoint
)
5281 /* For a software watchpoint, we must always check the
5283 must_check_value
= true;
5284 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5285 /* We have a hardware watchpoint (read, write, or access)
5286 and the target earlier reported an address watched by
5288 must_check_value
= true;
5289 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5290 && b
->type
== bp_hardware_watchpoint
)
5291 /* We were stopped by a hardware watchpoint, but the target could
5292 not report the data address. We must check the watchpoint's
5293 value. Access and read watchpoints are out of luck; without
5294 a data address, we can't figure it out. */
5295 must_check_value
= true;
5297 if (must_check_value
)
5303 e
= watchpoint_check (bs
);
5305 catch (const gdb_exception
&ex
)
5307 exception_fprintf (gdb_stderr
, ex
,
5308 "Error evaluating expression "
5309 "for watchpoint %d\n",
5312 SWITCH_THRU_ALL_UIS ()
5314 gdb_printf (_("Watchpoint %d deleted.\n"),
5317 watchpoint_del_at_next_stop (b
);
5324 /* We've already printed what needs to be printed. */
5325 bs
->print_it
= print_it_done
;
5329 bs
->print_it
= print_it_noop
;
5332 case WP_VALUE_CHANGED
:
5333 if (b
->type
== bp_read_watchpoint
)
5335 /* There are two cases to consider here:
5337 1. We're watching the triggered memory for reads.
5338 In that case, trust the target, and always report
5339 the watchpoint hit to the user. Even though
5340 reads don't cause value changes, the value may
5341 have changed since the last time it was read, and
5342 since we're not trapping writes, we will not see
5343 those, and as such we should ignore our notion of
5346 2. We're watching the triggered memory for both
5347 reads and writes. There are two ways this may
5350 2.1. This is a target that can't break on data
5351 reads only, but can break on accesses (reads or
5352 writes), such as e.g., x86. We detect this case
5353 at the time we try to insert read watchpoints.
5355 2.2. Otherwise, the target supports read
5356 watchpoints, but, the user set an access or write
5357 watchpoint watching the same memory as this read
5360 If we're watching memory writes as well as reads,
5361 ignore watchpoint hits when we find that the
5362 value hasn't changed, as reads don't cause
5363 changes. This still gives false positives when
5364 the program writes the same value to memory as
5365 what there was already in memory (we will confuse
5366 it for a read), but it's much better than
5369 int other_write_watchpoint
= 0;
5371 if (bl
->watchpoint_type
== hw_read
)
5373 for (breakpoint
*other_b
: all_breakpoints ())
5374 if (other_b
->type
== bp_hardware_watchpoint
5375 || other_b
->type
== bp_access_watchpoint
)
5377 struct watchpoint
*other_w
=
5378 (struct watchpoint
*) other_b
;
5380 if (other_w
->watchpoint_triggered
5381 == watch_triggered_yes
)
5383 other_write_watchpoint
= 1;
5389 if (other_write_watchpoint
5390 || bl
->watchpoint_type
== hw_access
)
5392 /* We're watching the same memory for writes,
5393 and the value changed since the last time we
5394 updated it, so this trap must be for a write.
5396 bs
->print_it
= print_it_noop
;
5401 case WP_VALUE_NOT_CHANGED
:
5402 if (b
->type
== bp_hardware_watchpoint
5403 || b
->type
== bp_watchpoint
)
5405 /* Don't stop: write watchpoints shouldn't fire if
5406 the value hasn't changed. */
5407 bs
->print_it
= print_it_noop
;
5417 else /* !must_check_value */
5419 /* This is a case where some watchpoint(s) triggered, but
5420 not at the address of this watchpoint, or else no
5421 watchpoint triggered after all. So don't print
5422 anything for this watchpoint. */
5423 bs
->print_it
= print_it_noop
;
5429 /* For breakpoints that are currently marked as telling gdb to stop,
5430 check conditions (condition proper, frame, thread and ignore count)
5431 of breakpoint referred to by BS. If we should not stop for this
5432 breakpoint, set BS->stop to 0. */
5435 bpstat_check_breakpoint_conditions (bpstat
*bs
, thread_info
*thread
)
5437 INFRUN_SCOPED_DEBUG_ENTER_EXIT
;
5439 const struct bp_location
*bl
;
5440 struct breakpoint
*b
;
5442 bool condition_result
= true;
5443 struct expression
*cond
;
5445 gdb_assert (bs
->stop
);
5447 /* BS is built for existing struct breakpoint. */
5448 bl
= bs
->bp_location_at
.get ();
5449 gdb_assert (bl
!= NULL
);
5450 b
= bs
->breakpoint_at
;
5451 gdb_assert (b
!= NULL
);
5453 infrun_debug_printf ("thread = %s, breakpoint %d.%d",
5454 thread
->ptid
.to_string ().c_str (),
5455 b
->number
, find_loc_num_by_location (bl
));
5457 /* Even if the target evaluated the condition on its end and notified GDB, we
5458 need to do so again since GDB does not know if we stopped due to a
5459 breakpoint or a single step breakpoint. */
5461 if (frame_id_p (b
->frame_id
)
5462 && b
->frame_id
!= get_stack_frame_id (get_current_frame ()))
5464 infrun_debug_printf ("incorrect frame %s not %s, not stopping",
5465 get_stack_frame_id (get_current_frame ()).to_string ().c_str (),
5466 b
->frame_id
.to_string ().c_str ());
5471 /* If this is a thread/task-specific breakpoint, don't waste cpu
5472 evaluating the condition if this isn't the specified
5474 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5475 || (b
->task
!= -1 && b
->task
!= ada_get_task_number (thread
)))
5477 infrun_debug_printf ("incorrect thread or task, not stopping");
5482 /* Evaluate extension language breakpoints that have a "stop" method
5484 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5486 if (is_watchpoint (b
))
5488 struct watchpoint
*w
= (struct watchpoint
*) b
;
5490 cond
= w
->cond_exp
.get ();
5493 cond
= bl
->cond
.get ();
5495 if (cond
!= nullptr && b
->disposition
!= disp_del_at_next_stop
)
5497 bool within_current_scope
= true;
5498 struct watchpoint
* w
;
5500 /* We use scoped_value_mark because it could be a long time
5501 before we return to the command level and call
5502 free_all_values. We can't call free_all_values because we
5503 might be in the middle of evaluating a function call. */
5504 scoped_value_mark mark
;
5506 if (is_watchpoint (b
))
5507 w
= (struct watchpoint
*) b
;
5511 /* Need to select the frame, with all that implies so that
5512 the conditions will have the right context. Because we
5513 use the frame, we will not see an inlined function's
5514 variables when we arrive at a breakpoint at the start
5515 of the inlined function; the current frame will be the
5517 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5518 select_frame (get_current_frame ());
5521 frame_info_ptr frame
;
5523 /* For local watchpoint expressions, which particular
5524 instance of a local is being watched matters, so we
5525 keep track of the frame to evaluate the expression
5526 in. To evaluate the condition however, it doesn't
5527 really matter which instantiation of the function
5528 where the condition makes sense triggers the
5529 watchpoint. This allows an expression like "watch
5530 global if q > 10" set in `func', catch writes to
5531 global on all threads that call `func', or catch
5532 writes on all recursive calls of `func' by a single
5533 thread. We simply always evaluate the condition in
5534 the innermost frame that's executing where it makes
5535 sense to evaluate the condition. It seems
5537 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5539 select_frame (frame
);
5541 within_current_scope
= false;
5543 if (within_current_scope
)
5547 condition_result
= breakpoint_cond_eval (cond
);
5549 catch (const gdb_exception
&ex
)
5551 exception_fprintf (gdb_stderr
, ex
,
5552 "Error in testing breakpoint condition:\n");
5557 warning (_("Watchpoint condition cannot be tested "
5558 "in the current scope"));
5559 /* If we failed to set the right context for this
5560 watchpoint, unconditionally report it. */
5562 /* FIXME-someday, should give breakpoint #. */
5565 if (cond
!= nullptr && !condition_result
)
5567 infrun_debug_printf ("condition_result = false, not stopping");
5571 else if (b
->ignore_count
> 0)
5573 infrun_debug_printf ("ignore count %d, not stopping",
5577 /* Increase the hit count even though we don't stop. */
5579 gdb::observers::breakpoint_modified
.notify (b
);
5584 infrun_debug_printf ("stopping at this breakpoint");
5586 infrun_debug_printf ("not stopping at this breakpoint");
5589 /* Returns true if we need to track moribund locations of LOC's type
5590 on the current target. */
5593 need_moribund_for_location_type (const struct bp_location
*loc
)
5595 return ((loc
->loc_type
== bp_loc_software_breakpoint
5596 && !target_supports_stopped_by_sw_breakpoint ())
5597 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5598 && !target_supports_stopped_by_hw_breakpoint ()));
5601 /* See breakpoint.h. */
5604 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5605 const target_waitstatus
&ws
)
5607 bpstat
*bs_head
= nullptr, **bs_link
= &bs_head
;
5609 for (breakpoint
*b
: all_breakpoints ())
5611 if (!breakpoint_enabled (b
))
5614 for (bp_location
*bl
: b
->locations ())
5616 /* For hardware watchpoints, we look only at the first
5617 location. The watchpoint_check function will work on the
5618 entire expression, not the individual locations. For
5619 read watchpoints, the watchpoints_triggered function has
5620 checked all locations already. */
5621 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5624 if (!bl
->enabled
|| bl
->disabled_by_cond
|| bl
->shlib_disabled
)
5627 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5630 /* Come here if it's a watchpoint, or if the break address
5633 bpstat
*bs
= new bpstat (bl
, &bs_link
); /* Alloc a bpstat to
5636 /* Assume we stop. Should we find a watchpoint that is not
5637 actually triggered, or if the condition of the breakpoint
5638 evaluates as false, we'll reset 'stop' to 0. */
5642 /* If this is a scope breakpoint, mark the associated
5643 watchpoint as triggered so that we will handle the
5644 out-of-scope event. We'll get to the watchpoint next
5646 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5648 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5650 w
->watchpoint_triggered
= watch_triggered_yes
;
5655 /* Check if a moribund breakpoint explains the stop. */
5656 if (!target_supports_stopped_by_sw_breakpoint ()
5657 || !target_supports_stopped_by_hw_breakpoint ())
5659 for (bp_location
*loc
: moribund_locations
)
5661 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5662 && need_moribund_for_location_type (loc
))
5664 bpstat
*bs
= new bpstat (loc
, &bs_link
);
5665 /* For hits of moribund locations, we should just proceed. */
5668 bs
->print_it
= print_it_noop
;
5676 /* See breakpoint.h. */
5679 bpstat_stop_status (const address_space
*aspace
,
5680 CORE_ADDR bp_addr
, thread_info
*thread
,
5681 const target_waitstatus
&ws
,
5684 struct breakpoint
*b
= NULL
;
5685 /* First item of allocated bpstat's. */
5686 bpstat
*bs_head
= stop_chain
;
5688 int need_remove_insert
;
5691 /* First, build the bpstat chain with locations that explain a
5692 target stop, while being careful to not set the target running,
5693 as that may invalidate locations (in particular watchpoint
5694 locations are recreated). Resuming will happen here with
5695 breakpoint conditions or watchpoint expressions that include
5696 inferior function calls. */
5697 if (bs_head
== NULL
)
5698 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5700 /* A bit of special processing for shlib breakpoints. We need to
5701 process solib loading here, so that the lists of loaded and
5702 unloaded libraries are correct before we handle "catch load" and
5704 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5706 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5708 handle_solib_event ();
5713 /* Now go through the locations that caused the target to stop, and
5714 check whether we're interested in reporting this stop to higher
5715 layers, or whether we should resume the target transparently. */
5719 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5724 b
= bs
->breakpoint_at
;
5725 b
->check_status (bs
);
5728 bpstat_check_breakpoint_conditions (bs
, thread
);
5734 /* We will stop here. */
5735 if (b
->disposition
== disp_disable
)
5737 --(b
->enable_count
);
5738 if (b
->enable_count
<= 0)
5739 b
->enable_state
= bp_disabled
;
5742 gdb::observers::breakpoint_modified
.notify (b
);
5745 bs
->commands
= b
->commands
;
5746 if (command_line_is_silent (bs
->commands
5747 ? bs
->commands
.get () : NULL
))
5750 b
->after_condition_true (bs
);
5755 /* Print nothing for this entry if we don't stop or don't
5757 if (!bs
->stop
|| !bs
->print
)
5758 bs
->print_it
= print_it_noop
;
5761 /* If we aren't stopping, the value of some hardware watchpoint may
5762 not have changed, but the intermediate memory locations we are
5763 watching may have. Don't bother if we're stopping; this will get
5765 need_remove_insert
= 0;
5766 if (! bpstat_causes_stop (bs_head
))
5767 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5769 && bs
->breakpoint_at
5770 && is_hardware_watchpoint (bs
->breakpoint_at
))
5772 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5774 update_watchpoint (w
, false /* don't reparse. */);
5775 need_remove_insert
= 1;
5778 if (need_remove_insert
)
5779 update_global_location_list (UGLL_MAY_INSERT
);
5780 else if (removed_any
)
5781 update_global_location_list (UGLL_DONT_INSERT
);
5786 /* See breakpoint.h. */
5789 bpstat_stop_status_nowatch (const address_space
*aspace
, CORE_ADDR bp_addr
,
5790 thread_info
*thread
, const target_waitstatus
&ws
)
5792 gdb_assert (!target_stopped_by_watchpoint ());
5794 /* Clear all watchpoints' 'watchpoint_triggered' value from a
5795 previous stop to avoid confusing bpstat_stop_status. */
5796 watchpoints_triggered (ws
);
5798 return bpstat_stop_status (aspace
, bp_addr
, thread
, ws
);
5802 handle_jit_event (CORE_ADDR address
)
5804 struct gdbarch
*gdbarch
;
5806 infrun_debug_printf ("handling bp_jit_event");
5808 /* Switch terminal for any messages produced by
5809 breakpoint_re_set. */
5810 target_terminal::ours_for_output ();
5812 gdbarch
= get_frame_arch (get_current_frame ());
5813 /* This event is caused by a breakpoint set in `jit_breakpoint_re_set`,
5814 thus it is expected that its objectfile can be found through
5815 minimal symbol lookup. If it doesn't work (and assert fails), it
5816 most likely means that `jit_breakpoint_re_set` was changes and this
5817 function needs to be updated too. */
5818 bound_minimal_symbol jit_bp_sym
= lookup_minimal_symbol_by_pc (address
);
5819 gdb_assert (jit_bp_sym
.objfile
!= nullptr);
5820 objfile
*objfile
= jit_bp_sym
.objfile
;
5821 if (objfile
->separate_debug_objfile_backlink
)
5822 objfile
= objfile
->separate_debug_objfile_backlink
;
5823 jit_event_handler (gdbarch
, objfile
);
5825 target_terminal::inferior ();
5828 /* Prepare WHAT final decision for infrun. */
5830 /* Decide what infrun needs to do with this bpstat. */
5833 bpstat_what (bpstat
*bs_head
)
5835 struct bpstat_what retval
;
5838 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5839 retval
.call_dummy
= STOP_NONE
;
5840 retval
.is_longjmp
= false;
5842 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5844 /* Extract this BS's action. After processing each BS, we check
5845 if its action overrides all we've seem so far. */
5846 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5849 if (bs
->breakpoint_at
== NULL
)
5851 /* I suspect this can happen if it was a momentary
5852 breakpoint which has since been deleted. */
5856 bptype
= bs
->breakpoint_at
->type
;
5863 case bp_hardware_breakpoint
:
5864 case bp_single_step
:
5867 case bp_shlib_event
:
5871 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5873 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5876 this_action
= BPSTAT_WHAT_SINGLE
;
5879 case bp_hardware_watchpoint
:
5880 case bp_read_watchpoint
:
5881 case bp_access_watchpoint
:
5885 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5887 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5891 /* There was a watchpoint, but we're not stopping.
5892 This requires no further action. */
5896 case bp_longjmp_call_dummy
:
5900 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5901 retval
.is_longjmp
= bptype
!= bp_exception
;
5904 this_action
= BPSTAT_WHAT_SINGLE
;
5906 case bp_longjmp_resume
:
5907 case bp_exception_resume
:
5910 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5911 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5914 this_action
= BPSTAT_WHAT_SINGLE
;
5916 case bp_step_resume
:
5918 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5921 /* It is for the wrong frame. */
5922 this_action
= BPSTAT_WHAT_SINGLE
;
5925 case bp_hp_step_resume
:
5927 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5930 /* It is for the wrong frame. */
5931 this_action
= BPSTAT_WHAT_SINGLE
;
5934 case bp_watchpoint_scope
:
5935 case bp_thread_event
:
5936 case bp_overlay_event
:
5937 case bp_longjmp_master
:
5938 case bp_std_terminate_master
:
5939 case bp_exception_master
:
5940 this_action
= BPSTAT_WHAT_SINGLE
;
5946 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5948 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5952 /* Some catchpoints are implemented with breakpoints.
5953 For those, we need to step over the breakpoint. */
5954 if (bs
->bp_location_at
->loc_type
== bp_loc_software_breakpoint
5955 || bs
->bp_location_at
->loc_type
== bp_loc_hardware_breakpoint
)
5956 this_action
= BPSTAT_WHAT_SINGLE
;
5960 this_action
= BPSTAT_WHAT_SINGLE
;
5963 /* Make sure the action is stop (silent or noisy),
5964 so infrun.c pops the dummy frame. */
5965 retval
.call_dummy
= STOP_STACK_DUMMY
;
5966 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5968 case bp_std_terminate
:
5969 /* Make sure the action is stop (silent or noisy),
5970 so infrun.c pops the dummy frame. */
5971 retval
.call_dummy
= STOP_STD_TERMINATE
;
5972 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5975 case bp_fast_tracepoint
:
5976 case bp_static_tracepoint
:
5977 case bp_static_marker_tracepoint
:
5978 /* Tracepoint hits should not be reported back to GDB, and
5979 if one got through somehow, it should have been filtered
5981 internal_error (_("bpstat_what: tracepoint encountered"));
5983 case bp_gnu_ifunc_resolver
:
5984 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5985 this_action
= BPSTAT_WHAT_SINGLE
;
5987 case bp_gnu_ifunc_resolver_return
:
5988 /* The breakpoint will be removed, execution will restart from the
5989 PC of the former breakpoint. */
5990 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5995 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5997 this_action
= BPSTAT_WHAT_SINGLE
;
6001 internal_error (_("bpstat_what: unhandled bptype %d"), (int) bptype
);
6004 retval
.main_action
= std::max (retval
.main_action
, this_action
);
6011 bpstat_run_callbacks (bpstat
*bs_head
)
6015 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
6017 struct breakpoint
*b
= bs
->breakpoint_at
;
6024 handle_jit_event (bs
->bp_location_at
->address
);
6026 case bp_gnu_ifunc_resolver
:
6027 gnu_ifunc_resolver_stop ((code_breakpoint
*) b
);
6029 case bp_gnu_ifunc_resolver_return
:
6030 gnu_ifunc_resolver_return_stop ((code_breakpoint
*) b
);
6036 /* See breakpoint.h. */
6039 bpstat_should_step ()
6041 for (breakpoint
*b
: all_breakpoints ())
6042 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
6048 /* See breakpoint.h. */
6051 bpstat_causes_stop (bpstat
*bs
)
6053 for (; bs
!= NULL
; bs
= bs
->next
)
6062 /* Compute a number of spaces suitable to indent the next line
6063 so it starts at the position corresponding to the table column
6064 named COL_NAME in the currently active table of UIOUT. */
6067 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
6069 int i
, total_width
, width
, align
;
6073 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
6075 if (strcmp (text
, col_name
) == 0)
6078 total_width
+= width
+ 1;
6084 /* Determine if the locations of this breakpoint will have their conditions
6085 evaluated by the target, host or a mix of both. Returns the following:
6087 "host": Host evals condition.
6088 "host or target": Host or Target evals condition.
6089 "target": Target evals condition.
6093 bp_condition_evaluator (const breakpoint
*b
)
6095 char host_evals
= 0;
6096 char target_evals
= 0;
6101 if (!is_breakpoint (b
))
6104 if (gdb_evaluates_breakpoint_condition_p ()
6105 || !target_supports_evaluation_of_breakpoint_conditions ())
6106 return condition_evaluation_host
;
6108 for (bp_location
*bl
: b
->locations ())
6110 if (bl
->cond_bytecode
)
6116 if (host_evals
&& target_evals
)
6117 return condition_evaluation_both
;
6118 else if (target_evals
)
6119 return condition_evaluation_target
;
6121 return condition_evaluation_host
;
6124 /* Determine the breakpoint location's condition evaluator. This is
6125 similar to bp_condition_evaluator, but for locations. */
6128 bp_location_condition_evaluator (const struct bp_location
*bl
)
6130 if (bl
&& !is_breakpoint (bl
->owner
))
6133 if (gdb_evaluates_breakpoint_condition_p ()
6134 || !target_supports_evaluation_of_breakpoint_conditions ())
6135 return condition_evaluation_host
;
6137 if (bl
&& bl
->cond_bytecode
)
6138 return condition_evaluation_target
;
6140 return condition_evaluation_host
;
6143 /* Print the LOC location out of the list of B->LOC locations. */
6146 print_breakpoint_location (const breakpoint
*b
,
6147 struct bp_location
*loc
)
6149 struct ui_out
*uiout
= current_uiout
;
6151 scoped_restore_current_program_space restore_pspace
;
6153 if (loc
!= NULL
&& loc
->shlib_disabled
)
6157 set_current_program_space (loc
->pspace
);
6159 if (b
->display_canonical
)
6160 uiout
->field_string ("what", b
->locspec
->to_string ());
6161 else if (loc
&& loc
->symtab
)
6163 const struct symbol
*sym
= loc
->symbol
;
6167 uiout
->text ("in ");
6168 uiout
->field_string ("func", sym
->print_name (),
6169 function_name_style
.style ());
6171 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
6172 uiout
->text ("at ");
6174 uiout
->field_string ("file",
6175 symtab_to_filename_for_display (loc
->symtab
),
6176 file_name_style
.style ());
6179 if (uiout
->is_mi_like_p ())
6180 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
6182 uiout
->field_signed ("line", loc
->line_number
);
6188 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
6190 uiout
->field_stream ("at", stb
);
6194 uiout
->field_string ("pending", b
->locspec
->to_string ());
6195 /* If extra_string is available, it could be holding a condition
6196 or dprintf arguments. In either case, make sure it is printed,
6197 too, but only for non-MI streams. */
6198 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
6200 if (b
->type
== bp_dprintf
)
6204 uiout
->text (b
->extra_string
.get ());
6208 if (loc
&& is_breakpoint (b
)
6209 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
6210 && bp_condition_evaluator (b
) == condition_evaluation_both
)
6213 uiout
->field_string ("evaluated-by",
6214 bp_location_condition_evaluator (loc
));
6220 bptype_string (enum bptype type
)
6222 struct ep_type_description
6225 const char *description
;
6227 static struct ep_type_description bptypes
[] =
6229 {bp_none
, "?deleted?"},
6230 {bp_breakpoint
, "breakpoint"},
6231 {bp_hardware_breakpoint
, "hw breakpoint"},
6232 {bp_single_step
, "sw single-step"},
6233 {bp_until
, "until"},
6234 {bp_finish
, "finish"},
6235 {bp_watchpoint
, "watchpoint"},
6236 {bp_hardware_watchpoint
, "hw watchpoint"},
6237 {bp_read_watchpoint
, "read watchpoint"},
6238 {bp_access_watchpoint
, "acc watchpoint"},
6239 {bp_longjmp
, "longjmp"},
6240 {bp_longjmp_resume
, "longjmp resume"},
6241 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
6242 {bp_exception
, "exception"},
6243 {bp_exception_resume
, "exception resume"},
6244 {bp_step_resume
, "step resume"},
6245 {bp_hp_step_resume
, "high-priority step resume"},
6246 {bp_watchpoint_scope
, "watchpoint scope"},
6247 {bp_call_dummy
, "call dummy"},
6248 {bp_std_terminate
, "std::terminate"},
6249 {bp_shlib_event
, "shlib events"},
6250 {bp_thread_event
, "thread events"},
6251 {bp_overlay_event
, "overlay events"},
6252 {bp_longjmp_master
, "longjmp master"},
6253 {bp_std_terminate_master
, "std::terminate master"},
6254 {bp_exception_master
, "exception master"},
6255 {bp_catchpoint
, "catchpoint"},
6256 {bp_tracepoint
, "tracepoint"},
6257 {bp_fast_tracepoint
, "fast tracepoint"},
6258 {bp_static_tracepoint
, "static tracepoint"},
6259 {bp_static_marker_tracepoint
, "static marker tracepoint"},
6260 {bp_dprintf
, "dprintf"},
6261 {bp_jit_event
, "jit events"},
6262 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6263 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6266 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6267 || ((int) type
!= bptypes
[(int) type
].type
))
6268 internal_error (_("bptypes table does not describe type #%d."),
6271 return bptypes
[(int) type
].description
;
6274 /* For MI, output a field named 'thread-groups' with a list as the value.
6275 For CLI, prefix the list with the string 'inf'. */
6278 output_thread_groups (struct ui_out
*uiout
,
6279 const char *field_name
,
6280 const std::vector
<int> &inf_nums
,
6283 int is_mi
= uiout
->is_mi_like_p ();
6285 /* For backward compatibility, don't display inferiors in CLI unless
6286 there are several. Always display them for MI. */
6287 if (!is_mi
&& mi_only
)
6290 ui_out_emit_list
list_emitter (uiout
, field_name
);
6292 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6298 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6299 uiout
->field_string (NULL
, mi_group
);
6304 uiout
->text (" inf ");
6308 uiout
->text (plongest (inf_nums
[i
]));
6313 /* See breakpoint.h. */
6315 bool fix_breakpoint_script_output_globally
= false;
6317 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
6318 instead of going via breakpoint_ops::print_one. This makes "maint
6319 info breakpoints" show the software breakpoint locations of
6320 catchpoints, which are considered internal implementation
6321 detail. Returns true if RAW_LOC is false and if the breakpoint's
6322 print_one method did something; false otherwise. */
6325 print_one_breakpoint_location (struct breakpoint
*b
,
6326 struct bp_location
*loc
,
6328 struct bp_location
**last_loc
,
6329 int allflag
, bool raw_loc
)
6331 struct command_line
*l
;
6332 static char bpenables
[] = "nynny";
6334 struct ui_out
*uiout
= current_uiout
;
6335 bool header_of_multiple
= false;
6336 bool part_of_multiple
= (loc
!= NULL
);
6337 struct value_print_options opts
;
6339 get_user_print_options (&opts
);
6341 gdb_assert (!loc
|| loc_number
!= 0);
6342 /* See comment in print_one_breakpoint concerning treatment of
6343 breakpoints with single disabled location. */
6346 && (b
->loc
->next
!= NULL
6347 || !b
->loc
->enabled
|| b
->loc
->disabled_by_cond
)))
6348 header_of_multiple
= true;
6356 if (part_of_multiple
)
6357 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
6359 uiout
->field_signed ("number", b
->number
);
6363 if (part_of_multiple
)
6364 uiout
->field_skip ("type");
6366 uiout
->field_string ("type", bptype_string (b
->type
));
6370 if (part_of_multiple
)
6371 uiout
->field_skip ("disp");
6373 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6377 if (part_of_multiple
)
6379 /* For locations that are disabled because of an invalid
6380 condition, display "N*" on the CLI, where "*" refers to a
6381 footnote below the table. For MI, simply display a "N"
6382 without a footnote. On the CLI, for enabled locations whose
6383 breakpoint is disabled, display "y-". */
6384 auto get_enable_state
= [uiout
, loc
] () -> const char *
6386 if (uiout
->is_mi_like_p ())
6388 if (loc
->disabled_by_cond
)
6390 else if (!loc
->enabled
)
6397 if (loc
->disabled_by_cond
)
6399 else if (!loc
->enabled
)
6401 else if (!breakpoint_enabled (loc
->owner
))
6407 uiout
->field_string ("enabled", get_enable_state ());
6410 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6413 bool result
= false;
6414 if (!raw_loc
&& b
->print_one (last_loc
))
6418 if (is_watchpoint (b
))
6420 struct watchpoint
*w
= (struct watchpoint
*) b
;
6422 /* Field 4, the address, is omitted (which makes the columns
6423 not line up too nicely with the headers, but the effect
6424 is relatively readable). */
6425 if (opts
.addressprint
)
6426 uiout
->field_skip ("addr");
6428 uiout
->field_string ("what", w
->exp_string
.get ());
6430 else if (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6431 || is_ada_exception_catchpoint (b
))
6433 if (opts
.addressprint
)
6436 if (header_of_multiple
)
6437 uiout
->field_string ("addr", "<MULTIPLE>",
6438 metadata_style
.style ());
6439 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6440 uiout
->field_string ("addr", "<PENDING>",
6441 metadata_style
.style ());
6443 uiout
->field_core_addr ("addr",
6444 loc
->gdbarch
, loc
->address
);
6447 if (!header_of_multiple
)
6448 print_breakpoint_location (b
, loc
);
6454 if (loc
!= NULL
&& !header_of_multiple
)
6456 std::vector
<int> inf_nums
;
6459 for (inferior
*inf
: all_inferiors ())
6461 if (inf
->pspace
== loc
->pspace
)
6462 inf_nums
.push_back (inf
->num
);
6465 /* For backward compatibility, don't display inferiors in CLI unless
6466 there are several. Always display for MI. */
6468 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6469 && (program_spaces
.size () > 1
6470 || number_of_inferiors () > 1)
6471 /* LOC is for existing B, it cannot be in
6472 moribund_locations and thus having NULL OWNER. */
6473 && loc
->owner
->type
!= bp_catchpoint
))
6475 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6478 /* In the MI output, each location of a thread or task specific
6479 breakpoint includes the relevant thread or task ID. This is done for
6480 backwards compatibility reasons.
6482 For the CLI output, the thread/task information is printed on a
6483 separate line, see the 'stop only in thread' and 'stop only in task'
6485 if (!header_of_multiple
&& uiout
->is_mi_like_p ())
6487 if (b
->thread
!= -1)
6488 uiout
->field_signed ("thread", b
->thread
);
6489 else if (b
->task
!= -1)
6490 uiout
->field_signed ("task", b
->task
);
6495 if (!part_of_multiple
)
6496 b
->print_one_detail (uiout
);
6498 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6501 uiout
->text ("\tstop only in stack frame at ");
6502 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6504 uiout
->field_core_addr ("frame",
6505 b
->gdbarch
, b
->frame_id
.stack_addr
);
6509 if (!part_of_multiple
&& b
->cond_string
)
6512 if (is_tracepoint (b
))
6513 uiout
->text ("\ttrace only if ");
6515 uiout
->text ("\tstop only if ");
6516 uiout
->field_string ("cond", b
->cond_string
.get ());
6518 /* Print whether the target is doing the breakpoint's condition
6519 evaluation. If GDB is doing the evaluation, don't print anything. */
6520 if (is_breakpoint (b
)
6521 && breakpoint_condition_evaluation_mode ()
6522 == condition_evaluation_target
)
6524 uiout
->message (" (%pF evals)",
6525 string_field ("evaluated-by",
6526 bp_condition_evaluator (b
)));
6531 if (!part_of_multiple
&& b
->thread
!= -1)
6533 /* FIXME should make an annotation for this. */
6534 uiout
->text ("\tstop only in thread ");
6535 if (uiout
->is_mi_like_p ())
6536 uiout
->field_signed ("thread", b
->thread
);
6539 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6541 uiout
->field_string ("thread", print_thread_id (thr
));
6546 if (!part_of_multiple
&& b
->task
!= -1)
6548 uiout
->text ("\tstop only in task ");
6549 uiout
->field_signed ("task", b
->task
);
6553 if (!part_of_multiple
)
6557 /* FIXME should make an annotation for this. */
6558 if (is_catchpoint (b
))
6559 uiout
->text ("\tcatchpoint");
6560 else if (is_tracepoint (b
))
6561 uiout
->text ("\ttracepoint");
6563 uiout
->text ("\tbreakpoint");
6564 uiout
->text (" already hit ");
6565 uiout
->field_signed ("times", b
->hit_count
);
6566 if (b
->hit_count
== 1)
6567 uiout
->text (" time\n");
6569 uiout
->text (" times\n");
6573 /* Output the count also if it is zero, but only if this is mi. */
6574 if (uiout
->is_mi_like_p ())
6575 uiout
->field_signed ("times", b
->hit_count
);
6579 if (!part_of_multiple
&& b
->ignore_count
)
6582 uiout
->message ("\tignore next %pF hits\n",
6583 signed_field ("ignore", b
->ignore_count
));
6586 /* Note that an enable count of 1 corresponds to "enable once"
6587 behavior, which is reported by the combination of enablement and
6588 disposition, so we don't need to mention it here. */
6589 if (!part_of_multiple
&& b
->enable_count
> 1)
6592 uiout
->text ("\tdisable after ");
6593 /* Tweak the wording to clarify that ignore and enable counts
6594 are distinct, and have additive effect. */
6595 if (b
->ignore_count
)
6596 uiout
->text ("additional ");
6598 uiout
->text ("next ");
6599 uiout
->field_signed ("enable", b
->enable_count
);
6600 uiout
->text (" hits\n");
6603 if (!part_of_multiple
&& is_tracepoint (b
))
6605 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6607 if (tp
->traceframe_usage
)
6609 uiout
->text ("\ttrace buffer usage ");
6610 uiout
->field_signed ("traceframe-usage", tp
->traceframe_usage
);
6611 uiout
->text (" bytes\n");
6615 l
= b
->commands
? b
->commands
.get () : NULL
;
6616 if (!part_of_multiple
&& l
)
6620 bool use_fixed_output
=
6621 (uiout
->test_flags (fix_breakpoint_script_output
)
6622 || fix_breakpoint_script_output_globally
);
6624 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
6625 gdb::optional
<ui_out_emit_list
> list_emitter
;
6627 if (use_fixed_output
)
6628 list_emitter
.emplace (uiout
, "script");
6630 tuple_emitter
.emplace (uiout
, "script");
6632 print_command_lines (uiout
, l
, 4);
6635 if (is_tracepoint (b
))
6637 struct tracepoint
*t
= (struct tracepoint
*) b
;
6639 if (!part_of_multiple
&& t
->pass_count
)
6641 annotate_field (10);
6642 uiout
->text ("\tpass count ");
6643 uiout
->field_signed ("pass", t
->pass_count
);
6644 uiout
->text (" \n");
6647 /* Don't display it when tracepoint or tracepoint location is
6649 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6651 annotate_field (11);
6653 if (uiout
->is_mi_like_p ())
6654 uiout
->field_string ("installed",
6655 loc
->inserted
? "y" : "n");
6661 uiout
->text ("\tnot ");
6662 uiout
->text ("installed on target\n");
6667 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6669 if (is_watchpoint (b
))
6671 struct watchpoint
*w
= (struct watchpoint
*) b
;
6673 uiout
->field_string ("original-location", w
->exp_string
.get ());
6675 else if (b
->locspec
!= nullptr)
6677 const char *str
= b
->locspec
->to_string ();
6679 uiout
->field_string ("original-location", str
);
6686 /* See breakpoint.h. */
6688 bool fix_multi_location_breakpoint_output_globally
= false;
6691 print_one_breakpoint (struct breakpoint
*b
,
6692 struct bp_location
**last_loc
,
6695 struct ui_out
*uiout
= current_uiout
;
6696 bool use_fixed_output
6697 = (uiout
->test_flags (fix_multi_location_breakpoint_output
)
6698 || fix_multi_location_breakpoint_output_globally
);
6700 gdb::optional
<ui_out_emit_tuple
> bkpt_tuple_emitter (gdb::in_place
, uiout
, "bkpt");
6701 bool printed
= print_one_breakpoint_location (b
, NULL
, 0, last_loc
,
6704 /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6706 if (!use_fixed_output
)
6707 bkpt_tuple_emitter
.reset ();
6709 /* If this breakpoint has custom print function,
6710 it's already printed. Otherwise, print individual
6711 locations, if any. */
6712 if (!printed
|| allflag
)
6714 /* If breakpoint has a single location that is disabled, we
6715 print it as if it had several locations, since otherwise it's
6716 hard to represent "breakpoint enabled, location disabled"
6719 Note that while hardware watchpoints have several locations
6720 internally, that's not a property exposed to users.
6722 Likewise, while catchpoints may be implemented with
6723 breakpoints (e.g., catch throw), that's not a property
6724 exposed to users. We do however display the internal
6725 breakpoint locations with "maint info breakpoints". */
6726 if (!is_hardware_watchpoint (b
)
6727 && (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6728 || is_ada_exception_catchpoint (b
))
6730 || (b
->loc
&& (b
->loc
->next
6732 || b
->loc
->disabled_by_cond
))))
6734 gdb::optional
<ui_out_emit_list
> locations_list
;
6736 /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6737 MI record. For later versions, place breakpoint locations in a
6739 if (uiout
->is_mi_like_p () && use_fixed_output
)
6740 locations_list
.emplace (uiout
, "locations");
6743 for (bp_location
*loc
: b
->locations ())
6745 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6746 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6755 breakpoint_address_bits (struct breakpoint
*b
)
6757 int print_address_bits
= 0;
6759 for (bp_location
*loc
: b
->locations ())
6761 if (!bl_address_is_meaningful (loc
))
6764 int addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6765 if (addr_bit
> print_address_bits
)
6766 print_address_bits
= addr_bit
;
6769 return print_address_bits
;
6772 /* See breakpoint.h. */
6775 print_breakpoint (breakpoint
*b
)
6777 struct bp_location
*dummy_loc
= NULL
;
6778 print_one_breakpoint (b
, &dummy_loc
, 0);
6781 /* Return true if this breakpoint was set by the user, false if it is
6782 internal or momentary. */
6785 user_breakpoint_p (struct breakpoint
*b
)
6787 return b
->number
> 0;
6790 /* See breakpoint.h. */
6793 pending_breakpoint_p (struct breakpoint
*b
)
6795 return b
->loc
== NULL
;
6798 /* Print information on breakpoints (including watchpoints and tracepoints).
6800 If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
6801 understood by number_or_range_parser. Only breakpoints included in this
6802 list are then printed.
6804 If SHOW_INTERNAL is true, print internal breakpoints.
6806 If FILTER is non-NULL, call it on each breakpoint and only include the
6807 ones for which it returns true.
6809 Return the total number of breakpoints listed. */
6812 breakpoint_1 (const char *bp_num_list
, bool show_internal
,
6813 bool (*filter
) (const struct breakpoint
*))
6815 struct bp_location
*last_loc
= NULL
;
6816 int nr_printable_breakpoints
;
6817 struct value_print_options opts
;
6818 int print_address_bits
= 0;
6819 int print_type_col_width
= 14;
6820 struct ui_out
*uiout
= current_uiout
;
6821 bool has_disabled_by_cond_location
= false;
6823 get_user_print_options (&opts
);
6825 /* Compute the number of rows in the table, as well as the size
6826 required for address fields. */
6827 nr_printable_breakpoints
= 0;
6828 for (breakpoint
*b
: all_breakpoints ())
6830 /* If we have a filter, only list the breakpoints it accepts. */
6831 if (filter
&& !filter (b
))
6834 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6835 accept. Skip the others. */
6836 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6838 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6840 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6844 if (show_internal
|| user_breakpoint_p (b
))
6846 int addr_bit
, type_len
;
6848 addr_bit
= breakpoint_address_bits (b
);
6849 if (addr_bit
> print_address_bits
)
6850 print_address_bits
= addr_bit
;
6852 type_len
= strlen (bptype_string (b
->type
));
6853 if (type_len
> print_type_col_width
)
6854 print_type_col_width
= type_len
;
6856 nr_printable_breakpoints
++;
6861 ui_out_emit_table
table_emitter (uiout
,
6862 opts
.addressprint
? 6 : 5,
6863 nr_printable_breakpoints
,
6866 if (nr_printable_breakpoints
> 0)
6867 annotate_breakpoints_headers ();
6868 if (nr_printable_breakpoints
> 0)
6870 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6871 if (nr_printable_breakpoints
> 0)
6873 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6874 if (nr_printable_breakpoints
> 0)
6876 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6877 if (nr_printable_breakpoints
> 0)
6879 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6880 if (opts
.addressprint
)
6882 if (nr_printable_breakpoints
> 0)
6884 if (print_address_bits
<= 32)
6885 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6887 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6889 if (nr_printable_breakpoints
> 0)
6891 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6892 uiout
->table_body ();
6893 if (nr_printable_breakpoints
> 0)
6894 annotate_breakpoints_table ();
6896 for (breakpoint
*b
: all_breakpoints ())
6899 /* If we have a filter, only list the breakpoints it accepts. */
6900 if (filter
&& !filter (b
))
6903 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6904 accept. Skip the others. */
6906 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6908 if (show_internal
) /* maintenance info breakpoint */
6910 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6913 else /* all others */
6915 if (!number_is_in_list (bp_num_list
, b
->number
))
6919 /* We only print out user settable breakpoints unless the
6920 show_internal is set. */
6921 if (show_internal
|| user_breakpoint_p (b
))
6923 print_one_breakpoint (b
, &last_loc
, show_internal
);
6924 for (bp_location
*loc
: b
->locations ())
6925 if (loc
->disabled_by_cond
)
6926 has_disabled_by_cond_location
= true;
6931 if (nr_printable_breakpoints
== 0)
6933 /* If there's a filter, let the caller decide how to report
6937 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6938 uiout
->message ("No breakpoints or watchpoints.\n");
6940 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6946 if (last_loc
&& !server_command
)
6947 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6949 if (has_disabled_by_cond_location
&& !uiout
->is_mi_like_p ())
6950 uiout
->message (_("(*): Breakpoint condition is invalid at this "
6954 /* FIXME? Should this be moved up so that it is only called when
6955 there have been breakpoints? */
6956 annotate_breakpoints_table_end ();
6958 return nr_printable_breakpoints
;
6961 /* Display the value of default-collect in a way that is generally
6962 compatible with the breakpoint list. */
6965 default_collect_info (void)
6967 struct ui_out
*uiout
= current_uiout
;
6969 /* If it has no value (which is frequently the case), say nothing; a
6970 message like "No default-collect." gets in user's face when it's
6972 if (default_collect
.empty ())
6975 /* The following phrase lines up nicely with per-tracepoint collect
6977 uiout
->text ("default collect ");
6978 uiout
->field_string ("default-collect", default_collect
);
6979 uiout
->text (" \n");
6983 info_breakpoints_command (const char *args
, int from_tty
)
6985 breakpoint_1 (args
, false, NULL
);
6987 default_collect_info ();
6991 info_watchpoints_command (const char *args
, int from_tty
)
6993 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6994 struct ui_out
*uiout
= current_uiout
;
6996 if (num_printed
== 0)
6998 if (args
== NULL
|| *args
== '\0')
6999 uiout
->message ("No watchpoints.\n");
7001 uiout
->message ("No watchpoint matching '%s'.\n", args
);
7006 maintenance_info_breakpoints (const char *args
, int from_tty
)
7008 breakpoint_1 (args
, true, NULL
);
7010 default_collect_info ();
7014 breakpoint_has_pc (struct breakpoint
*b
,
7015 struct program_space
*pspace
,
7016 CORE_ADDR pc
, struct obj_section
*section
)
7018 for (bp_location
*bl
: b
->locations ())
7020 if (bl
->pspace
== pspace
7021 && bl
->address
== pc
7022 && (!overlay_debugging
|| bl
->section
== section
))
7028 /* See breakpoint.h. */
7031 describe_other_breakpoints (struct gdbarch
*gdbarch
,
7032 struct program_space
*pspace
, CORE_ADDR pc
,
7033 struct obj_section
*section
, int thread
)
7037 for (breakpoint
*b
: all_breakpoints ())
7038 others
+= (user_breakpoint_p (b
)
7039 && breakpoint_has_pc (b
, pspace
, pc
, section
));
7044 gdb_printf (_("Note: breakpoint "));
7045 else /* if (others == ???) */
7046 gdb_printf (_("Note: breakpoints "));
7047 for (breakpoint
*b
: all_breakpoints ())
7048 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
7051 gdb_printf ("%d", b
->number
);
7052 if (b
->thread
== -1 && thread
!= -1)
7053 gdb_printf (" (all threads)");
7054 else if (b
->thread
!= -1)
7056 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
7057 gdb_printf (" (thread %s)", print_thread_id (thr
));
7059 else if (b
->task
!= -1)
7060 gdb_printf (" (task %d)", b
->task
);
7061 gdb_printf ("%s%s ",
7062 ((b
->enable_state
== bp_disabled
7063 || b
->enable_state
== bp_call_disabled
)
7067 : ((others
== 1) ? " and" : ""));
7069 current_uiout
->message (_("also set at pc %ps.\n"),
7070 styled_string (address_style
.style (),
7071 paddress (gdbarch
, pc
)));
7076 /* Return true iff it is meaningful to use the address member of LOC.
7077 For some breakpoint types, the locations' address members are
7078 irrelevant and it makes no sense to attempt to compare them to
7079 other addresses (or use them for any other purpose either).
7081 More specifically, software watchpoints and catchpoints that are
7082 not backed by breakpoints always have a zero valued location
7083 address and we don't want to mark breakpoints of any of these types
7084 to be a duplicate of an actual breakpoint location at address
7088 bl_address_is_meaningful (bp_location
*loc
)
7090 return loc
->loc_type
!= bp_loc_other
;
7093 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
7094 true if LOC1 and LOC2 represent the same watchpoint location. */
7097 watchpoint_locations_match (const struct bp_location
*loc1
,
7098 const struct bp_location
*loc2
)
7100 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
7101 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
7103 /* Both of them must exist. */
7104 gdb_assert (w1
!= NULL
);
7105 gdb_assert (w2
!= NULL
);
7107 /* If the target can evaluate the condition expression in hardware,
7108 then we we need to insert both watchpoints even if they are at
7109 the same place. Otherwise the watchpoint will only trigger when
7110 the condition of whichever watchpoint was inserted evaluates to
7111 true, not giving a chance for GDB to check the condition of the
7112 other watchpoint. */
7114 && target_can_accel_watchpoint_condition (loc1
->address
,
7116 loc1
->watchpoint_type
,
7117 w1
->cond_exp
.get ()))
7119 && target_can_accel_watchpoint_condition (loc2
->address
,
7121 loc2
->watchpoint_type
,
7122 w2
->cond_exp
.get ())))
7125 /* Note that this checks the owner's type, not the location's. In
7126 case the target does not support read watchpoints, but does
7127 support access watchpoints, we'll have bp_read_watchpoint
7128 watchpoints with hw_access locations. Those should be considered
7129 duplicates of hw_read locations. The hw_read locations will
7130 become hw_access locations later. */
7131 return (loc1
->owner
->type
== loc2
->owner
->type
7132 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
7133 && loc1
->address
== loc2
->address
7134 && loc1
->length
== loc2
->length
);
7137 /* See breakpoint.h. */
7140 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
7141 const address_space
*aspace2
, CORE_ADDR addr2
)
7143 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7144 || aspace1
== aspace2
)
7148 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
7149 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
7150 matches ASPACE2. On targets that have global breakpoints, the address
7151 space doesn't really matter. */
7154 breakpoint_address_match_range (const address_space
*aspace1
,
7156 int len1
, const address_space
*aspace2
,
7159 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
7160 || aspace1
== aspace2
)
7161 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
7164 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
7165 a ranged breakpoint. In most targets, a match happens only if ASPACE
7166 matches the breakpoint's address space. On targets that have global
7167 breakpoints, the address space doesn't really matter. */
7170 breakpoint_location_address_match (struct bp_location
*bl
,
7171 const address_space
*aspace
,
7174 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
7177 && breakpoint_address_match_range (bl
->pspace
->aspace
,
7178 bl
->address
, bl
->length
,
7182 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
7183 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
7184 match happens only if ASPACE matches the breakpoint's address
7185 space. On targets that have global breakpoints, the address space
7186 doesn't really matter. */
7189 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
7190 const address_space
*aspace
,
7191 CORE_ADDR addr
, int len
)
7193 if (gdbarch_has_global_breakpoints (target_gdbarch ())
7194 || bl
->pspace
->aspace
== aspace
)
7196 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
7198 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
7204 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
7205 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
7206 true, otherwise returns false. */
7209 tracepoint_locations_match (const struct bp_location
*loc1
,
7210 const struct bp_location
*loc2
)
7212 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
7213 /* Since tracepoint locations are never duplicated with others', tracepoint
7214 locations at the same address of different tracepoints are regarded as
7215 different locations. */
7216 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
7221 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
7222 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
7223 the same location. If SW_HW_BPS_MATCH is true, then software
7224 breakpoint locations and hardware breakpoint locations match,
7225 otherwise they don't. */
7228 breakpoint_locations_match (const struct bp_location
*loc1
,
7229 const struct bp_location
*loc2
,
7230 bool sw_hw_bps_match
)
7232 int hw_point1
, hw_point2
;
7234 /* Both of them must not be in moribund_locations. */
7235 gdb_assert (loc1
->owner
!= NULL
);
7236 gdb_assert (loc2
->owner
!= NULL
);
7238 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
7239 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
7241 if (hw_point1
!= hw_point2
)
7244 return watchpoint_locations_match (loc1
, loc2
);
7245 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
7246 return tracepoint_locations_match (loc1
, loc2
);
7248 /* We compare bp_location.length in order to cover ranged
7249 breakpoints. Keep this in sync with
7250 bp_location_is_less_than. */
7251 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
7252 loc2
->pspace
->aspace
, loc2
->address
)
7253 && (loc1
->loc_type
== loc2
->loc_type
|| sw_hw_bps_match
)
7254 && loc1
->length
== loc2
->length
);
7258 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
7259 int bnum
, bool have_bnum
)
7261 /* The longest string possibly returned by hex_string_custom
7262 is 50 chars. These must be at least that big for safety. */
7266 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
7267 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
7269 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
7270 bnum
, astr1
, astr2
);
7272 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
7275 /* Adjust a breakpoint's address to account for architectural
7276 constraints on breakpoint placement. Return the adjusted address.
7277 Note: Very few targets require this kind of adjustment. For most
7278 targets, this function is simply the identity function. */
7281 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
7282 CORE_ADDR bpaddr
, enum bptype bptype
,
7283 struct program_space
*pspace
)
7285 gdb_assert (pspace
!= nullptr);
7287 if (bptype
== bp_watchpoint
7288 || bptype
== bp_hardware_watchpoint
7289 || bptype
== bp_read_watchpoint
7290 || bptype
== bp_access_watchpoint
7291 || bptype
== bp_catchpoint
)
7293 /* Watchpoints and the various bp_catch_* eventpoints should not
7294 have their addresses modified. */
7297 else if (bptype
== bp_single_step
)
7299 /* Single-step breakpoints should not have their addresses
7300 modified. If there's any architectural constrain that
7301 applies to this address, then it should have already been
7302 taken into account when the breakpoint was created in the
7303 first place. If we didn't do this, stepping through e.g.,
7304 Thumb-2 IT blocks would break. */
7309 CORE_ADDR adjusted_bpaddr
= bpaddr
;
7311 /* Some targets have architectural constraints on the placement
7312 of breakpoint instructions. Obtain the adjusted address. */
7313 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7315 /* Targets that implement this adjustment function will likely
7316 inspect either the symbol table, target memory at BPADDR, or
7317 even state registers, so ensure a suitable thread (and its
7318 associated program space) are currently selected. */
7319 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
7320 switch_to_program_space_and_thread (pspace
);
7322 = gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7326 = gdbarch_remove_non_address_bits (gdbarch
, adjusted_bpaddr
);
7328 /* An adjusted breakpoint address can significantly alter
7329 a user's expectations. Print a warning if an adjustment
7331 if (adjusted_bpaddr
!= bpaddr
)
7332 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, false);
7334 return adjusted_bpaddr
;
7339 bp_location_from_bp_type (bptype type
)
7344 case bp_single_step
:
7348 case bp_longjmp_resume
:
7349 case bp_longjmp_call_dummy
:
7351 case bp_exception_resume
:
7352 case bp_step_resume
:
7353 case bp_hp_step_resume
:
7354 case bp_watchpoint_scope
:
7356 case bp_std_terminate
:
7357 case bp_shlib_event
:
7358 case bp_thread_event
:
7359 case bp_overlay_event
:
7361 case bp_longjmp_master
:
7362 case bp_std_terminate_master
:
7363 case bp_exception_master
:
7364 case bp_gnu_ifunc_resolver
:
7365 case bp_gnu_ifunc_resolver_return
:
7367 return bp_loc_software_breakpoint
;
7368 case bp_hardware_breakpoint
:
7369 return bp_loc_hardware_breakpoint
;
7370 case bp_hardware_watchpoint
:
7371 case bp_read_watchpoint
:
7372 case bp_access_watchpoint
:
7373 return bp_loc_hardware_watchpoint
;
7375 return bp_loc_software_watchpoint
;
7378 case bp_fast_tracepoint
:
7379 case bp_static_tracepoint
:
7380 case bp_static_marker_tracepoint
:
7381 return bp_loc_other
;
7383 internal_error (_("unknown breakpoint type"));
7387 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
7389 this->owner
= owner
;
7390 this->cond_bytecode
= NULL
;
7391 this->shlib_disabled
= 0;
7393 this->disabled_by_cond
= false;
7395 this->loc_type
= type
;
7397 if (this->loc_type
== bp_loc_software_breakpoint
7398 || this->loc_type
== bp_loc_hardware_breakpoint
)
7399 mark_breakpoint_location_modified (this);
7404 bp_location::bp_location (breakpoint
*owner
)
7405 : bp_location::bp_location (owner
,
7406 bp_location_from_bp_type (owner
->type
))
7410 /* Decrement reference count. If the reference count reaches 0,
7411 destroy the bp_location. Sets *BLP to NULL. */
7414 decref_bp_location (struct bp_location
**blp
)
7416 bp_location_ref_policy::decref (*blp
);
7420 /* Add breakpoint B at the end of the global breakpoint chain. */
7423 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7425 struct breakpoint
*b1
;
7426 struct breakpoint
*result
= b
.get ();
7428 /* Add this breakpoint to the end of the chain so that a list of
7429 breakpoints will come out in order of increasing numbers. */
7431 b1
= breakpoint_chain
;
7433 breakpoint_chain
= b
.release ();
7438 b1
->next
= b
.release ();
7444 /* Initialize loc->function_name. */
7447 set_breakpoint_location_function (struct bp_location
*loc
)
7449 gdb_assert (loc
->owner
!= NULL
);
7451 if (loc
->owner
->type
== bp_breakpoint
7452 || loc
->owner
->type
== bp_hardware_breakpoint
7453 || is_tracepoint (loc
->owner
))
7455 const char *function_name
;
7457 if (loc
->msymbol
!= NULL
7458 && (loc
->msymbol
->type () == mst_text_gnu_ifunc
7459 || loc
->msymbol
->type () == mst_data_gnu_ifunc
))
7461 struct breakpoint
*b
= loc
->owner
;
7463 function_name
= loc
->msymbol
->linkage_name ();
7465 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7466 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7468 /* Create only the whole new breakpoint of this type but do not
7469 mess more complicated breakpoints with multiple locations. */
7470 b
->type
= bp_gnu_ifunc_resolver
;
7471 /* Remember the resolver's address for use by the return
7473 loc
->related_address
= loc
->address
;
7477 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7480 loc
->function_name
= make_unique_xstrdup (function_name
);
7484 /* Attempt to determine architecture of location identified by SAL. */
7486 get_sal_arch (struct symtab_and_line sal
)
7489 return sal
.section
->objfile
->arch ();
7491 return sal
.symtab
->compunit ()->objfile ()->arch ();
7496 /* Call this routine when stepping and nexting to enable a breakpoint
7497 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7498 initiated the operation. */
7501 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7503 int thread
= tp
->global_num
;
7505 /* To avoid having to rescan all objfile symbols at every step,
7506 we maintain a list of continually-inserted but always disabled
7507 longjmp "master" breakpoints. Here, we simply create momentary
7508 clones of those and enable them for the requested thread. */
7509 for (breakpoint
*b
: all_breakpoints_safe ())
7510 if (b
->pspace
== current_program_space
7511 && (b
->type
== bp_longjmp_master
7512 || b
->type
== bp_exception_master
))
7514 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7515 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7516 after their removal. */
7517 momentary_breakpoint_from_master (b
, type
, 1, thread
);
7520 tp
->initiating_frame
= frame
;
7523 /* Delete all longjmp breakpoints from THREAD. */
7525 delete_longjmp_breakpoint (int thread
)
7527 for (breakpoint
*b
: all_breakpoints_safe ())
7528 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7530 if (b
->thread
== thread
)
7531 delete_breakpoint (b
);
7536 delete_longjmp_breakpoint_at_next_stop (int thread
)
7538 for (breakpoint
*b
: all_breakpoints_safe ())
7539 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7541 if (b
->thread
== thread
)
7542 b
->disposition
= disp_del_at_next_stop
;
7546 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7547 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7548 pointer to any of them. Return NULL if this system cannot place longjmp
7552 set_longjmp_breakpoint_for_call_dummy (void)
7554 breakpoint
*retval
= nullptr;
7556 for (breakpoint
*b
: all_breakpoints ())
7557 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7559 int thread
= inferior_thread ()->global_num
;
7561 = momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7564 /* Link NEW_B into the chain of RETVAL breakpoints. */
7566 gdb_assert (new_b
->related_breakpoint
== new_b
);
7569 new_b
->related_breakpoint
= retval
;
7570 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7571 retval
= retval
->related_breakpoint
;
7572 retval
->related_breakpoint
= new_b
;
7578 /* Verify all existing dummy frames and their associated breakpoints for
7579 TP. Remove those which can no longer be found in the current frame
7582 If the unwind fails then there is not sufficient information to discard
7583 dummy frames. In this case, elide the clean up and the dummy frames will
7584 be cleaned up next time this function is called from a location where
7585 unwinding is possible. */
7588 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7590 struct breakpoint
*b
, *b_tmp
;
7592 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7593 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7595 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7597 /* Find the bp_call_dummy breakpoint in the list of breakpoints
7598 chained off b->related_breakpoint. */
7599 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7600 dummy_b
= dummy_b
->related_breakpoint
;
7602 /* If there was no bp_call_dummy breakpoint then there's nothing
7603 more to do. Or, if the dummy frame associated with the
7604 bp_call_dummy is still on the stack then we need to leave this
7605 bp_call_dummy in place. */
7606 if (dummy_b
->type
!= bp_call_dummy
7607 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7610 /* We didn't find the dummy frame on the stack, this could be
7611 because we have longjmp'd to a stack frame that is previous to
7612 the dummy frame, or it could be because the stack unwind is
7613 broken at some point between the longjmp frame and the dummy
7616 Next we figure out why the stack unwind stopped. If it looks
7617 like the unwind is complete then we assume the dummy frame has
7618 been jumped over, however, if the unwind stopped for an
7619 unexpected reason then we assume the stack unwind is currently
7620 broken, and that we will (eventually) return to the dummy
7623 It might be tempting to consider using frame_id_inner here, but
7624 that is not safe. There is no guarantee that the stack frames
7625 we are looking at here are even on the same stack as the
7626 original dummy frame, hence frame_id_inner can't be used. See
7627 the comments on frame_id_inner for more details. */
7628 bool unwind_finished_unexpectedly
= false;
7629 for (frame_info_ptr fi
= get_current_frame (); fi
!= nullptr; )
7631 frame_info_ptr prev
= get_prev_frame (fi
);
7632 if (prev
== nullptr)
7634 /* FI is the last stack frame. Why did this frame not
7636 auto stop_reason
= get_frame_unwind_stop_reason (fi
);
7637 if (stop_reason
!= UNWIND_NO_REASON
7638 && stop_reason
!= UNWIND_OUTERMOST
)
7639 unwind_finished_unexpectedly
= true;
7643 if (unwind_finished_unexpectedly
)
7646 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7648 while (b
->related_breakpoint
!= b
)
7650 if (b_tmp
== b
->related_breakpoint
)
7651 b_tmp
= b
->related_breakpoint
->next
;
7652 delete_breakpoint (b
->related_breakpoint
);
7654 delete_breakpoint (b
);
7659 enable_overlay_breakpoints (void)
7661 for (breakpoint
*b
: all_breakpoints ())
7662 if (b
->type
== bp_overlay_event
)
7664 b
->enable_state
= bp_enabled
;
7665 update_global_location_list (UGLL_MAY_INSERT
);
7666 overlay_events_enabled
= 1;
7671 disable_overlay_breakpoints (void)
7673 for (breakpoint
*b
: all_breakpoints ())
7674 if (b
->type
== bp_overlay_event
)
7676 b
->enable_state
= bp_disabled
;
7677 update_global_location_list (UGLL_DONT_INSERT
);
7678 overlay_events_enabled
= 0;
7682 /* Set an active std::terminate breakpoint for each std::terminate
7683 master breakpoint. */
7685 set_std_terminate_breakpoint (void)
7687 for (breakpoint
*b
: all_breakpoints_safe ())
7688 if (b
->pspace
== current_program_space
7689 && b
->type
== bp_std_terminate_master
)
7691 momentary_breakpoint_from_master (b
, bp_std_terminate
, 1,
7692 inferior_thread ()->global_num
);
7696 /* Delete all the std::terminate breakpoints. */
7698 delete_std_terminate_breakpoint (void)
7700 for (breakpoint
*b
: all_breakpoints_safe ())
7701 if (b
->type
== bp_std_terminate
)
7702 delete_breakpoint (b
);
7706 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7708 struct breakpoint
*b
;
7710 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
);
7712 b
->enable_state
= bp_enabled
;
7713 /* locspec has to be used or breakpoint_re_set will delete me. */
7714 b
->locspec
= new_address_location_spec (b
->loc
->address
, NULL
, 0);
7716 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7721 struct lang_and_radix
7727 /* Create a breakpoint for JIT code registration and unregistration. */
7730 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7732 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
);
7735 /* Remove JIT code registration and unregistration breakpoint(s). */
7738 remove_jit_event_breakpoints (void)
7740 for (breakpoint
*b
: all_breakpoints_safe ())
7741 if (b
->type
== bp_jit_event
7742 && b
->loc
->pspace
== current_program_space
)
7743 delete_breakpoint (b
);
7747 remove_solib_event_breakpoints (void)
7749 for (breakpoint
*b
: all_breakpoints_safe ())
7750 if (b
->type
== bp_shlib_event
7751 && b
->loc
->pspace
== current_program_space
)
7752 delete_breakpoint (b
);
7755 /* See breakpoint.h. */
7758 remove_solib_event_breakpoints_at_next_stop (void)
7760 for (breakpoint
*b
: all_breakpoints_safe ())
7761 if (b
->type
== bp_shlib_event
7762 && b
->loc
->pspace
== current_program_space
)
7763 b
->disposition
= disp_del_at_next_stop
;
7766 /* Helper for create_solib_event_breakpoint /
7767 create_and_insert_solib_event_breakpoint. Allows specifying which
7768 INSERT_MODE to pass through to update_global_location_list. */
7770 static struct breakpoint
*
7771 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7772 enum ugll_insert_mode insert_mode
)
7774 struct breakpoint
*b
;
7776 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
);
7777 update_global_location_list_nothrow (insert_mode
);
7782 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7784 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7787 /* See breakpoint.h. */
7790 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7792 struct breakpoint
*b
;
7794 /* Explicitly tell update_global_location_list to insert
7796 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7797 if (!b
->loc
->inserted
)
7799 delete_breakpoint (b
);
7805 /* Disable any breakpoints that are on code in shared libraries. Only
7806 apply to enabled breakpoints, disabled ones can just stay disabled. */
7809 disable_breakpoints_in_shlibs (void)
7811 for (bp_location
*loc
: all_bp_locations ())
7813 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7814 struct breakpoint
*b
= loc
->owner
;
7816 /* We apply the check to all breakpoints, including disabled for
7817 those with loc->duplicate set. This is so that when breakpoint
7818 becomes enabled, or the duplicate is removed, gdb will try to
7819 insert all breakpoints. If we don't set shlib_disabled here,
7820 we'll try to insert those breakpoints and fail. */
7821 if (((b
->type
== bp_breakpoint
)
7822 || (b
->type
== bp_jit_event
)
7823 || (b
->type
== bp_hardware_breakpoint
)
7824 || (is_tracepoint (b
)))
7825 && loc
->pspace
== current_program_space
7826 && !loc
->shlib_disabled
7827 && solib_name_from_address (loc
->pspace
, loc
->address
)
7830 loc
->shlib_disabled
= 1;
7835 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7836 notification of unloaded_shlib. Only apply to enabled breakpoints,
7837 disabled ones can just stay disabled. */
7840 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7842 bool disabled_shlib_breaks
= false;
7844 for (bp_location
*loc
: all_bp_locations ())
7846 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7847 struct breakpoint
*b
= loc
->owner
;
7849 if (solib
->pspace
== loc
->pspace
7850 && !loc
->shlib_disabled
7851 && (((b
->type
== bp_breakpoint
7852 || b
->type
== bp_jit_event
7853 || b
->type
== bp_hardware_breakpoint
)
7854 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7855 || loc
->loc_type
== bp_loc_software_breakpoint
))
7856 || is_tracepoint (b
))
7857 && solib_contains_address_p (solib
, loc
->address
))
7859 loc
->shlib_disabled
= 1;
7860 /* At this point, we cannot rely on remove_breakpoint
7861 succeeding so we must mark the breakpoint as not inserted
7862 to prevent future errors occurring in remove_breakpoints. */
7865 /* This may cause duplicate notifications for the same breakpoint. */
7866 gdb::observers::breakpoint_modified
.notify (b
);
7868 if (!disabled_shlib_breaks
)
7870 target_terminal::ours_for_output ();
7871 warning (_("Temporarily disabling breakpoints "
7872 "for unloaded shared library \"%s\""),
7875 disabled_shlib_breaks
= true;
7880 /* Disable any breakpoints and tracepoints in OBJFILE upon
7881 notification of free_objfile. Only apply to enabled breakpoints,
7882 disabled ones can just stay disabled. */
7885 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7887 if (objfile
== NULL
)
7890 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7891 managed by the user with add-symbol-file/remove-symbol-file.
7892 Similarly to how breakpoints in shared libraries are handled in
7893 response to "nosharedlibrary", mark breakpoints in such modules
7894 shlib_disabled so they end up uninserted on the next global
7895 location list update. Shared libraries not loaded by the user
7896 aren't handled here -- they're already handled in
7897 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7898 solib_unloaded observer. We skip objfiles that are not
7899 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7901 if ((objfile
->flags
& OBJF_SHARED
) == 0
7902 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7905 for (breakpoint
*b
: all_breakpoints ())
7907 bool bp_modified
= false;
7909 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7912 for (bp_location
*loc
: b
->locations ())
7914 CORE_ADDR loc_addr
= loc
->address
;
7916 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7917 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7920 if (loc
->shlib_disabled
!= 0)
7923 if (objfile
->pspace
!= loc
->pspace
)
7926 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7927 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7930 if (is_addr_in_objfile (loc_addr
, objfile
))
7932 loc
->shlib_disabled
= 1;
7933 /* At this point, we don't know whether the object was
7934 unmapped from the inferior or not, so leave the
7935 inserted flag alone. We'll handle failure to
7936 uninsert quietly, in case the object was indeed
7939 mark_breakpoint_location_modified (loc
);
7946 gdb::observers::breakpoint_modified
.notify (b
);
7950 /* See breakpoint.h. */
7952 breakpoint::breakpoint (struct gdbarch
*gdbarch_
, enum bptype bptype
,
7953 bool temp
, const char *cond_string_
)
7955 disposition (temp
? disp_del
: disp_donttouch
),
7957 language (current_language
->la_language
),
7958 input_radix (::input_radix
),
7959 cond_string (cond_string_
!= nullptr
7960 ? make_unique_xstrdup (cond_string_
)
7962 related_breakpoint (this)
7966 /* See breakpoint.h. */
7968 catchpoint::catchpoint (struct gdbarch
*gdbarch
, bool temp
,
7969 const char *cond_string
)
7970 : breakpoint (gdbarch
, bp_catchpoint
, temp
, cond_string
)
7972 add_dummy_location (this, current_program_space
);
7974 pspace
= current_program_space
;
7978 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
7980 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
7981 set_breakpoint_number (internal
, b
);
7982 if (is_tracepoint (b
))
7983 set_tracepoint_count (breakpoint_count
);
7986 gdb::observers::breakpoint_created
.notify (b
);
7989 update_global_location_list (UGLL_MAY_INSERT
);
7995 hw_breakpoint_used_count (void)
7999 for (breakpoint
*b
: all_breakpoints ())
8000 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8001 for (bp_location
*bl
: b
->locations ())
8003 /* Special types of hardware breakpoints may use more than
8005 i
+= b
->resources_needed (bl
);
8011 /* Returns the resources B would use if it were a hardware
8015 hw_watchpoint_use_count (struct breakpoint
*b
)
8019 if (!breakpoint_enabled (b
))
8022 for (bp_location
*bl
: b
->locations ())
8024 /* Special types of hardware watchpoints may use more than
8026 i
+= b
->resources_needed (bl
);
8032 /* Returns the sum the used resources of all hardware watchpoints of
8033 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8034 the sum of the used resources of all hardware watchpoints of other
8035 types _not_ TYPE. */
8038 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8039 enum bptype type
, int *other_type_used
)
8043 *other_type_used
= 0;
8044 for (breakpoint
*b
: all_breakpoints ())
8048 if (!breakpoint_enabled (b
))
8051 if (b
->type
== type
)
8052 i
+= hw_watchpoint_use_count (b
);
8053 else if (is_hardware_watchpoint (b
))
8054 *other_type_used
= 1;
8061 disable_watchpoints_before_interactive_call_start (void)
8063 for (breakpoint
*b
: all_breakpoints ())
8064 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8066 b
->enable_state
= bp_call_disabled
;
8067 update_global_location_list (UGLL_DONT_INSERT
);
8072 enable_watchpoints_after_interactive_call_stop (void)
8074 for (breakpoint
*b
: all_breakpoints ())
8075 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8077 b
->enable_state
= bp_enabled
;
8078 update_global_location_list (UGLL_MAY_INSERT
);
8083 disable_breakpoints_before_startup (void)
8085 current_program_space
->executing_startup
= 1;
8086 update_global_location_list (UGLL_DONT_INSERT
);
8090 enable_breakpoints_after_startup (void)
8092 current_program_space
->executing_startup
= 0;
8093 breakpoint_re_set ();
8096 /* Allocate a new momentary breakpoint. */
8098 template<typename
... Arg
>
8099 static momentary_breakpoint
*
8100 new_momentary_breakpoint (struct gdbarch
*gdbarch
, enum bptype type
,
8103 if (type
== bp_longjmp
|| type
== bp_exception
)
8104 return new longjmp_breakpoint (gdbarch
, type
,
8105 std::forward
<Arg
> (args
)...);
8107 return new momentary_breakpoint (gdbarch
, type
,
8108 std::forward
<Arg
> (args
)...);
8111 /* Set a momentary breakpoint of type TYPE at address specified by
8112 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8116 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8117 struct frame_id frame_id
, enum bptype type
)
8119 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8121 gdb_assert (!frame_id_artificial_p (frame_id
));
8123 std::unique_ptr
<momentary_breakpoint
> b
8124 (new_momentary_breakpoint (gdbarch
, type
, sal
.pspace
, frame_id
,
8125 inferior_thread ()->global_num
));
8127 b
->add_location (sal
);
8129 breakpoint_up
bp (add_to_breakpoint_chain (std::move (b
)));
8131 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8136 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8137 The new breakpoint will have type TYPE, use OPS as its
8138 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8140 static struct breakpoint
*
8141 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8146 std::unique_ptr
<breakpoint
> copy
8147 (new_momentary_breakpoint (orig
->gdbarch
, type
, orig
->pspace
,
8148 orig
->frame_id
, thread
));
8149 copy
->loc
= copy
->allocate_location ();
8150 set_breakpoint_location_function (copy
->loc
);
8152 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8153 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8154 copy
->loc
->address
= orig
->loc
->address
;
8155 copy
->loc
->section
= orig
->loc
->section
;
8156 copy
->loc
->pspace
= orig
->loc
->pspace
;
8157 copy
->loc
->probe
= orig
->loc
->probe
;
8158 copy
->loc
->line_number
= orig
->loc
->line_number
;
8159 copy
->loc
->symtab
= orig
->loc
->symtab
;
8160 copy
->loc
->enabled
= loc_enabled
;
8162 breakpoint
*b
= add_to_breakpoint_chain (std::move (copy
));
8163 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8167 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8171 clone_momentary_breakpoint (struct breakpoint
*orig
)
8173 /* If there's nothing to clone, then return nothing. */
8177 return momentary_breakpoint_from_master (orig
, orig
->type
, 0,
8182 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8185 struct symtab_and_line sal
;
8187 sal
= find_pc_line (pc
, 0);
8189 sal
.section
= find_pc_overlay (pc
);
8190 sal
.explicit_pc
= 1;
8192 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8196 /* Tell the user we have just set a breakpoint B. */
8199 mention (const breakpoint
*b
)
8201 b
->print_mention ();
8202 current_uiout
->text ("\n");
8206 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8208 /* Handle "set breakpoint auto-hw on".
8210 If the explicitly specified breakpoint type is not hardware
8211 breakpoint, check the memory map to see whether the breakpoint
8212 address is in read-only memory.
8214 - location type is not hardware breakpoint, memory is read-only.
8215 We change the type of the location to hardware breakpoint.
8217 - location type is hardware breakpoint, memory is read-write. This
8218 means we've previously made the location hardware one, but then the
8219 memory map changed, so we undo.
8223 handle_automatic_hardware_breakpoints (bp_location
*bl
)
8225 if (automatic_hardware_breakpoints
8226 && bl
->owner
->type
!= bp_hardware_breakpoint
8227 && (bl
->loc_type
== bp_loc_software_breakpoint
8228 || bl
->loc_type
== bp_loc_hardware_breakpoint
))
8230 /* When breakpoints are removed, remove_breakpoints will use
8231 location types we've just set here, the only possible problem
8232 is that memory map has changed during running program, but
8233 it's not going to work anyway with current gdb. */
8234 mem_region
*mr
= lookup_mem_region (bl
->address
);
8238 enum bp_loc_type new_type
;
8240 if (mr
->attrib
.mode
!= MEM_RW
)
8241 new_type
= bp_loc_hardware_breakpoint
;
8243 new_type
= bp_loc_software_breakpoint
;
8245 if (new_type
!= bl
->loc_type
)
8247 static bool said
= false;
8249 bl
->loc_type
= new_type
;
8252 gdb_printf (_("Note: automatically using "
8253 "hardware breakpoints for "
8254 "read-only addresses.\n"));
8263 code_breakpoint::add_location (const symtab_and_line
&sal
)
8265 struct bp_location
*new_loc
, **tmp
;
8266 CORE_ADDR adjusted_address
;
8267 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8269 if (loc_gdbarch
== NULL
)
8270 loc_gdbarch
= gdbarch
;
8272 /* Adjust the breakpoint's address prior to allocating a location.
8273 Once we call allocate_location(), that mostly uninitialized
8274 location will be placed on the location chain. Adjustment of the
8275 breakpoint may cause target_read_memory() to be called and we do
8276 not want its scan of the location chain to find a breakpoint and
8277 location that's only been partially initialized. */
8278 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8282 /* Sort the locations by their ADDRESS. */
8283 new_loc
= allocate_location ();
8284 for (tmp
= &(loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8285 tmp
= &((*tmp
)->next
))
8287 new_loc
->next
= *tmp
;
8290 new_loc
->requested_address
= sal
.pc
;
8291 new_loc
->address
= adjusted_address
;
8292 new_loc
->pspace
= sal
.pspace
;
8293 new_loc
->probe
.prob
= sal
.prob
;
8294 new_loc
->probe
.objfile
= sal
.objfile
;
8295 gdb_assert (new_loc
->pspace
!= NULL
);
8296 new_loc
->section
= sal
.section
;
8297 new_loc
->gdbarch
= loc_gdbarch
;
8298 new_loc
->line_number
= sal
.line
;
8299 new_loc
->symtab
= sal
.symtab
;
8300 new_loc
->symbol
= sal
.symbol
;
8301 new_loc
->msymbol
= sal
.msymbol
;
8302 new_loc
->objfile
= sal
.objfile
;
8304 set_breakpoint_location_function (new_loc
);
8306 /* While by definition, permanent breakpoints are already present in the
8307 code, we don't mark the location as inserted. Normally one would expect
8308 that GDB could rely on that breakpoint instruction to stop the program,
8309 thus removing the need to insert its own breakpoint, except that executing
8310 the breakpoint instruction can kill the target instead of reporting a
8311 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8312 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8313 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8314 breakpoint be inserted normally results in QEMU knowing about the GDB
8315 breakpoint, and thus trap before the breakpoint instruction is executed.
8316 (If GDB later needs to continue execution past the permanent breakpoint,
8317 it manually increments the PC, thus avoiding executing the breakpoint
8319 if (bp_loc_is_permanent (new_loc
))
8320 new_loc
->permanent
= 1;
8326 /* Return true if LOC is pointing to a permanent breakpoint,
8327 return false otherwise. */
8330 bp_loc_is_permanent (struct bp_location
*loc
)
8332 gdb_assert (loc
!= NULL
);
8334 /* If we have a non-breakpoint-backed catchpoint or a software
8335 watchpoint, just return 0. We should not attempt to read from
8336 the addresses the locations of these breakpoint types point to.
8337 gdbarch_program_breakpoint_here_p, below, will attempt to read
8339 if (!bl_address_is_meaningful (loc
))
8342 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8343 switch_to_program_space_and_thread (loc
->pspace
);
8344 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8347 /* Build a command list for the dprintf corresponding to the current
8348 settings of the dprintf style options. */
8351 update_dprintf_command_list (struct breakpoint
*b
)
8353 const char *dprintf_args
= b
->extra_string
.get ();
8354 gdb::unique_xmalloc_ptr
<char> printf_line
= nullptr;
8359 dprintf_args
= skip_spaces (dprintf_args
);
8361 /* Allow a comma, as it may have terminated a location, but don't
8363 if (*dprintf_args
== ',')
8365 dprintf_args
= skip_spaces (dprintf_args
);
8367 if (*dprintf_args
!= '"')
8368 error (_("Bad format string, missing '\"'."));
8370 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8371 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8372 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8374 if (dprintf_function
.empty ())
8375 error (_("No function supplied for dprintf call"));
8377 if (!dprintf_channel
.empty ())
8378 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8379 dprintf_function
.c_str (),
8380 dprintf_channel
.c_str (),
8383 printf_line
= xstrprintf ("call (void) %s (%s)",
8384 dprintf_function
.c_str (),
8387 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8389 if (target_can_run_breakpoint_commands ())
8390 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8393 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8394 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8398 internal_error (_("Invalid dprintf style."));
8400 gdb_assert (printf_line
!= NULL
);
8402 /* Manufacture a printf sequence. */
8403 struct command_line
*printf_cmd_line
8404 = new struct command_line (simple_control
, printf_line
.release ());
8405 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8406 command_lines_deleter ()));
8409 /* Update all dprintf commands, making their command lists reflect
8410 current style settings. */
8413 update_dprintf_commands (const char *args
, int from_tty
,
8414 struct cmd_list_element
*c
)
8416 for (breakpoint
*b
: all_breakpoints ())
8417 if (b
->type
== bp_dprintf
)
8418 update_dprintf_command_list (b
);
8421 code_breakpoint::code_breakpoint (struct gdbarch
*gdbarch_
,
8423 gdb::array_view
<const symtab_and_line
> sals
,
8424 location_spec_up
&&locspec_
,
8425 gdb::unique_xmalloc_ptr
<char> filter_
,
8426 gdb::unique_xmalloc_ptr
<char> cond_string_
,
8427 gdb::unique_xmalloc_ptr
<char> extra_string_
,
8428 enum bpdisp disposition_
,
8429 int thread_
, int task_
, int ignore_count_
,
8431 int enabled_
, unsigned flags
,
8432 int display_canonical_
)
8433 : breakpoint (gdbarch_
, type_
)
8437 if (type
== bp_hardware_breakpoint
)
8439 int target_resources_ok
;
8441 i
= hw_breakpoint_used_count ();
8442 target_resources_ok
=
8443 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8445 if (target_resources_ok
== 0)
8446 error (_("No hardware breakpoint support in the target."));
8447 else if (target_resources_ok
< 0)
8448 error (_("Hardware breakpoints used exceeds limit."));
8451 gdb_assert (!sals
.empty ());
8453 /* At most one of thread or task can be set on any breakpoint. */
8454 gdb_assert (thread
== -1 || task
== -1);
8458 cond_string
= std::move (cond_string_
);
8459 extra_string
= std::move (extra_string_
);
8460 ignore_count
= ignore_count_
;
8461 enable_state
= enabled_
? bp_enabled
: bp_disabled
;
8462 disposition
= disposition_
;
8464 if (type
== bp_static_tracepoint
8465 || type
== bp_static_marker_tracepoint
)
8467 auto *t
= gdb::checked_static_cast
<struct tracepoint
*> (this);
8468 struct static_tracepoint_marker marker
;
8470 if (strace_marker_p (this))
8472 /* We already know the marker exists, otherwise, we wouldn't
8473 see a sal for it. */
8474 const char *p
= &locspec_
->to_string ()[3];
8477 p
= skip_spaces (p
);
8479 endp
= skip_to_space (p
);
8481 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8483 gdb_printf (_("Probed static tracepoint marker \"%s\"\n"),
8484 t
->static_trace_marker_id
.c_str ());
8486 else if (target_static_tracepoint_marker_at (sals
[0].pc
, &marker
))
8488 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8490 gdb_printf (_("Probed static tracepoint marker \"%s\"\n"),
8491 t
->static_trace_marker_id
.c_str ());
8494 warning (_("Couldn't determine the static tracepoint marker to probe"));
8497 for (const auto &sal
: sals
)
8501 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8502 if (loc_gdbarch
== nullptr)
8503 loc_gdbarch
= gdbarch
;
8505 describe_other_breakpoints (loc_gdbarch
,
8506 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8509 bp_location
*new_loc
= add_location (sal
);
8510 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8511 new_loc
->inserted
= 1;
8513 /* Do not set breakpoint locations conditions yet. As locations
8514 are inserted, they get sorted based on their addresses. Let
8515 the list stabilize to have reliable location numbers. */
8517 /* Dynamic printf requires and uses additional arguments on the
8518 command line, otherwise it's an error. */
8519 if (type
== bp_dprintf
)
8521 if (extra_string
!= nullptr)
8522 update_dprintf_command_list (this);
8524 error (_("Format string required"));
8526 else if (extra_string
!= nullptr)
8527 error (_("Garbage '%s' at end of command"), extra_string
.get ());
8530 /* The order of the locations is now stable. Set the location
8531 condition using the location's number. */
8533 for (bp_location
*bl
: locations ())
8535 if (cond_string
!= nullptr)
8536 set_breakpoint_location_condition (cond_string
.get (), bl
,
8542 display_canonical
= display_canonical_
;
8543 if (locspec_
!= nullptr)
8544 locspec
= std::move (locspec_
);
8546 locspec
= new_address_location_spec (this->loc
->address
, NULL
, 0);
8547 filter
= std::move (filter_
);
8551 create_breakpoint_sal (struct gdbarch
*gdbarch
,
8552 gdb::array_view
<const symtab_and_line
> sals
,
8553 location_spec_up
&&locspec
,
8554 gdb::unique_xmalloc_ptr
<char> filter
,
8555 gdb::unique_xmalloc_ptr
<char> cond_string
,
8556 gdb::unique_xmalloc_ptr
<char> extra_string
,
8557 enum bptype type
, enum bpdisp disposition
,
8558 int thread
, int task
, int ignore_count
,
8560 int enabled
, int internal
, unsigned flags
,
8561 int display_canonical
)
8563 std::unique_ptr
<code_breakpoint
> b
8564 = new_breakpoint_from_type (gdbarch
,
8567 std::move (locspec
),
8569 std::move (cond_string
),
8570 std::move (extra_string
),
8572 thread
, task
, ignore_count
,
8577 install_breakpoint (internal
, std::move (b
), 0);
8580 /* Add SALS.nelts breakpoints to the breakpoint table. For each
8581 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
8582 value. COND_STRING, if not NULL, specified the condition to be
8583 used for all breakpoints. Essentially the only case where
8584 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
8585 function. In that case, it's still not possible to specify
8586 separate conditions for different overloaded functions, so
8587 we take just a single condition string.
8589 NOTE: If the function succeeds, the caller is expected to cleanup
8590 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
8591 array contents). If the function fails (error() is called), the
8592 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
8593 COND and SALS arrays and each of those arrays contents. */
8596 create_breakpoints_sal (struct gdbarch
*gdbarch
,
8597 struct linespec_result
*canonical
,
8598 gdb::unique_xmalloc_ptr
<char> cond_string
,
8599 gdb::unique_xmalloc_ptr
<char> extra_string
,
8600 enum bptype type
, enum bpdisp disposition
,
8601 int thread
, int task
, int ignore_count
,
8603 int enabled
, int internal
, unsigned flags
)
8605 if (canonical
->pre_expanded
)
8606 gdb_assert (canonical
->lsals
.size () == 1);
8608 for (const auto &lsal
: canonical
->lsals
)
8610 /* Note that 'location' can be NULL in the case of a plain
8611 'break', without arguments. */
8612 location_spec_up locspec
8613 = (canonical
->locspec
!= nullptr
8614 ? canonical
->locspec
->clone ()
8616 gdb::unique_xmalloc_ptr
<char> filter_string
8617 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
8619 create_breakpoint_sal (gdbarch
, lsal
.sals
,
8620 std::move (locspec
),
8621 std::move (filter_string
),
8622 std::move (cond_string
),
8623 std::move (extra_string
),
8625 thread
, task
, ignore_count
,
8626 from_tty
, enabled
, internal
, flags
,
8627 canonical
->special_display
);
8631 /* Parse LOCSPEC which is assumed to be a SAL specification possibly
8632 followed by conditionals. On return, SALS contains an array of SAL
8633 addresses found. LOCSPEC points to the end of the SAL (for
8636 The array and the line spec strings are allocated on the heap, it is
8637 the caller's responsibility to free them. */
8640 parse_breakpoint_sals (location_spec
*locspec
,
8641 struct linespec_result
*canonical
)
8643 struct symtab_and_line cursal
;
8645 if (locspec
->type () == LINESPEC_LOCATION_SPEC
)
8647 const char *spec
= as_linespec_location_spec (locspec
)->spec_string
;
8651 /* The last displayed codepoint, if it's valid, is our default
8652 breakpoint address. */
8653 if (last_displayed_sal_is_valid ())
8655 /* Set sal's pspace, pc, symtab, and line to the values
8656 corresponding to the last call to print_frame_info.
8657 Be sure to reinitialize LINE with NOTCURRENT == 0
8658 as the breakpoint line number is inappropriate otherwise.
8659 find_pc_line would adjust PC, re-set it back. */
8660 symtab_and_line sal
= get_last_displayed_sal ();
8661 CORE_ADDR pc
= sal
.pc
;
8663 sal
= find_pc_line (pc
, 0);
8665 /* "break" without arguments is equivalent to "break *PC"
8666 where PC is the last displayed codepoint's address. So
8667 make sure to set sal.explicit_pc to prevent GDB from
8668 trying to expand the list of sals to include all other
8669 instances with the same symtab and line. */
8671 sal
.explicit_pc
= 1;
8673 struct linespec_sals lsal
;
8675 lsal
.canonical
= NULL
;
8677 canonical
->lsals
.push_back (std::move (lsal
));
8681 error (_("No default breakpoint address now."));
8685 /* Force almost all breakpoints to be in terms of the
8686 current_source_symtab (which is decode_line_1's default).
8687 This should produce the results we want almost all of the
8688 time while leaving default_breakpoint_* alone.
8690 ObjC: However, don't match an Objective-C method name which
8691 may have a '+' or '-' succeeded by a '['. */
8692 cursal
= get_current_source_symtab_and_line ();
8693 if (last_displayed_sal_is_valid ())
8695 const char *spec
= NULL
;
8697 if (locspec
->type () == LINESPEC_LOCATION_SPEC
)
8698 spec
= as_linespec_location_spec (locspec
)->spec_string
;
8702 && strchr ("+-", spec
[0]) != NULL
8705 decode_line_full (locspec
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
8706 get_last_displayed_symtab (),
8707 get_last_displayed_line (),
8708 canonical
, NULL
, NULL
);
8713 decode_line_full (locspec
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
8714 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
8718 /* Convert each SAL into a real PC. Verify that the PC can be
8719 inserted as a breakpoint. If it can't throw an error. */
8722 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
8724 for (auto &sal
: sals
)
8725 resolve_sal_pc (&sal
);
8728 /* Fast tracepoints may have restrictions on valid locations. For
8729 instance, a fast tracepoint using a jump instead of a trap will
8730 likely have to overwrite more bytes than a trap would, and so can
8731 only be placed where the instruction is longer than the jump, or a
8732 multi-instruction sequence does not have a jump into the middle of
8736 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
8737 gdb::array_view
<const symtab_and_line
> sals
)
8739 for (const auto &sal
: sals
)
8741 struct gdbarch
*sarch
;
8743 sarch
= get_sal_arch (sal
);
8744 /* We fall back to GDBARCH if there is no architecture
8745 associated with SAL. */
8749 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
8750 error (_("May not have a fast tracepoint at %s%s"),
8751 paddress (sarch
, sal
.pc
), msg
.c_str ());
8755 /* Given TOK, a string specification of condition and thread, as
8756 accepted by the 'break' command, extract the condition
8757 string and thread number and set *COND_STRING and *THREAD.
8758 PC identifies the context at which the condition should be parsed.
8759 If no condition is found, *COND_STRING is set to NULL.
8760 If no thread is found, *THREAD is set to -1. */
8763 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
8764 gdb::unique_xmalloc_ptr
<char> *cond_string
,
8765 int *thread
, int *task
,
8766 gdb::unique_xmalloc_ptr
<char> *rest
)
8768 cond_string
->reset ();
8776 const char *end_tok
;
8778 const char *cond_start
= NULL
;
8779 const char *cond_end
= NULL
;
8781 tok
= skip_spaces (tok
);
8783 if ((*tok
== '"' || *tok
== ',') && rest
)
8785 rest
->reset (savestring (tok
, strlen (tok
)));
8789 end_tok
= skip_to_space (tok
);
8791 toklen
= end_tok
- tok
;
8793 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
8795 tok
= cond_start
= end_tok
+ 1;
8798 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
8800 catch (const gdb_exception_error
&)
8805 tok
= tok
+ strlen (tok
);
8808 cond_string
->reset (savestring (cond_start
, cond_end
- cond_start
));
8810 else if (toklen
>= 1 && strncmp (tok
, "-force-condition", toklen
) == 0)
8815 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
8818 struct thread_info
*thr
;
8821 error(_("You can specify only one thread."));
8824 error (_("You can specify only one of thread or task."));
8827 thr
= parse_thread_id (tok
, &tmptok
);
8829 error (_("Junk after thread keyword."));
8830 *thread
= thr
->global_num
;
8833 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
8838 error(_("You can specify only one task."));
8841 error (_("You can specify only one of thread or task."));
8844 *task
= strtol (tok
, &tmptok
, 0);
8846 error (_("Junk after task keyword."));
8847 if (!valid_task_id (*task
))
8848 error (_("Unknown task %d."), *task
);
8853 rest
->reset (savestring (tok
, strlen (tok
)));
8857 error (_("Junk at end of arguments."));
8861 /* Call 'find_condition_and_thread' for each sal in SALS until a parse
8862 succeeds. The parsed values are written to COND_STRING, THREAD,
8863 TASK, and REST. See the comment of 'find_condition_and_thread'
8864 for the description of these parameters and INPUT. */
8867 find_condition_and_thread_for_sals (const std::vector
<symtab_and_line
> &sals
,
8869 gdb::unique_xmalloc_ptr
<char> *cond_string
,
8870 int *thread
, int *task
,
8871 gdb::unique_xmalloc_ptr
<char> *rest
)
8873 int num_failures
= 0;
8874 for (auto &sal
: sals
)
8876 gdb::unique_xmalloc_ptr
<char> cond
;
8879 gdb::unique_xmalloc_ptr
<char> remaining
;
8881 /* Here we want to parse 'arg' to separate condition from thread
8882 number. But because parsing happens in a context and the
8883 contexts of sals might be different, try each until there is
8884 success. Finding one successful parse is sufficient for our
8885 goal. When setting the breakpoint we'll re-parse the
8886 condition in the context of each sal. */
8889 find_condition_and_thread (input
, sal
.pc
, &cond
, &thread_id
,
8890 &task_id
, &remaining
);
8891 *cond_string
= std::move (cond
);
8892 /* At most one of thread or task can be set. */
8893 gdb_assert (thread_id
== -1 || task_id
== -1);
8894 *thread
= thread_id
;
8896 *rest
= std::move (remaining
);
8899 catch (const gdb_exception_error
&e
)
8902 /* If no sal remains, do not continue. */
8903 if (num_failures
== sals
.size ())
8909 /* Decode a static tracepoint marker spec. */
8911 static std::vector
<symtab_and_line
>
8912 decode_static_tracepoint_spec (const char **arg_p
)
8914 const char *p
= &(*arg_p
)[3];
8917 p
= skip_spaces (p
);
8919 endp
= skip_to_space (p
);
8921 std::string
marker_str (p
, endp
- p
);
8923 std::vector
<static_tracepoint_marker
> markers
8924 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
8925 if (markers
.empty ())
8926 error (_("No known static tracepoint marker named %s"),
8927 marker_str
.c_str ());
8929 std::vector
<symtab_and_line
> sals
;
8930 sals
.reserve (markers
.size ());
8932 for (const static_tracepoint_marker
&marker
: markers
)
8934 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
8935 sal
.pc
= marker
.address
;
8936 sals
.push_back (sal
);
8943 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
8944 according to IS_TRACEPOINT. */
8946 static const struct breakpoint_ops
*
8947 breakpoint_ops_for_location_spec_type (enum location_spec_type locspec_type
,
8952 if (locspec_type
== PROBE_LOCATION_SPEC
)
8953 return &tracepoint_probe_breakpoint_ops
;
8955 return &code_breakpoint_ops
;
8959 if (locspec_type
== PROBE_LOCATION_SPEC
)
8960 return &bkpt_probe_breakpoint_ops
;
8962 return &code_breakpoint_ops
;
8966 /* See breakpoint.h. */
8968 const struct breakpoint_ops
*
8969 breakpoint_ops_for_location_spec (const location_spec
*locspec
,
8972 if (locspec
!= nullptr)
8973 return (breakpoint_ops_for_location_spec_type
8974 (locspec
->type (), is_tracepoint
));
8975 return &code_breakpoint_ops
;
8978 /* See breakpoint.h. */
8981 create_breakpoint (struct gdbarch
*gdbarch
,
8982 location_spec
*locspec
,
8983 const char *cond_string
,
8984 int thread
, const char *extra_string
,
8985 bool force_condition
, int parse_extra
,
8986 int tempflag
, enum bptype type_wanted
,
8988 enum auto_boolean pending_break_support
,
8989 const struct breakpoint_ops
*ops
,
8990 int from_tty
, int enabled
, int internal
,
8993 struct linespec_result canonical
;
8994 bool pending
= false;
8996 int prev_bkpt_count
= breakpoint_count
;
8998 gdb_assert (ops
!= NULL
);
9000 /* If extra_string isn't useful, set it to NULL. */
9001 if (extra_string
!= NULL
&& *extra_string
== '\0')
9002 extra_string
= NULL
;
9006 ops
->create_sals_from_location_spec (locspec
, &canonical
);
9008 catch (const gdb_exception_error
&e
)
9010 /* If caller is interested in rc value from parse, set
9012 if (e
.error
== NOT_FOUND_ERROR
)
9014 /* If pending breakpoint support is turned off, throw
9017 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9020 exception_print (gdb_stderr
, e
);
9022 /* If pending breakpoint support is auto query and the user
9023 selects no, then simply return the error code. */
9024 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9025 && !nquery (_("Make %s pending on future shared library load? "),
9026 bptype_string (type_wanted
)))
9029 /* At this point, either the user was queried about setting
9030 a pending breakpoint and selected yes, or pending
9031 breakpoint behavior is on and thus a pending breakpoint
9032 is defaulted on behalf of the user. */
9039 if (!pending
&& canonical
.lsals
.empty ())
9042 /* Resolve all line numbers to PC's and verify that the addresses
9043 are ok for the target. */
9046 for (auto &lsal
: canonical
.lsals
)
9047 breakpoint_sals_to_pc (lsal
.sals
);
9050 /* Fast tracepoints may have additional restrictions on location. */
9051 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9053 for (const auto &lsal
: canonical
.lsals
)
9054 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9057 /* Verify that condition can be parsed, before setting any
9058 breakpoints. Allocate a separate condition expression for each
9062 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9063 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9067 gdb::unique_xmalloc_ptr
<char> rest
;
9068 gdb::unique_xmalloc_ptr
<char> cond
;
9070 const linespec_sals
&lsal
= canonical
.lsals
[0];
9072 find_condition_and_thread_for_sals (lsal
.sals
, extra_string
,
9073 &cond
, &thread
, &task
, &rest
);
9074 cond_string_copy
= std::move (cond
);
9075 extra_string_copy
= std::move (rest
);
9079 if (type_wanted
!= bp_dprintf
9080 && extra_string
!= NULL
&& *extra_string
!= '\0')
9081 error (_("Garbage '%s' at end of location"), extra_string
);
9083 /* Check the validity of the condition. We should error out
9084 if the condition is invalid at all of the locations and
9085 if it is not forced. In the PARSE_EXTRA case above, this
9086 check is done when parsing the EXTRA_STRING. */
9087 if (cond_string
!= nullptr && !force_condition
)
9089 int num_failures
= 0;
9090 const linespec_sals
&lsal
= canonical
.lsals
[0];
9091 for (const auto &sal
: lsal
.sals
)
9093 const char *cond
= cond_string
;
9096 parse_exp_1 (&cond
, sal
.pc
, block_for_pc (sal
.pc
), 0);
9097 /* One success is sufficient to keep going. */
9100 catch (const gdb_exception_error
&)
9103 /* If this is the last sal, error out. */
9104 if (num_failures
== lsal
.sals
.size ())
9110 /* Create a private copy of condition string. */
9112 cond_string_copy
.reset (xstrdup (cond_string
));
9113 /* Create a private copy of any extra string. */
9115 extra_string_copy
.reset (xstrdup (extra_string
));
9118 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9119 std::move (cond_string_copy
),
9120 std::move (extra_string_copy
),
9122 tempflag
? disp_del
: disp_donttouch
,
9123 thread
, task
, ignore_count
,
9124 from_tty
, enabled
, internal
, flags
);
9128 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (gdbarch
,
9130 b
->locspec
= locspec
->clone ();
9133 b
->cond_string
= NULL
;
9136 /* Create a private copy of condition string. */
9137 b
->cond_string
.reset (cond_string
!= NULL
9138 ? xstrdup (cond_string
)
9143 /* Create a private copy of any extra string. */
9144 b
->extra_string
.reset (extra_string
!= NULL
9145 ? xstrdup (extra_string
)
9147 b
->ignore_count
= ignore_count
;
9148 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9149 b
->condition_not_parsed
= 1;
9150 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9151 if ((type_wanted
!= bp_breakpoint
9152 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9153 b
->pspace
= current_program_space
;
9155 install_breakpoint (internal
, std::move (b
), 0);
9158 if (canonical
.lsals
.size () > 1)
9160 warning (_("Multiple breakpoints were set.\nUse the "
9161 "\"delete\" command to delete unwanted breakpoints."));
9162 prev_breakpoint_count
= prev_bkpt_count
;
9165 update_global_location_list (UGLL_MAY_INSERT
);
9170 /* Set a breakpoint.
9171 ARG is a string describing breakpoint address,
9172 condition, and thread.
9173 FLAG specifies if a breakpoint is hardware on,
9174 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9178 break_command_1 (const char *arg
, int flag
, int from_tty
)
9180 int tempflag
= flag
& BP_TEMPFLAG
;
9181 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9182 ? bp_hardware_breakpoint
9185 location_spec_up locspec
= string_to_location_spec (&arg
, current_language
);
9186 const struct breakpoint_ops
*ops
9187 = breakpoint_ops_for_location_spec (locspec
.get (),
9188 false /* is_tracepoint */);
9190 create_breakpoint (get_current_arch (),
9192 NULL
, 0, arg
, false, 1 /* parse arg */,
9193 tempflag
, type_wanted
,
9194 0 /* Ignore count */,
9195 pending_break_support
,
9203 /* Helper function for break_command_1 and disassemble_command. */
9206 resolve_sal_pc (struct symtab_and_line
*sal
)
9210 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9212 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9213 error (_("No line %d in file \"%s\"."),
9214 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9217 /* If this SAL corresponds to a breakpoint inserted using a line
9218 number, then skip the function prologue if necessary. */
9219 if (sal
->explicit_line
)
9220 skip_prologue_sal (sal
);
9223 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9225 const struct blockvector
*bv
;
9226 const struct block
*b
;
9229 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9230 sal
->symtab
->compunit ());
9233 sym
= block_linkage_function (b
);
9236 = sym
->obj_section (sal
->symtab
->compunit ()->objfile ());
9239 /* It really is worthwhile to have the section, so we'll
9240 just have to look harder. This case can be executed
9241 if we have line numbers but no functions (as can
9242 happen in assembly source). */
9244 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9245 switch_to_program_space_and_thread (sal
->pspace
);
9247 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9249 sal
->section
= msym
.obj_section ();
9256 break_command (const char *arg
, int from_tty
)
9258 break_command_1 (arg
, 0, from_tty
);
9262 tbreak_command (const char *arg
, int from_tty
)
9264 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9268 hbreak_command (const char *arg
, int from_tty
)
9270 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9274 thbreak_command (const char *arg
, int from_tty
)
9276 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9279 /* The dynamic printf command is mostly like a regular breakpoint, but
9280 with a prewired command list consisting of a single output command,
9281 built from extra arguments supplied on the dprintf command
9285 dprintf_command (const char *arg
, int from_tty
)
9287 location_spec_up locspec
= string_to_location_spec (&arg
, current_language
);
9289 /* If non-NULL, ARG should have been advanced past the location;
9290 the next character must be ','. */
9293 if (arg
[0] != ',' || arg
[1] == '\0')
9294 error (_("Format string required"));
9297 /* Skip the comma. */
9302 create_breakpoint (get_current_arch (),
9304 NULL
, 0, arg
, false, 1 /* parse arg */,
9306 0 /* Ignore count */,
9307 pending_break_support
,
9308 &code_breakpoint_ops
,
9316 agent_printf_command (const char *arg
, int from_tty
)
9318 error (_("May only run agent-printf on the target"));
9321 /* Implement the "breakpoint_hit" method for ranged breakpoints. */
9324 ranged_breakpoint::breakpoint_hit (const struct bp_location
*bl
,
9325 const address_space
*aspace
,
9327 const target_waitstatus
&ws
)
9329 if (ws
.kind () != TARGET_WAITKIND_STOPPED
9330 || ws
.sig () != GDB_SIGNAL_TRAP
)
9333 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9334 bl
->length
, aspace
, bp_addr
);
9337 /* Implement the "resources_needed" method for ranged breakpoints. */
9340 ranged_breakpoint::resources_needed (const struct bp_location
*bl
)
9342 return target_ranged_break_num_registers ();
9345 /* Implement the "print_it" method for ranged breakpoints. */
9347 enum print_stop_action
9348 ranged_breakpoint::print_it (const bpstat
*bs
) const
9350 struct bp_location
*bl
= loc
;
9351 struct ui_out
*uiout
= current_uiout
;
9353 gdb_assert (type
== bp_hardware_breakpoint
);
9355 /* Ranged breakpoints have only one location. */
9356 gdb_assert (bl
&& bl
->next
== NULL
);
9358 annotate_breakpoint (number
);
9360 maybe_print_thread_hit_breakpoint (uiout
);
9362 if (disposition
== disp_del
)
9363 uiout
->text ("Temporary ranged breakpoint ");
9365 uiout
->text ("Ranged breakpoint ");
9366 if (uiout
->is_mi_like_p ())
9368 uiout
->field_string ("reason",
9369 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9370 uiout
->field_string ("disp", bpdisp_text (disposition
));
9372 print_num_locno (bs
, uiout
);
9375 return PRINT_SRC_AND_LOC
;
9378 /* Implement the "print_one" method for ranged breakpoints. */
9381 ranged_breakpoint::print_one (bp_location
**last_loc
) const
9383 struct bp_location
*bl
= loc
;
9384 struct value_print_options opts
;
9385 struct ui_out
*uiout
= current_uiout
;
9387 /* Ranged breakpoints have only one location. */
9388 gdb_assert (bl
&& bl
->next
== NULL
);
9390 get_user_print_options (&opts
);
9392 if (opts
.addressprint
)
9393 /* We don't print the address range here, it will be printed later
9394 by ranged_breakpoint::print_one_detail. */
9395 uiout
->field_skip ("addr");
9397 print_breakpoint_location (this, bl
);
9403 /* Implement the "print_one_detail" method for ranged breakpoints. */
9406 ranged_breakpoint::print_one_detail (struct ui_out
*uiout
) const
9408 CORE_ADDR address_start
, address_end
;
9409 struct bp_location
*bl
= loc
;
9414 address_start
= bl
->address
;
9415 address_end
= address_start
+ bl
->length
- 1;
9417 uiout
->text ("\taddress range: ");
9418 stb
.printf ("[%s, %s]",
9419 print_core_address (bl
->gdbarch
, address_start
),
9420 print_core_address (bl
->gdbarch
, address_end
));
9421 uiout
->field_stream ("addr", stb
);
9425 /* Implement the "print_mention" method for ranged breakpoints. */
9428 ranged_breakpoint::print_mention () const
9430 struct bp_location
*bl
= loc
;
9431 struct ui_out
*uiout
= current_uiout
;
9434 gdb_assert (type
== bp_hardware_breakpoint
);
9436 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9437 number
, paddress (bl
->gdbarch
, bl
->address
),
9438 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9441 /* Implement the "print_recreate" method for ranged breakpoints. */
9444 ranged_breakpoint::print_recreate (struct ui_file
*fp
) const
9446 gdb_printf (fp
, "break-range %s, %s",
9447 locspec
->to_string (),
9448 locspec_range_end
->to_string ());
9449 print_recreate_thread (fp
);
9452 /* Find the address where the end of the breakpoint range should be
9453 placed, given the SAL of the end of the range. This is so that if
9454 the user provides a line number, the end of the range is set to the
9455 last instruction of the given line. */
9458 find_breakpoint_range_end (struct symtab_and_line sal
)
9462 /* If the user provided a PC value, use it. Otherwise,
9463 find the address of the end of the given location. */
9464 if (sal
.explicit_pc
)
9471 ret
= find_line_pc_range (sal
, &start
, &end
);
9473 error (_("Could not find location of the end of the range."));
9475 /* find_line_pc_range returns the start of the next line. */
9482 /* Implement the "break-range" CLI command. */
9485 break_range_command (const char *arg
, int from_tty
)
9487 const char *arg_start
;
9488 struct linespec_result canonical_start
, canonical_end
;
9489 int bp_count
, can_use_bp
, length
;
9492 /* We don't support software ranged breakpoints. */
9493 if (target_ranged_break_num_registers () < 0)
9494 error (_("This target does not support hardware ranged breakpoints."));
9496 bp_count
= hw_breakpoint_used_count ();
9497 bp_count
+= target_ranged_break_num_registers ();
9498 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9501 error (_("Hardware breakpoints used exceeds limit."));
9503 arg
= skip_spaces (arg
);
9504 if (arg
== NULL
|| arg
[0] == '\0')
9505 error(_("No address range specified."));
9508 location_spec_up start_locspec
9509 = string_to_location_spec (&arg
, current_language
);
9510 parse_breakpoint_sals (start_locspec
.get (), &canonical_start
);
9513 error (_("Too few arguments."));
9514 else if (canonical_start
.lsals
.empty ())
9515 error (_("Could not find location of the beginning of the range."));
9517 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
9519 if (canonical_start
.lsals
.size () > 1
9520 || lsal_start
.sals
.size () != 1)
9521 error (_("Cannot create a ranged breakpoint with multiple locations."));
9523 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
9524 std::string
addr_string_start (arg_start
, arg
- arg_start
);
9526 arg
++; /* Skip the comma. */
9527 arg
= skip_spaces (arg
);
9529 /* Parse the end location specification. */
9533 /* We call decode_line_full directly here instead of using
9534 parse_breakpoint_sals because we need to specify the start
9535 location spec's symtab and line as the default symtab and line
9536 for the end of the range. This makes it possible to have ranges
9537 like "foo.c:27, +14", where +14 means 14 lines from the start
9539 location_spec_up end_locspec
9540 = string_to_location_spec (&arg
, current_language
);
9541 decode_line_full (end_locspec
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
9542 sal_start
.symtab
, sal_start
.line
,
9543 &canonical_end
, NULL
, NULL
);
9545 if (canonical_end
.lsals
.empty ())
9546 error (_("Could not find location of the end of the range."));
9548 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
9549 if (canonical_end
.lsals
.size () > 1
9550 || lsal_end
.sals
.size () != 1)
9551 error (_("Cannot create a ranged breakpoint with multiple locations."));
9553 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
9555 end
= find_breakpoint_range_end (sal_end
);
9556 if (sal_start
.pc
> end
)
9557 error (_("Invalid address range, end precedes start."));
9559 length
= end
- sal_start
.pc
+ 1;
9561 /* Length overflowed. */
9562 error (_("Address range too large."));
9563 else if (length
== 1)
9565 /* This range is simple enough to be handled by
9566 the `hbreak' command. */
9567 hbreak_command (&addr_string_start
[0], 1);
9572 /* Now set up the breakpoint and install it. */
9574 std::unique_ptr
<breakpoint
> br
9575 (new ranged_breakpoint (get_current_arch (),
9577 std::move (start_locspec
),
9578 std::move (end_locspec
)));
9580 install_breakpoint (false, std::move (br
), true);
9583 /* Return non-zero if EXP is verified as constant. Returned zero
9584 means EXP is variable. Also the constant detection may fail for
9585 some constant expressions and in such case still falsely return
9589 watchpoint_exp_is_const (const struct expression
*exp
)
9591 return exp
->op
->constant_p ();
9594 /* Implement the "re_set" method for watchpoints. */
9597 watchpoint::re_set ()
9599 /* Watchpoint can be either on expression using entirely global
9600 variables, or it can be on local variables.
9602 Watchpoints of the first kind are never auto-deleted, and even
9603 persist across program restarts. Since they can use variables
9604 from shared libraries, we need to reparse expression as libraries
9605 are loaded and unloaded.
9607 Watchpoints on local variables can also change meaning as result
9608 of solib event. For example, if a watchpoint uses both a local
9609 and a global variables in expression, it's a local watchpoint,
9610 but unloading of a shared library will make the expression
9611 invalid. This is not a very common use case, but we still
9612 re-evaluate expression, to avoid surprises to the user.
9614 Note that for local watchpoints, we re-evaluate it only if
9615 watchpoints frame id is still valid. If it's not, it means the
9616 watchpoint is out of scope and will be deleted soon. In fact,
9617 I'm not sure we'll ever be called in this case.
9619 If a local watchpoint's frame id is still valid, then
9620 exp_valid_block is likewise valid, and we can safely use it.
9622 Don't do anything about disabled watchpoints, since they will be
9623 reevaluated again when enabled. */
9624 update_watchpoint (this, true /* reparse */);
9627 /* Implement the "insert" method for hardware watchpoints. */
9630 watchpoint::insert_location (struct bp_location
*bl
)
9632 int length
= exact
? 1 : bl
->length
;
9634 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
9638 /* Implement the "remove" method for hardware watchpoints. */
9641 watchpoint::remove_location (struct bp_location
*bl
,
9642 enum remove_bp_reason reason
)
9644 int length
= exact
? 1 : bl
->length
;
9646 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
9651 watchpoint::breakpoint_hit (const struct bp_location
*bl
,
9652 const address_space
*aspace
, CORE_ADDR bp_addr
,
9653 const target_waitstatus
&ws
)
9655 struct breakpoint
*b
= bl
->owner
;
9657 /* Continuable hardware watchpoints are treated as non-existent if the
9658 reason we stopped wasn't a hardware watchpoint (we didn't stop on
9659 some data address). Otherwise gdb won't stop on a break instruction
9660 in the code (not from a breakpoint) when a hardware watchpoint has
9661 been defined. Also skip watchpoints which we know did not trigger
9662 (did not match the data address). */
9663 if (is_hardware_watchpoint (b
)
9664 && watchpoint_triggered
== watch_triggered_no
)
9671 watchpoint::check_status (bpstat
*bs
)
9673 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
9675 bpstat_check_watchpoint (bs
);
9678 /* Implement the "resources_needed" method for hardware
9682 watchpoint::resources_needed (const struct bp_location
*bl
)
9684 int length
= exact
? 1 : bl
->length
;
9686 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
9689 /* Implement the "works_in_software_mode" method for hardware
9693 watchpoint::works_in_software_mode () const
9695 /* Read and access watchpoints only work with hardware support. */
9696 return type
== bp_watchpoint
|| type
== bp_hardware_watchpoint
;
9699 enum print_stop_action
9700 watchpoint::print_it (const bpstat
*bs
) const
9702 struct breakpoint
*b
;
9703 enum print_stop_action result
;
9704 struct ui_out
*uiout
= current_uiout
;
9706 gdb_assert (bs
->bp_location_at
!= NULL
);
9708 b
= bs
->breakpoint_at
;
9710 annotate_watchpoint (b
->number
);
9711 maybe_print_thread_hit_breakpoint (uiout
);
9715 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
9719 case bp_hardware_watchpoint
:
9720 if (uiout
->is_mi_like_p ())
9722 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
9724 tuple_emitter
.emplace (uiout
, "value");
9725 uiout
->text ("\nOld value = ");
9726 watchpoint_value_print (bs
->old_val
.get (), &stb
);
9727 uiout
->field_stream ("old", stb
);
9728 uiout
->text ("\nNew value = ");
9729 watchpoint_value_print (val
.get (), &stb
);
9730 uiout
->field_stream ("new", stb
);
9732 /* More than one watchpoint may have been triggered. */
9733 result
= PRINT_UNKNOWN
;
9736 case bp_read_watchpoint
:
9737 if (uiout
->is_mi_like_p ())
9739 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
9741 tuple_emitter
.emplace (uiout
, "value");
9742 uiout
->text ("\nValue = ");
9743 watchpoint_value_print (val
.get (), &stb
);
9744 uiout
->field_stream ("value", stb
);
9746 result
= PRINT_UNKNOWN
;
9749 case bp_access_watchpoint
:
9750 if (bs
->old_val
!= NULL
)
9752 if (uiout
->is_mi_like_p ())
9755 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9757 tuple_emitter
.emplace (uiout
, "value");
9758 uiout
->text ("\nOld value = ");
9759 watchpoint_value_print (bs
->old_val
.get (), &stb
);
9760 uiout
->field_stream ("old", stb
);
9761 uiout
->text ("\nNew value = ");
9766 if (uiout
->is_mi_like_p ())
9769 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9770 tuple_emitter
.emplace (uiout
, "value");
9771 uiout
->text ("\nValue = ");
9773 watchpoint_value_print (val
.get (), &stb
);
9774 uiout
->field_stream ("new", stb
);
9776 result
= PRINT_UNKNOWN
;
9779 result
= PRINT_UNKNOWN
;
9785 /* Implement the "print_mention" method for hardware watchpoints. */
9788 watchpoint::print_mention () const
9790 struct ui_out
*uiout
= current_uiout
;
9791 const char *tuple_name
;
9796 uiout
->text ("Watchpoint ");
9799 case bp_hardware_watchpoint
:
9800 uiout
->text ("Hardware watchpoint ");
9803 case bp_read_watchpoint
:
9804 uiout
->text ("Hardware read watchpoint ");
9805 tuple_name
= "hw-rwpt";
9807 case bp_access_watchpoint
:
9808 uiout
->text ("Hardware access (read/write) watchpoint ");
9809 tuple_name
= "hw-awpt";
9812 internal_error (_("Invalid hardware watchpoint type."));
9815 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
9816 uiout
->field_signed ("number", number
);
9818 uiout
->field_string ("exp", exp_string
.get ());
9821 /* Implement the "print_recreate" method for watchpoints. */
9824 watchpoint::print_recreate (struct ui_file
*fp
) const
9829 case bp_hardware_watchpoint
:
9830 gdb_printf (fp
, "watch");
9832 case bp_read_watchpoint
:
9833 gdb_printf (fp
, "rwatch");
9835 case bp_access_watchpoint
:
9836 gdb_printf (fp
, "awatch");
9839 internal_error (_("Invalid watchpoint type."));
9842 gdb_printf (fp
, " %s", exp_string
.get ());
9843 print_recreate_thread (fp
);
9846 /* Implement the "explains_signal" method for watchpoints. */
9849 watchpoint::explains_signal (enum gdb_signal sig
)
9851 /* A software watchpoint cannot cause a signal other than
9853 if (type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
9859 struct masked_watchpoint
: public watchpoint
9861 using watchpoint::watchpoint
;
9863 int insert_location (struct bp_location
*) override
;
9864 int remove_location (struct bp_location
*,
9865 enum remove_bp_reason reason
) override
;
9866 int resources_needed (const struct bp_location
*) override
;
9867 bool works_in_software_mode () const override
;
9868 enum print_stop_action
print_it (const bpstat
*bs
) const override
;
9869 void print_one_detail (struct ui_out
*) const override
;
9870 void print_mention () const override
;
9871 void print_recreate (struct ui_file
*fp
) const override
;
9874 /* Implement the "insert" method for masked hardware watchpoints. */
9877 masked_watchpoint::insert_location (struct bp_location
*bl
)
9879 return target_insert_mask_watchpoint (bl
->address
, hw_wp_mask
,
9880 bl
->watchpoint_type
);
9883 /* Implement the "remove" method for masked hardware watchpoints. */
9886 masked_watchpoint::remove_location (struct bp_location
*bl
,
9887 enum remove_bp_reason reason
)
9889 return target_remove_mask_watchpoint (bl
->address
, hw_wp_mask
,
9890 bl
->watchpoint_type
);
9893 /* Implement the "resources_needed" method for masked hardware
9897 masked_watchpoint::resources_needed (const struct bp_location
*bl
)
9899 return target_masked_watch_num_registers (bl
->address
, hw_wp_mask
);
9902 /* Implement the "works_in_software_mode" method for masked hardware
9906 masked_watchpoint::works_in_software_mode () const
9911 /* Implement the "print_it" method for masked hardware
9914 enum print_stop_action
9915 masked_watchpoint::print_it (const bpstat
*bs
) const
9917 struct breakpoint
*b
= bs
->breakpoint_at
;
9918 struct ui_out
*uiout
= current_uiout
;
9920 /* Masked watchpoints have only one location. */
9921 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
9923 annotate_watchpoint (b
->number
);
9924 maybe_print_thread_hit_breakpoint (uiout
);
9928 case bp_hardware_watchpoint
:
9929 if (uiout
->is_mi_like_p ())
9931 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
9934 case bp_read_watchpoint
:
9935 if (uiout
->is_mi_like_p ())
9937 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
9940 case bp_access_watchpoint
:
9941 if (uiout
->is_mi_like_p ())
9944 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
9947 internal_error (_("Invalid hardware watchpoint type."));
9952 Check the underlying instruction at PC for the memory\n\
9953 address and value which triggered this watchpoint.\n"));
9956 /* More than one watchpoint may have been triggered. */
9957 return PRINT_UNKNOWN
;
9960 /* Implement the "print_one_detail" method for masked hardware
9964 masked_watchpoint::print_one_detail (struct ui_out
*uiout
) const
9966 /* Masked watchpoints have only one location. */
9967 gdb_assert (loc
&& loc
->next
== NULL
);
9969 uiout
->text ("\tmask ");
9970 uiout
->field_core_addr ("mask", loc
->gdbarch
, hw_wp_mask
);
9974 /* Implement the "print_mention" method for masked hardware
9978 masked_watchpoint::print_mention () const
9980 struct ui_out
*uiout
= current_uiout
;
9981 const char *tuple_name
;
9985 case bp_hardware_watchpoint
:
9986 uiout
->text ("Masked hardware watchpoint ");
9989 case bp_read_watchpoint
:
9990 uiout
->text ("Masked hardware read watchpoint ");
9991 tuple_name
= "hw-rwpt";
9993 case bp_access_watchpoint
:
9994 uiout
->text ("Masked hardware access (read/write) watchpoint ");
9995 tuple_name
= "hw-awpt";
9998 internal_error (_("Invalid hardware watchpoint type."));
10001 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10002 uiout
->field_signed ("number", number
);
10003 uiout
->text (": ");
10004 uiout
->field_string ("exp", exp_string
.get ());
10007 /* Implement the "print_recreate" method for masked hardware
10011 masked_watchpoint::print_recreate (struct ui_file
*fp
) const
10015 case bp_hardware_watchpoint
:
10016 gdb_printf (fp
, "watch");
10018 case bp_read_watchpoint
:
10019 gdb_printf (fp
, "rwatch");
10021 case bp_access_watchpoint
:
10022 gdb_printf (fp
, "awatch");
10025 internal_error (_("Invalid hardware watchpoint type."));
10028 gdb_printf (fp
, " %s mask 0x%s", exp_string
.get (),
10029 phex (hw_wp_mask
, sizeof (CORE_ADDR
)));
10030 print_recreate_thread (fp
);
10033 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10036 is_masked_watchpoint (const struct breakpoint
*b
)
10038 return dynamic_cast<const masked_watchpoint
*> (b
) != nullptr;
10041 /* accessflag: hw_write: watch write,
10042 hw_read: watch read,
10043 hw_access: watch access (read or write) */
10045 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10046 bool just_location
, bool internal
)
10048 struct breakpoint
*scope_breakpoint
= NULL
;
10049 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10050 struct value
*result
;
10051 int saved_bitpos
= 0, saved_bitsize
= 0;
10052 const char *exp_start
= NULL
;
10053 const char *exp_end
= NULL
;
10054 const char *tok
, *end_tok
;
10056 const char *cond_start
= NULL
;
10057 const char *cond_end
= NULL
;
10058 enum bptype bp_type
;
10060 /* Flag to indicate whether we are going to use masks for
10061 the hardware watchpoint. */
10062 bool use_mask
= false;
10063 CORE_ADDR mask
= 0;
10066 /* Make sure that we actually have parameters to parse. */
10067 if (arg
!= NULL
&& arg
[0] != '\0')
10069 const char *value_start
;
10071 exp_end
= arg
+ strlen (arg
);
10073 /* Look for "parameter value" pairs at the end
10074 of the arguments string. */
10075 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10077 /* Skip whitespace at the end of the argument list. */
10078 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10081 /* Find the beginning of the last token.
10082 This is the value of the parameter. */
10083 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10085 value_start
= tok
+ 1;
10087 /* Skip whitespace. */
10088 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10093 /* Find the beginning of the second to last token.
10094 This is the parameter itself. */
10095 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10098 toklen
= end_tok
- tok
+ 1;
10100 if (toklen
== 6 && startswith (tok
, "thread"))
10102 struct thread_info
*thr
;
10103 /* At this point we've found a "thread" token, which means
10104 the user is trying to set a watchpoint that triggers
10105 only in a specific thread. */
10109 error(_("You can specify only one thread."));
10112 error (_("You can specify only one of thread or task."));
10114 /* Extract the thread ID from the next token. */
10115 thr
= parse_thread_id (value_start
, &endp
);
10117 /* Check if the user provided a valid thread ID. */
10118 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10119 invalid_thread_id_error (value_start
);
10121 thread
= thr
->global_num
;
10123 else if (toklen
== 4 && startswith (tok
, "task"))
10128 error(_("You can specify only one task."));
10131 error (_("You can specify only one of thread or task."));
10133 task
= strtol (value_start
, &tmp
, 0);
10134 if (tmp
== value_start
)
10135 error (_("Junk after task keyword."));
10136 if (!valid_task_id (task
))
10137 error (_("Unknown task %d."), task
);
10139 else if (toklen
== 4 && startswith (tok
, "mask"))
10141 /* We've found a "mask" token, which means the user wants to
10142 create a hardware watchpoint that is going to have the mask
10144 struct value
*mask_value
;
10147 error(_("You can specify only one mask."));
10149 use_mask
= just_location
= true;
10151 scoped_value_mark mark
;
10152 mask_value
= parse_to_comma_and_eval (&value_start
);
10153 mask
= value_as_address (mask_value
);
10156 /* We didn't recognize what we found. We should stop here. */
10159 /* Truncate the string and get rid of the "parameter value" pair before
10160 the arguments string is parsed by the parse_exp_1 function. */
10167 /* Parse the rest of the arguments. From here on out, everything
10168 is in terms of a newly allocated string instead of the original
10170 std::string
expression (arg
, exp_end
- arg
);
10171 exp_start
= arg
= expression
.c_str ();
10172 innermost_block_tracker tracker
;
10173 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10175 /* Remove trailing whitespace from the expression before saving it.
10176 This makes the eventual display of the expression string a bit
10178 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10181 /* Checking if the expression is not constant. */
10182 if (watchpoint_exp_is_const (exp
.get ()))
10186 len
= exp_end
- exp_start
;
10187 while (len
> 0 && isspace (exp_start
[len
- 1]))
10189 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10192 exp_valid_block
= tracker
.block ();
10193 struct value
*mark
= value_mark ();
10194 struct value
*val_as_value
= nullptr;
10195 fetch_subexp_value (exp
.get (), exp
->op
.get (), &val_as_value
, &result
, NULL
,
10198 if (val_as_value
!= NULL
&& just_location
)
10200 saved_bitpos
= val_as_value
->bitpos ();
10201 saved_bitsize
= val_as_value
->bitsize ();
10209 exp_valid_block
= NULL
;
10210 val
= release_value (value_addr (result
));
10211 value_free_to_mark (mark
);
10215 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10218 error (_("This target does not support masked watchpoints."));
10219 else if (ret
== -2)
10220 error (_("Invalid mask or memory region."));
10223 else if (val_as_value
!= NULL
)
10224 val
= release_value (val_as_value
);
10226 tok
= skip_spaces (arg
);
10227 end_tok
= skip_to_space (tok
);
10229 toklen
= end_tok
- tok
;
10230 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10232 tok
= cond_start
= end_tok
+ 1;
10233 innermost_block_tracker if_tracker
;
10234 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10236 /* The watchpoint expression may not be local, but the condition
10237 may still be. E.g.: `watch global if local > 0'. */
10238 cond_exp_valid_block
= if_tracker
.block ();
10243 error (_("Junk at end of command."));
10245 frame_info_ptr wp_frame
= block_innermost_frame (exp_valid_block
);
10247 /* Save this because create_internal_breakpoint below invalidates
10249 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10251 /* If the expression is "local", then set up a "watchpoint scope"
10252 breakpoint at the point where we've left the scope of the watchpoint
10253 expression. Create the scope breakpoint before the watchpoint, so
10254 that we will encounter it first in bpstat_stop_status. */
10255 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10257 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10259 if (frame_id_p (caller_frame_id
))
10261 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10262 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10265 = create_internal_breakpoint (caller_arch
, caller_pc
,
10266 bp_watchpoint_scope
);
10268 /* create_internal_breakpoint could invalidate WP_FRAME. */
10271 scope_breakpoint
->enable_state
= bp_enabled
;
10273 /* Automatically delete the breakpoint when it hits. */
10274 scope_breakpoint
->disposition
= disp_del
;
10276 /* Only break in the proper frame (help with recursion). */
10277 scope_breakpoint
->frame_id
= caller_frame_id
;
10279 /* Set the address at which we will stop. */
10280 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10281 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10282 scope_breakpoint
->loc
->address
10283 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10284 scope_breakpoint
->loc
->requested_address
,
10285 scope_breakpoint
->type
,
10286 current_program_space
);
10290 /* Now set up the breakpoint. We create all watchpoints as hardware
10291 watchpoints here even if hardware watchpoints are turned off, a call
10292 to update_watchpoint later in this function will cause the type to
10293 drop back to bp_watchpoint (software watchpoint) if required. */
10295 if (accessflag
== hw_read
)
10296 bp_type
= bp_read_watchpoint
;
10297 else if (accessflag
== hw_access
)
10298 bp_type
= bp_access_watchpoint
;
10300 bp_type
= bp_hardware_watchpoint
;
10302 std::unique_ptr
<watchpoint
> w
;
10304 w
.reset (new masked_watchpoint (nullptr, bp_type
));
10306 w
.reset (new watchpoint (nullptr, bp_type
));
10308 /* At most one of thread or task can be set on a watchpoint. */
10309 gdb_assert (thread
== -1 || task
== -1);
10310 w
->thread
= thread
;
10312 w
->disposition
= disp_donttouch
;
10313 w
->pspace
= current_program_space
;
10314 w
->exp
= std::move (exp
);
10315 w
->exp_valid_block
= exp_valid_block
;
10316 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10319 struct type
*t
= val
.get ()->type ();
10320 CORE_ADDR addr
= value_as_address (val
.get ());
10322 w
->exp_string_reparse
10323 = current_language
->watch_location_expression (t
, addr
);
10325 w
->exp_string
= xstrprintf ("-location %.*s",
10326 (int) (exp_end
- exp_start
), exp_start
);
10329 w
->exp_string
.reset (savestring (exp_start
, exp_end
- exp_start
));
10333 w
->hw_wp_mask
= mask
;
10338 w
->val_bitpos
= saved_bitpos
;
10339 w
->val_bitsize
= saved_bitsize
;
10340 w
->val_valid
= true;
10344 w
->cond_string
.reset (savestring (cond_start
, cond_end
- cond_start
));
10346 w
->cond_string
= 0;
10348 if (frame_id_p (watchpoint_frame
))
10350 w
->watchpoint_frame
= watchpoint_frame
;
10351 w
->watchpoint_thread
= inferior_ptid
;
10355 w
->watchpoint_frame
= null_frame_id
;
10356 w
->watchpoint_thread
= null_ptid
;
10359 if (scope_breakpoint
!= NULL
)
10361 /* The scope breakpoint is related to the watchpoint. We will
10362 need to act on them together. */
10363 w
->related_breakpoint
= scope_breakpoint
;
10364 scope_breakpoint
->related_breakpoint
= w
.get ();
10367 if (!just_location
)
10368 value_free_to_mark (mark
);
10370 /* Finally update the new watchpoint. This creates the locations
10371 that should be inserted. */
10372 update_watchpoint (w
.get (), true /* reparse */);
10374 install_breakpoint (internal
, std::move (w
), 1);
10377 /* Return count of debug registers needed to watch the given expression.
10378 If the watchpoint cannot be handled in hardware return zero. */
10381 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
10383 int found_memory_cnt
= 0;
10385 /* Did the user specifically forbid us to use hardware watchpoints? */
10386 if (!can_use_hw_watchpoints
)
10389 gdb_assert (!vals
.empty ());
10390 struct value
*head
= vals
[0].get ();
10392 /* Make sure that the value of the expression depends only upon
10393 memory contents, and values computed from them within GDB. If we
10394 find any register references or function calls, we can't use a
10395 hardware watchpoint.
10397 The idea here is that evaluating an expression generates a series
10398 of values, one holding the value of every subexpression. (The
10399 expression a*b+c has five subexpressions: a, b, a*b, c, and
10400 a*b+c.) GDB's values hold almost enough information to establish
10401 the criteria given above --- they identify memory lvalues,
10402 register lvalues, computed values, etcetera. So we can evaluate
10403 the expression, and then scan the chain of values that leaves
10404 behind to decide whether we can detect any possible change to the
10405 expression's final value using only hardware watchpoints.
10407 However, I don't think that the values returned by inferior
10408 function calls are special in any way. So this function may not
10409 notice that an expression involving an inferior function call
10410 can't be watched with hardware watchpoints. FIXME. */
10411 for (const value_ref_ptr
&iter
: vals
)
10413 struct value
*v
= iter
.get ();
10415 if (v
->lval () == lval_memory
)
10417 if (v
!= head
&& v
->lazy ())
10418 /* A lazy memory lvalue in the chain is one that GDB never
10419 needed to fetch; we either just used its address (e.g.,
10420 `a' in `a.b') or we never needed it at all (e.g., `a'
10421 in `a,b'). This doesn't apply to HEAD; if that is
10422 lazy then it was not readable, but watch it anyway. */
10426 /* Ahh, memory we actually used! Check if we can cover
10427 it with hardware watchpoints. */
10428 struct type
*vtype
= check_typedef (v
->type ());
10430 /* We only watch structs and arrays if user asked for it
10431 explicitly, never if they just happen to appear in a
10432 middle of some value chain. */
10434 || (vtype
->code () != TYPE_CODE_STRUCT
10435 && vtype
->code () != TYPE_CODE_ARRAY
))
10437 CORE_ADDR vaddr
= v
->address ();
10441 len
= (target_exact_watchpoints
10442 && is_scalar_type_recursive (vtype
))?
10443 1 : v
->type ()->length ();
10445 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10449 found_memory_cnt
+= num_regs
;
10453 else if (v
->lval () != not_lval
10454 && v
->deprecated_modifiable () == 0)
10455 return 0; /* These are values from the history (e.g., $1). */
10456 else if (v
->lval () == lval_register
)
10457 return 0; /* Cannot watch a register with a HW watchpoint. */
10460 /* The expression itself looks suitable for using a hardware
10461 watchpoint, but give the target machine a chance to reject it. */
10462 return found_memory_cnt
;
10466 watch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10468 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
10471 /* Options for the watch, awatch, and rwatch commands. */
10473 struct watch_options
10475 /* For -location. */
10476 bool location
= false;
10479 /* Definitions of options for the "watch", "awatch", and "rwatch" commands.
10481 Historically GDB always accepted both '-location' and '-l' flags for
10482 these commands (both flags being synonyms). When converting to the
10483 newer option scheme only '-location' is added here. That's fine (for
10484 backward compatibility) as any non-ambiguous prefix of a flag will be
10485 accepted, so '-l', '-loc', are now all accepted.
10487 What this means is that, if in the future, we add any new flag here
10488 that starts with '-l' then this will break backward compatibility, so
10489 please, don't do that! */
10491 static const gdb::option::option_def watch_option_defs
[] = {
10492 gdb::option::flag_option_def
<watch_options
> {
10494 [] (watch_options
*opt
) { return &opt
->location
; },
10496 This evaluates EXPRESSION and watches the memory to which is refers.\n\
10497 -l can be used as a short form of -location."),
10501 /* Returns the option group used by 'watch', 'awatch', and 'rwatch'
10504 static gdb::option::option_def_group
10505 make_watch_options_def_group (watch_options
*opts
)
10507 return {{watch_option_defs
}, opts
};
10510 /* A helper function that looks for the "-location" argument and then
10511 calls watch_command_1. */
10514 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
10516 watch_options opts
;
10517 auto grp
= make_watch_options_def_group (&opts
);
10518 gdb::option::process_options
10519 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
10520 if (arg
!= nullptr && *arg
== '\0')
10523 watch_command_1 (arg
, accessflag
, from_tty
, opts
.location
, false);
10526 /* Command completion for 'watch', 'awatch', and 'rwatch' commands. */
10528 watch_command_completer (struct cmd_list_element
*ignore
,
10529 completion_tracker
&tracker
,
10530 const char *text
, const char * /*word*/)
10532 const auto group
= make_watch_options_def_group (nullptr);
10533 if (gdb::option::complete_options
10534 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
10537 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
10538 expression_completer (ignore
, tracker
, text
, word
);
10542 watch_command (const char *arg
, int from_tty
)
10544 watch_maybe_just_location (arg
, hw_write
, from_tty
);
10548 rwatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10550 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
10554 rwatch_command (const char *arg
, int from_tty
)
10556 watch_maybe_just_location (arg
, hw_read
, from_tty
);
10560 awatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10562 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
10566 awatch_command (const char *arg
, int from_tty
)
10568 watch_maybe_just_location (arg
, hw_access
, from_tty
);
10572 /* Data for the FSM that manages the until(location)/advance commands
10573 in infcmd.c. Here because it uses the mechanisms of
10576 struct until_break_fsm
: public thread_fsm
10578 /* The thread that was current when the command was executed. */
10581 /* The breakpoint set at the return address in the caller frame,
10582 plus breakpoints at all the destination locations. */
10583 std::vector
<breakpoint_up
> breakpoints
;
10585 until_break_fsm (struct interp
*cmd_interp
, int thread
,
10586 std::vector
<breakpoint_up
> &&breakpoints
)
10587 : thread_fsm (cmd_interp
),
10589 breakpoints (std::move (breakpoints
))
10593 void clean_up (struct thread_info
*thread
) override
;
10594 bool should_stop (struct thread_info
*thread
) override
;
10595 enum async_reply_reason
do_async_reply_reason () override
;
10598 /* Implementation of the 'should_stop' FSM method for the
10599 until(location)/advance commands. */
10602 until_break_fsm::should_stop (struct thread_info
*tp
)
10604 for (const breakpoint_up
&bp
: breakpoints
)
10605 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
10606 bp
.get ()) != NULL
)
10615 /* Implementation of the 'clean_up' FSM method for the
10616 until(location)/advance commands. */
10619 until_break_fsm::clean_up (struct thread_info
*)
10621 /* Clean up our temporary breakpoints. */
10622 breakpoints
.clear ();
10623 delete_longjmp_breakpoint (thread
);
10626 /* Implementation of the 'async_reply_reason' FSM method for the
10627 until(location)/advance commands. */
10629 enum async_reply_reason
10630 until_break_fsm::do_async_reply_reason ()
10632 return EXEC_ASYNC_LOCATION_REACHED
;
10636 until_break_command (const char *arg
, int from_tty
, int anywhere
)
10638 frame_info_ptr frame
;
10639 struct gdbarch
*frame_gdbarch
;
10640 struct frame_id stack_frame_id
;
10641 struct frame_id caller_frame_id
;
10643 struct thread_info
*tp
;
10645 clear_proceed_status (0);
10647 /* Set a breakpoint where the user wants it and at return from
10650 location_spec_up locspec
= string_to_location_spec (&arg
, current_language
);
10652 std::vector
<symtab_and_line
> sals
10653 = (last_displayed_sal_is_valid ()
10654 ? decode_line_1 (locspec
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10655 get_last_displayed_symtab (),
10656 get_last_displayed_line ())
10657 : decode_line_1 (locspec
.get (), DECODE_LINE_FUNFIRSTLINE
,
10661 error (_("Couldn't get information on specified line."));
10664 error (_("Junk at end of arguments."));
10666 tp
= inferior_thread ();
10667 thread
= tp
->global_num
;
10669 /* Note linespec handling above invalidates the frame chain.
10670 Installing a breakpoint also invalidates the frame chain (as it
10671 may need to switch threads), so do any frame handling before
10674 frame
= get_selected_frame (NULL
);
10675 frame_gdbarch
= get_frame_arch (frame
);
10676 stack_frame_id
= get_stack_frame_id (frame
);
10677 caller_frame_id
= frame_unwind_caller_id (frame
);
10679 /* Keep within the current frame, or in frames called by the current
10682 std::vector
<breakpoint_up
> breakpoints
;
10684 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
10686 if (frame_id_p (caller_frame_id
))
10688 struct symtab_and_line sal2
;
10689 struct gdbarch
*caller_gdbarch
;
10691 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
10692 sal2
.pc
= frame_unwind_caller_pc (frame
);
10693 caller_gdbarch
= frame_unwind_caller_arch (frame
);
10695 breakpoint_up caller_breakpoint
10696 = set_momentary_breakpoint (caller_gdbarch
, sal2
,
10697 caller_frame_id
, bp_until
);
10698 breakpoints
.emplace_back (std::move (caller_breakpoint
));
10700 set_longjmp_breakpoint (tp
, stack_frame_id
);
10701 lj_deleter
.emplace (thread
);
10704 /* set_momentary_breakpoint could invalidate FRAME. */
10707 /* If the user told us to continue until a specified location, we
10708 don't specify a frame at which we need to stop. Otherwise,
10709 specify the selected frame, because we want to stop only at the
10710 very same frame. */
10711 frame_id stop_frame_id
= anywhere
? null_frame_id
: stack_frame_id
;
10713 for (symtab_and_line
&sal
: sals
)
10715 resolve_sal_pc (&sal
);
10717 breakpoint_up location_breakpoint
10718 = set_momentary_breakpoint (frame_gdbarch
, sal
,
10719 stop_frame_id
, bp_until
);
10720 breakpoints
.emplace_back (std::move (location_breakpoint
));
10724 (std::unique_ptr
<thread_fsm
>
10725 (new until_break_fsm (command_interp (), tp
->global_num
,
10726 std::move (breakpoints
))));
10729 lj_deleter
->release ();
10731 proceed (-1, GDB_SIGNAL_DEFAULT
);
10736 /* Compare two breakpoints and return a strcmp-like result. */
10739 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
10741 uintptr_t ua
= (uintptr_t) a
;
10742 uintptr_t ub
= (uintptr_t) b
;
10744 if (a
->number
< b
->number
)
10746 else if (a
->number
> b
->number
)
10749 /* Now sort by address, in case we see, e..g, two breakpoints with
10753 return ua
> ub
? 1 : 0;
10756 /* Delete breakpoints by address or line. */
10759 clear_command (const char *arg
, int from_tty
)
10763 std::vector
<symtab_and_line
> decoded_sals
;
10764 symtab_and_line last_sal
;
10765 gdb::array_view
<symtab_and_line
> sals
;
10769 = decode_line_with_current_source (arg
,
10770 (DECODE_LINE_FUNFIRSTLINE
10771 | DECODE_LINE_LIST_MODE
));
10773 sals
= decoded_sals
;
10777 /* Set sal's line, symtab, pc, and pspace to the values
10778 corresponding to the last call to print_frame_info. If the
10779 codepoint is not valid, this will set all the fields to 0. */
10780 last_sal
= get_last_displayed_sal ();
10781 if (last_sal
.symtab
== 0)
10782 error (_("No source file specified."));
10788 /* We don't call resolve_sal_pc here. That's not as bad as it
10789 seems, because all existing breakpoints typically have both
10790 file/line and pc set. So, if clear is given file/line, we can
10791 match this to existing breakpoint without obtaining pc at all.
10793 We only support clearing given the address explicitly
10794 present in breakpoint table. Say, we've set breakpoint
10795 at file:line. There were several PC values for that file:line,
10796 due to optimization, all in one block.
10798 We've picked one PC value. If "clear" is issued with another
10799 PC corresponding to the same file:line, the breakpoint won't
10800 be cleared. We probably can still clear the breakpoint, but
10801 since the other PC value is never presented to user, user
10802 can only find it by guessing, and it does not seem important
10803 to support that. */
10805 /* For each line spec given, delete bps which correspond to it. Do
10806 it in two passes, solely to preserve the current behavior that
10807 from_tty is forced true if we delete more than one
10810 std::vector
<struct breakpoint
*> found
;
10811 for (const auto &sal
: sals
)
10813 const char *sal_fullname
;
10815 /* If exact pc given, clear bpts at that pc.
10816 If line given (pc == 0), clear all bpts on specified line.
10817 If defaulting, clear all bpts on default line
10820 defaulting sal.pc != 0 tests to do
10825 1 0 <can't happen> */
10827 sal_fullname
= (sal
.symtab
== NULL
10828 ? NULL
: symtab_to_fullname (sal
.symtab
));
10830 /* Find all matching breakpoints and add them to 'found'. */
10831 for (breakpoint
*b
: all_breakpoints ())
10834 /* Are we going to delete b? */
10835 if (b
->type
!= bp_none
&& !is_watchpoint (b
)
10836 && user_breakpoint_p (b
))
10838 for (bp_location
*loc
: b
->locations ())
10840 /* If the user specified file:line, don't allow a PC
10841 match. This matches historical gdb behavior. */
10842 int pc_match
= (!sal
.explicit_line
10844 && (loc
->pspace
== sal
.pspace
)
10845 && (loc
->address
== sal
.pc
)
10846 && (!section_is_overlay (loc
->section
)
10847 || loc
->section
== sal
.section
));
10848 int line_match
= 0;
10850 if ((default_match
|| sal
.explicit_line
)
10851 && loc
->symtab
!= NULL
10852 && sal_fullname
!= NULL
10853 && sal
.pspace
== loc
->pspace
10854 && loc
->line_number
== sal
.line
10855 && filename_cmp (symtab_to_fullname (loc
->symtab
),
10856 sal_fullname
) == 0)
10859 if (pc_match
|| line_match
)
10868 found
.push_back (b
);
10872 /* Now go thru the 'found' chain and delete them. */
10873 if (found
.empty ())
10876 error (_("No breakpoint at %s."), arg
);
10878 error (_("No breakpoint at this line."));
10881 /* Remove duplicates from the vec. */
10882 std::sort (found
.begin (), found
.end (),
10883 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
10885 return compare_breakpoints (bp_a
, bp_b
) < 0;
10887 found
.erase (std::unique (found
.begin (), found
.end (),
10888 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
10890 return compare_breakpoints (bp_a
, bp_b
) == 0;
10894 if (found
.size () > 1)
10895 from_tty
= 1; /* Always report if deleted more than one. */
10898 if (found
.size () == 1)
10899 gdb_printf (_("Deleted breakpoint "));
10901 gdb_printf (_("Deleted breakpoints "));
10904 for (breakpoint
*iter
: found
)
10907 gdb_printf ("%d ", iter
->number
);
10908 delete_breakpoint (iter
);
10914 /* Delete breakpoint in BS if they are `delete' breakpoints and
10915 all breakpoints that are marked for deletion, whether hit or not.
10916 This is called after any breakpoint is hit, or after errors. */
10919 breakpoint_auto_delete (bpstat
*bs
)
10921 for (; bs
; bs
= bs
->next
)
10922 if (bs
->breakpoint_at
10923 && bs
->breakpoint_at
->disposition
== disp_del
10925 delete_breakpoint (bs
->breakpoint_at
);
10927 for (breakpoint
*b
: all_breakpoints_safe ())
10928 if (b
->disposition
== disp_del_at_next_stop
)
10929 delete_breakpoint (b
);
10932 /* A comparison function for bp_location AP and BP being interfaced to
10933 std::sort. Sort elements primarily by their ADDRESS (no matter what
10934 bl_address_is_meaningful says), secondarily by ordering first
10935 permanent elements and terciarily just ensuring the array is sorted
10936 stable way despite std::sort being an unstable algorithm. */
10939 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
10941 if (a
->address
!= b
->address
)
10942 return a
->address
< b
->address
;
10944 /* Sort locations at the same address by their pspace number, keeping
10945 locations of the same inferior (in a multi-inferior environment)
10948 if (a
->pspace
->num
!= b
->pspace
->num
)
10949 return a
->pspace
->num
< b
->pspace
->num
;
10951 /* Sort permanent breakpoints first. */
10952 if (a
->permanent
!= b
->permanent
)
10953 return a
->permanent
> b
->permanent
;
10955 /* Sort by type in order to make duplicate determination easier.
10956 See update_global_location_list. This is kept in sync with
10957 breakpoint_locations_match. */
10958 if (a
->loc_type
< b
->loc_type
)
10961 /* Likewise, for range-breakpoints, sort by length. */
10962 if (a
->loc_type
== bp_loc_hardware_breakpoint
10963 && b
->loc_type
== bp_loc_hardware_breakpoint
10964 && a
->length
< b
->length
)
10967 /* Make the internal GDB representation stable across GDB runs
10968 where A and B memory inside GDB can differ. Breakpoint locations of
10969 the same type at the same address can be sorted in arbitrary order. */
10971 if (a
->owner
->number
!= b
->owner
->number
)
10972 return a
->owner
->number
< b
->owner
->number
;
10977 /* Set bp_locations_placed_address_before_address_max and
10978 bp_locations_shadow_len_after_address_max according to the current
10979 content of the bp_locations array. */
10982 bp_locations_target_extensions_update (void)
10984 bp_locations_placed_address_before_address_max
= 0;
10985 bp_locations_shadow_len_after_address_max
= 0;
10987 for (bp_location
*bl
: all_bp_locations ())
10989 CORE_ADDR start
, end
, addr
;
10991 if (!bp_location_has_shadow (bl
))
10994 start
= bl
->target_info
.placed_address
;
10995 end
= start
+ bl
->target_info
.shadow_len
;
10997 gdb_assert (bl
->address
>= start
);
10998 addr
= bl
->address
- start
;
10999 if (addr
> bp_locations_placed_address_before_address_max
)
11000 bp_locations_placed_address_before_address_max
= addr
;
11002 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11004 gdb_assert (bl
->address
< end
);
11005 addr
= end
- bl
->address
;
11006 if (addr
> bp_locations_shadow_len_after_address_max
)
11007 bp_locations_shadow_len_after_address_max
= addr
;
11011 /* Download tracepoint locations if they haven't been. */
11014 download_tracepoint_locations (void)
11016 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11018 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11020 for (breakpoint
*b
: all_tracepoints ())
11022 struct tracepoint
*t
;
11023 bool bp_location_downloaded
= false;
11025 if ((b
->type
== bp_fast_tracepoint
11026 ? !may_insert_fast_tracepoints
11027 : !may_insert_tracepoints
))
11030 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11032 if (target_can_download_tracepoint ())
11033 can_download_tracepoint
= TRIBOOL_TRUE
;
11035 can_download_tracepoint
= TRIBOOL_FALSE
;
11038 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11041 for (bp_location
*bl
: b
->locations ())
11043 /* In tracepoint, locations are _never_ duplicated, so
11044 should_be_inserted is equivalent to
11045 unduplicated_should_be_inserted. */
11046 if (!should_be_inserted (bl
) || bl
->inserted
)
11049 switch_to_program_space_and_thread (bl
->pspace
);
11051 target_download_tracepoint (bl
);
11054 bp_location_downloaded
= true;
11056 t
= (struct tracepoint
*) b
;
11057 t
->number_on_target
= b
->number
;
11058 if (bp_location_downloaded
)
11059 gdb::observers::breakpoint_modified
.notify (b
);
11063 /* Swap the insertion/duplication state between two locations. */
11066 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11068 const int left_inserted
= left
->inserted
;
11069 const int left_duplicate
= left
->duplicate
;
11070 const int left_needs_update
= left
->needs_update
;
11071 const struct bp_target_info left_target_info
= left
->target_info
;
11073 /* Locations of tracepoints can never be duplicated. */
11074 if (is_tracepoint (left
->owner
))
11075 gdb_assert (!left
->duplicate
);
11076 if (is_tracepoint (right
->owner
))
11077 gdb_assert (!right
->duplicate
);
11079 left
->inserted
= right
->inserted
;
11080 left
->duplicate
= right
->duplicate
;
11081 left
->needs_update
= right
->needs_update
;
11082 left
->target_info
= right
->target_info
;
11083 right
->inserted
= left_inserted
;
11084 right
->duplicate
= left_duplicate
;
11085 right
->needs_update
= left_needs_update
;
11086 right
->target_info
= left_target_info
;
11089 /* Force the re-insertion of the locations at ADDRESS. This is called
11090 once a new/deleted/modified duplicate location is found and we are evaluating
11091 conditions on the target's side. Such conditions need to be updated on
11095 force_breakpoint_reinsertion (struct bp_location
*bl
)
11097 CORE_ADDR address
= 0;
11100 address
= bl
->address
;
11101 pspace_num
= bl
->pspace
->num
;
11103 /* This is only meaningful if the target is
11104 evaluating conditions and if the user has
11105 opted for condition evaluation on the target's
11107 if (gdb_evaluates_breakpoint_condition_p ()
11108 || !target_supports_evaluation_of_breakpoint_conditions ())
11111 /* Flag all breakpoint locations with this address and
11112 the same program space as the location
11113 as "its condition has changed". We need to
11114 update the conditions on the target's side. */
11115 for (bp_location
*loc
: all_bp_locations_at_addr (address
))
11117 if (!is_breakpoint (loc
->owner
)
11118 || pspace_num
!= loc
->pspace
->num
)
11121 /* Flag the location appropriately. We use a different state to
11122 let everyone know that we already updated the set of locations
11123 with addr bl->address and program space bl->pspace. This is so
11124 we don't have to keep calling these functions just to mark locations
11125 that have already been marked. */
11126 loc
->condition_changed
= condition_updated
;
11128 /* Free the agent expression bytecode as well. We will compute
11130 loc
->cond_bytecode
.reset ();
11134 /* Called whether new breakpoints are created, or existing breakpoints
11135 deleted, to update the global location list and recompute which
11136 locations are duplicate of which.
11138 The INSERT_MODE flag determines whether locations may not, may, or
11139 shall be inserted now. See 'enum ugll_insert_mode' for more
11143 update_global_location_list (enum ugll_insert_mode insert_mode
)
11145 /* Last breakpoint location address that was marked for update. */
11146 CORE_ADDR last_addr
= 0;
11147 /* Last breakpoint location program space that was marked for update. */
11148 int last_pspace_num
= -1;
11150 /* Used in the duplicates detection below. When iterating over all
11151 bp_locations, points to the first bp_location of a given address.
11152 Breakpoints and watchpoints of different types are never
11153 duplicates of each other. Keep one pointer for each type of
11154 breakpoint/watchpoint, so we only need to loop over all locations
11156 struct bp_location
*bp_loc_first
; /* breakpoint */
11157 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11158 struct bp_location
*awp_loc_first
; /* access watchpoint */
11159 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11161 /* Saved former bp_locations array which we compare against the newly
11162 built bp_locations from the current state of ALL_BREAKPOINTS. */
11163 std::vector
<bp_location
*> old_locations
= std::move (bp_locations
);
11164 bp_locations
.clear ();
11166 for (breakpoint
*b
: all_breakpoints ())
11167 for (bp_location
*loc
: b
->locations ())
11168 bp_locations
.push_back (loc
);
11170 /* See if we need to "upgrade" a software breakpoint to a hardware
11171 breakpoint. Do this before deciding whether locations are
11172 duplicates. Also do this before sorting because sorting order
11173 depends on location type. */
11174 for (bp_location
*loc
: bp_locations
)
11175 if (!loc
->inserted
&& should_be_inserted (loc
))
11176 handle_automatic_hardware_breakpoints (loc
);
11178 std::sort (bp_locations
.begin (), bp_locations
.end (),
11179 bp_location_is_less_than
);
11181 bp_locations_target_extensions_update ();
11183 /* Identify bp_location instances that are no longer present in the
11184 new list, and therefore should be freed. Note that it's not
11185 necessary that those locations should be removed from inferior --
11186 if there's another location at the same address (previously
11187 marked as duplicate), we don't need to remove/insert the
11190 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11191 and former bp_location array state respectively. */
11194 for (bp_location
*old_loc
: old_locations
)
11196 /* Tells if 'old_loc' is found among the new locations. If
11197 not, we have to free it. */
11198 bool found_object
= false;
11199 /* Tells if the location should remain inserted in the target. */
11200 bool keep_in_target
= false;
11201 bool removed
= false;
11203 /* Skip LOCP entries which will definitely never be needed.
11204 Stop either at or being the one matching OLD_LOC. */
11205 while (loc_i
< bp_locations
.size ()
11206 && bp_locations
[loc_i
]->address
< old_loc
->address
)
11209 for (size_t loc2_i
= loc_i
;
11210 (loc2_i
< bp_locations
.size ()
11211 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11214 /* Check if this is a new/duplicated location or a duplicated
11215 location that had its condition modified. If so, we want to send
11216 its condition to the target if evaluation of conditions is taking
11218 if (bp_locations
[loc2_i
]->condition_changed
== condition_modified
11219 && (last_addr
!= old_loc
->address
11220 || last_pspace_num
!= old_loc
->pspace
->num
))
11222 force_breakpoint_reinsertion (bp_locations
[loc2_i
]);
11223 last_pspace_num
= old_loc
->pspace
->num
;
11226 if (bp_locations
[loc2_i
] == old_loc
)
11227 found_object
= true;
11230 /* We have already handled this address, update it so that we don't
11231 have to go through updates again. */
11232 last_addr
= old_loc
->address
;
11234 /* Target-side condition evaluation: Handle deleted locations. */
11236 force_breakpoint_reinsertion (old_loc
);
11238 /* If this location is no longer present, and inserted, look if
11239 there's maybe a new location at the same address. If so,
11240 mark that one inserted, and don't remove this one. This is
11241 needed so that we don't have a time window where a breakpoint
11242 at certain location is not inserted. */
11244 if (old_loc
->inserted
)
11246 /* If the location is inserted now, we might have to remove
11249 if (found_object
&& should_be_inserted (old_loc
))
11251 /* The location is still present in the location list,
11252 and still should be inserted. Don't do anything. */
11253 keep_in_target
= true;
11257 /* This location still exists, but it won't be kept in the
11258 target since it may have been disabled. We proceed to
11259 remove its target-side condition. */
11261 /* The location is either no longer present, or got
11262 disabled. See if there's another location at the
11263 same address, in which case we don't need to remove
11264 this one from the target. */
11266 /* OLD_LOC comes from existing struct breakpoint. */
11267 if (bl_address_is_meaningful (old_loc
))
11269 for (size_t loc2_i
= loc_i
;
11270 (loc2_i
< bp_locations
.size ()
11271 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11274 bp_location
*loc2
= bp_locations
[loc2_i
];
11276 if (loc2
== old_loc
)
11279 if (breakpoint_locations_match (loc2
, old_loc
))
11281 /* Read watchpoint locations are switched to
11282 access watchpoints, if the former are not
11283 supported, but the latter are. */
11284 if (is_hardware_watchpoint (old_loc
->owner
))
11286 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11287 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11290 /* loc2 is a duplicated location. We need to check
11291 if it should be inserted in case it will be
11293 if (unduplicated_should_be_inserted (loc2
))
11295 swap_insertion (old_loc
, loc2
);
11296 keep_in_target
= true;
11304 if (!keep_in_target
)
11306 if (remove_breakpoint (old_loc
))
11308 /* This is just about all we can do. We could keep
11309 this location on the global list, and try to
11310 remove it next time, but there's no particular
11311 reason why we will succeed next time.
11313 Note that at this point, old_loc->owner is still
11314 valid, as delete_breakpoint frees the breakpoint
11315 only after calling us. */
11316 gdb_printf (_("warning: Error removing "
11317 "breakpoint %d\n"),
11318 old_loc
->owner
->number
);
11326 if (removed
&& target_is_non_stop_p ()
11327 && need_moribund_for_location_type (old_loc
))
11329 /* This location was removed from the target. In
11330 non-stop mode, a race condition is possible where
11331 we've removed a breakpoint, but stop events for that
11332 breakpoint are already queued and will arrive later.
11333 We apply an heuristic to be able to distinguish such
11334 SIGTRAPs from other random SIGTRAPs: we keep this
11335 breakpoint location for a bit, and will retire it
11336 after we see some number of events. The theory here
11337 is that reporting of events should, "on the average",
11338 be fair, so after a while we'll see events from all
11339 threads that have anything of interest, and no longer
11340 need to keep this breakpoint location around. We
11341 don't hold locations forever so to reduce chances of
11342 mistaking a non-breakpoint SIGTRAP for a breakpoint
11345 The heuristic failing can be disastrous on
11346 decr_pc_after_break targets.
11348 On decr_pc_after_break targets, like e.g., x86-linux,
11349 if we fail to recognize a late breakpoint SIGTRAP,
11350 because events_till_retirement has reached 0 too
11351 soon, we'll fail to do the PC adjustment, and report
11352 a random SIGTRAP to the user. When the user resumes
11353 the inferior, it will most likely immediately crash
11354 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
11355 corrupted, because of being resumed e.g., in the
11356 middle of a multi-byte instruction, or skipped a
11357 one-byte instruction. This was actually seen happen
11358 on native x86-linux, and should be less rare on
11359 targets that do not support new thread events, like
11360 remote, due to the heuristic depending on
11363 Mistaking a random SIGTRAP for a breakpoint trap
11364 causes similar symptoms (PC adjustment applied when
11365 it shouldn't), but then again, playing with SIGTRAPs
11366 behind the debugger's back is asking for trouble.
11368 Since hardware watchpoint traps are always
11369 distinguishable from other traps, so we don't need to
11370 apply keep hardware watchpoint moribund locations
11371 around. We simply always ignore hardware watchpoint
11372 traps we can no longer explain. */
11374 process_stratum_target
*proc_target
= nullptr;
11375 for (inferior
*inf
: all_inferiors ())
11376 if (inf
->pspace
== old_loc
->pspace
)
11378 proc_target
= inf
->process_target ();
11381 if (proc_target
!= nullptr)
11382 old_loc
->events_till_retirement
11383 = 3 * (thread_count (proc_target
) + 1);
11385 old_loc
->events_till_retirement
= 1;
11386 old_loc
->owner
= NULL
;
11388 moribund_locations
.push_back (old_loc
);
11392 old_loc
->owner
= NULL
;
11393 decref_bp_location (&old_loc
);
11398 /* Rescan breakpoints at the same address and section, marking the
11399 first one as "first" and any others as "duplicates". This is so
11400 that the bpt instruction is only inserted once. If we have a
11401 permanent breakpoint at the same place as BPT, make that one the
11402 official one, and the rest as duplicates. Permanent breakpoints
11403 are sorted first for the same address.
11405 Do the same for hardware watchpoints, but also considering the
11406 watchpoint's type (regular/access/read) and length. */
11408 bp_loc_first
= NULL
;
11409 wp_loc_first
= NULL
;
11410 awp_loc_first
= NULL
;
11411 rwp_loc_first
= NULL
;
11413 for (bp_location
*loc
: all_bp_locations ())
11415 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
11417 struct bp_location
**loc_first_p
;
11418 breakpoint
*b
= loc
->owner
;
11420 if (!unduplicated_should_be_inserted (loc
)
11421 || !bl_address_is_meaningful (loc
)
11422 /* Don't detect duplicate for tracepoint locations because they are
11423 never duplicated. See the comments in field `duplicate' of
11424 `struct bp_location'. */
11425 || is_tracepoint (b
))
11427 /* Clear the condition modification flag. */
11428 loc
->condition_changed
= condition_unchanged
;
11432 if (b
->type
== bp_hardware_watchpoint
)
11433 loc_first_p
= &wp_loc_first
;
11434 else if (b
->type
== bp_read_watchpoint
)
11435 loc_first_p
= &rwp_loc_first
;
11436 else if (b
->type
== bp_access_watchpoint
)
11437 loc_first_p
= &awp_loc_first
;
11439 loc_first_p
= &bp_loc_first
;
11441 if (*loc_first_p
== NULL
11442 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
11443 || !breakpoint_locations_match (loc
, *loc_first_p
))
11445 *loc_first_p
= loc
;
11446 loc
->duplicate
= 0;
11448 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
11450 loc
->needs_update
= 1;
11451 /* Clear the condition modification flag. */
11452 loc
->condition_changed
= condition_unchanged
;
11458 /* This and the above ensure the invariant that the first location
11459 is not duplicated, and is the inserted one.
11460 All following are marked as duplicated, and are not inserted. */
11462 swap_insertion (loc
, *loc_first_p
);
11463 loc
->duplicate
= 1;
11465 /* Clear the condition modification flag. */
11466 loc
->condition_changed
= condition_unchanged
;
11469 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
11471 if (insert_mode
!= UGLL_DONT_INSERT
)
11472 insert_breakpoint_locations ();
11475 /* Even though the caller told us to not insert new
11476 locations, we may still need to update conditions on the
11477 target's side of breakpoints that were already inserted
11478 if the target is evaluating breakpoint conditions. We
11479 only update conditions for locations that are marked
11481 update_inserted_breakpoint_locations ();
11485 if (insert_mode
!= UGLL_DONT_INSERT
)
11486 download_tracepoint_locations ();
11490 breakpoint_retire_moribund (void)
11492 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
11494 struct bp_location
*loc
= moribund_locations
[ix
];
11495 if (--(loc
->events_till_retirement
) == 0)
11497 decref_bp_location (&loc
);
11498 unordered_remove (moribund_locations
, ix
);
11505 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
11510 update_global_location_list (insert_mode
);
11512 catch (const gdb_exception_error
&e
)
11517 /* Clear BKP from a BPS. */
11520 bpstat_remove_bp_location (bpstat
*bps
, struct breakpoint
*bpt
)
11524 for (bs
= bps
; bs
; bs
= bs
->next
)
11525 if (bs
->breakpoint_at
== bpt
)
11527 bs
->breakpoint_at
= NULL
;
11528 bs
->old_val
= NULL
;
11529 /* bs->commands will be freed later. */
11533 /* Callback for iterate_over_threads. */
11535 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
11537 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
11539 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
11543 /* See breakpoint.h. */
11546 code_breakpoint::say_where () const
11548 struct value_print_options opts
;
11550 get_user_print_options (&opts
);
11552 /* i18n: cagney/2005-02-11: Below needs to be merged into a
11556 /* For pending locations, the output differs slightly based
11557 on extra_string. If this is non-NULL, it contains either
11558 a condition or dprintf arguments. */
11559 if (extra_string
== NULL
)
11561 gdb_printf (_(" (%s) pending."), locspec
->to_string ());
11563 else if (type
== bp_dprintf
)
11565 gdb_printf (_(" (%s,%s) pending."),
11566 locspec
->to_string (),
11567 extra_string
.get ());
11571 gdb_printf (_(" (%s %s) pending."),
11572 locspec
->to_string (),
11573 extra_string
.get ());
11578 if (opts
.addressprint
|| loc
->symtab
== NULL
)
11579 gdb_printf (" at %ps",
11580 styled_string (address_style
.style (),
11581 paddress (loc
->gdbarch
,
11583 if (loc
->symtab
!= NULL
)
11585 /* If there is a single location, we can print the location
11587 if (loc
->next
== NULL
)
11589 const char *filename
11590 = symtab_to_filename_for_display (loc
->symtab
);
11591 gdb_printf (": file %ps, line %d.",
11592 styled_string (file_name_style
.style (),
11597 /* This is not ideal, but each location may have a
11598 different file name, and this at least reflects the
11599 real situation somewhat. */
11600 gdb_printf (": %s.", locspec
->to_string ());
11605 struct bp_location
*iter
= loc
;
11607 for (; iter
; iter
= iter
->next
)
11609 gdb_printf (" (%d locations)", n
);
11614 /* See breakpoint.h. */
11616 bp_location_range
breakpoint::locations () const
11618 return bp_location_range (this->loc
);
11621 struct bp_location
*
11622 breakpoint::allocate_location ()
11624 return new bp_location (this);
11627 #define internal_error_pure_virtual_called() \
11628 gdb_assert_not_reached ("pure virtual function called")
11631 breakpoint::insert_location (struct bp_location
*bl
)
11633 internal_error_pure_virtual_called ();
11637 breakpoint::remove_location (struct bp_location
*bl
,
11638 enum remove_bp_reason reason
)
11640 internal_error_pure_virtual_called ();
11644 breakpoint::breakpoint_hit (const struct bp_location
*bl
,
11645 const address_space
*aspace
,
11647 const target_waitstatus
&ws
)
11649 internal_error_pure_virtual_called ();
11653 breakpoint::resources_needed (const struct bp_location
*bl
)
11655 internal_error_pure_virtual_called ();
11658 enum print_stop_action
11659 breakpoint::print_it (const bpstat
*bs
) const
11661 internal_error_pure_virtual_called ();
11665 breakpoint::print_mention () const
11667 internal_error_pure_virtual_called ();
11671 breakpoint::print_recreate (struct ui_file
*fp
) const
11673 internal_error_pure_virtual_called ();
11676 /* Default breakpoint_ops methods. */
11679 code_breakpoint::re_set ()
11681 /* FIXME: is this still reachable? */
11682 if (breakpoint_location_spec_empty_p (this))
11684 /* Anything without a location can't be re-set. */
11685 delete_breakpoint (this);
11693 code_breakpoint::insert_location (struct bp_location
*bl
)
11695 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
11697 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
11698 bl
->target_info
.placed_address
= addr
;
11701 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11702 result
= target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11704 result
= target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11706 if (result
== 0 && bl
->probe
.prob
!= nullptr)
11708 /* The insertion was successful, now let's set the probe's semaphore
11710 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
11717 code_breakpoint::remove_location (struct bp_location
*bl
,
11718 enum remove_bp_reason reason
)
11720 if (bl
->probe
.prob
!= nullptr)
11722 /* Let's clear the semaphore before removing the location. */
11723 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
11726 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
11727 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
11729 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
11733 code_breakpoint::breakpoint_hit (const struct bp_location
*bl
,
11734 const address_space
*aspace
,
11736 const target_waitstatus
&ws
)
11738 if (ws
.kind () != TARGET_WAITKIND_STOPPED
11739 || ws
.sig () != GDB_SIGNAL_TRAP
)
11742 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
11746 if (overlay_debugging
/* unmapped overlay section */
11747 && section_is_overlay (bl
->section
)
11748 && !section_is_mapped (bl
->section
))
11755 dprintf_breakpoint::breakpoint_hit (const struct bp_location
*bl
,
11756 const address_space
*aspace
,
11758 const target_waitstatus
&ws
)
11760 if (dprintf_style
== dprintf_style_agent
11761 && target_can_run_breakpoint_commands ())
11763 /* An agent-style dprintf never causes a stop. If we see a trap
11764 for this address it must be for a breakpoint that happens to
11765 be set at the same address. */
11769 return this->ordinary_breakpoint::breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
11773 ordinary_breakpoint::resources_needed (const struct bp_location
*bl
)
11775 gdb_assert (type
== bp_hardware_breakpoint
);
11780 enum print_stop_action
11781 ordinary_breakpoint::print_it (const bpstat
*bs
) const
11783 const struct bp_location
*bl
;
11785 struct ui_out
*uiout
= current_uiout
;
11787 bl
= bs
->bp_location_at
.get ();
11789 bp_temp
= disposition
== disp_del
;
11790 if (bl
->address
!= bl
->requested_address
)
11791 breakpoint_adjustment_warning (bl
->requested_address
,
11794 annotate_breakpoint (number
);
11795 maybe_print_thread_hit_breakpoint (uiout
);
11797 if (uiout
->is_mi_like_p ())
11799 uiout
->field_string ("reason",
11800 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
11801 uiout
->field_string ("disp", bpdisp_text (disposition
));
11805 uiout
->text ("Temporary breakpoint ");
11807 uiout
->text ("Breakpoint ");
11808 print_num_locno (bs
, uiout
);
11809 uiout
->text (", ");
11811 return PRINT_SRC_AND_LOC
;
11815 ordinary_breakpoint::print_mention () const
11817 if (current_uiout
->is_mi_like_p ())
11822 case bp_breakpoint
:
11823 case bp_gnu_ifunc_resolver
:
11824 if (disposition
== disp_del
)
11825 gdb_printf (_("Temporary breakpoint"));
11827 gdb_printf (_("Breakpoint"));
11828 gdb_printf (_(" %d"), number
);
11829 if (type
== bp_gnu_ifunc_resolver
)
11830 gdb_printf (_(" at gnu-indirect-function resolver"));
11832 case bp_hardware_breakpoint
:
11833 gdb_printf (_("Hardware assisted breakpoint %d"), number
);
11836 gdb_printf (_("Dprintf %d"), number
);
11844 ordinary_breakpoint::print_recreate (struct ui_file
*fp
) const
11846 if (type
== bp_breakpoint
&& disposition
== disp_del
)
11847 gdb_printf (fp
, "tbreak");
11848 else if (type
== bp_breakpoint
)
11849 gdb_printf (fp
, "break");
11850 else if (type
== bp_hardware_breakpoint
11851 && disposition
== disp_del
)
11852 gdb_printf (fp
, "thbreak");
11853 else if (type
== bp_hardware_breakpoint
)
11854 gdb_printf (fp
, "hbreak");
11856 internal_error (_("unhandled breakpoint type %d"), (int) type
);
11858 gdb_printf (fp
, " %s", locspec
->to_string ());
11860 /* Print out extra_string if this breakpoint is pending. It might
11861 contain, for example, conditions that were set by the user. */
11862 if (loc
== NULL
&& extra_string
!= NULL
)
11863 gdb_printf (fp
, " %s", extra_string
.get ());
11865 print_recreate_thread (fp
);
11868 std::vector
<symtab_and_line
>
11869 code_breakpoint::decode_location_spec (location_spec
*locspec
,
11870 program_space
*search_pspace
)
11872 if (locspec
->type () == PROBE_LOCATION_SPEC
)
11873 return bkpt_probe_decode_location_spec (this, locspec
, search_pspace
);
11875 struct linespec_result canonical
;
11877 decode_line_full (locspec
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
11878 NULL
, 0, &canonical
, multiple_symbols_all
,
11881 /* We should get 0 or 1 resulting SALs. */
11882 gdb_assert (canonical
.lsals
.size () < 2);
11884 if (!canonical
.lsals
.empty ())
11886 const linespec_sals
&lsal
= canonical
.lsals
[0];
11887 return std::move (lsal
.sals
);
11892 /* Virtual table for internal breakpoints. */
11895 internal_breakpoint::re_set ()
11899 /* Delete overlay event and longjmp master breakpoints; they
11900 will be reset later by breakpoint_re_set. */
11901 case bp_overlay_event
:
11902 case bp_longjmp_master
:
11903 case bp_std_terminate_master
:
11904 case bp_exception_master
:
11905 delete_breakpoint (this);
11908 /* This breakpoint is special, it's set up when the inferior
11909 starts and we really don't want to touch it. */
11910 case bp_shlib_event
:
11912 /* Like bp_shlib_event, this breakpoint type is special. Once
11913 it is set up, we do not want to touch it. */
11914 case bp_thread_event
:
11920 internal_breakpoint::check_status (bpstat
*bs
)
11922 if (type
== bp_shlib_event
)
11924 /* If requested, stop when the dynamic linker notifies GDB of
11925 events. This allows the user to get control and place
11926 breakpoints in initializer routines for dynamically loaded
11927 objects (among other things). */
11928 bs
->stop
= stop_on_solib_events
!= 0;
11929 bs
->print
= stop_on_solib_events
!= 0;
11935 enum print_stop_action
11936 internal_breakpoint::print_it (const bpstat
*bs
) const
11940 case bp_shlib_event
:
11941 /* Did we stop because the user set the stop_on_solib_events
11942 variable? (If so, we report this as a generic, "Stopped due
11943 to shlib event" message.) */
11944 print_solib_event (false);
11947 case bp_thread_event
:
11948 /* Not sure how we will get here.
11949 GDB should not stop for these breakpoints. */
11950 gdb_printf (_("Thread Event Breakpoint: gdb should not stop!\n"));
11953 case bp_overlay_event
:
11954 /* By analogy with the thread event, GDB should not stop for these. */
11955 gdb_printf (_("Overlay Event Breakpoint: gdb should not stop!\n"));
11958 case bp_longjmp_master
:
11959 /* These should never be enabled. */
11960 gdb_printf (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
11963 case bp_std_terminate_master
:
11964 /* These should never be enabled. */
11965 gdb_printf (_("std::terminate Master Breakpoint: "
11966 "gdb should not stop!\n"));
11969 case bp_exception_master
:
11970 /* These should never be enabled. */
11971 gdb_printf (_("Exception Master Breakpoint: "
11972 "gdb should not stop!\n"));
11976 return PRINT_NOTHING
;
11980 internal_breakpoint::print_mention () const
11982 /* Nothing to mention. These breakpoints are internal. */
11985 /* Virtual table for momentary breakpoints */
11988 momentary_breakpoint::re_set ()
11990 /* Keep temporary breakpoints, which can be encountered when we step
11991 over a dlopen call and solib_add is resetting the breakpoints.
11992 Otherwise these should have been blown away via the cleanup chain
11993 or by breakpoint_init_inferior when we rerun the executable. */
11997 momentary_breakpoint::check_status (bpstat
*bs
)
11999 /* Nothing. The point of these breakpoints is causing a stop. */
12002 enum print_stop_action
12003 momentary_breakpoint::print_it (const bpstat
*bs
) const
12005 return PRINT_UNKNOWN
;
12009 momentary_breakpoint::print_mention () const
12011 /* Nothing to mention. These breakpoints are internal. */
12014 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12016 It gets cleared already on the removal of the first one of such placed
12017 breakpoints. This is OK as they get all removed altogether. */
12019 longjmp_breakpoint::~longjmp_breakpoint ()
12021 thread_info
*tp
= find_thread_global_id (this->thread
);
12024 tp
->initiating_frame
= null_frame_id
;
12028 bkpt_probe_create_sals_from_location_spec (location_spec
*locspec
,
12029 struct linespec_result
*canonical
)
12032 struct linespec_sals lsal
;
12034 lsal
.sals
= parse_probes (locspec
, NULL
, canonical
);
12035 lsal
.canonical
= xstrdup (canonical
->locspec
->to_string ());
12036 canonical
->lsals
.push_back (std::move (lsal
));
12039 static std::vector
<symtab_and_line
>
12040 bkpt_probe_decode_location_spec (struct breakpoint
*b
,
12041 location_spec
*locspec
,
12042 program_space
*search_pspace
)
12044 std::vector
<symtab_and_line
> sals
12045 = parse_probes (locspec
, search_pspace
, NULL
);
12047 error (_("probe not found"));
12052 tracepoint::breakpoint_hit (const struct bp_location
*bl
,
12053 const address_space
*aspace
, CORE_ADDR bp_addr
,
12054 const target_waitstatus
&ws
)
12056 /* By definition, the inferior does not report stops at
12062 tracepoint::print_one_detail (struct ui_out
*uiout
) const
12064 if (!static_trace_marker_id
.empty ())
12066 gdb_assert (type
== bp_static_tracepoint
12067 || type
== bp_static_marker_tracepoint
);
12069 uiout
->message ("\tmarker id is %pF\n",
12070 string_field ("static-tracepoint-marker-string-id",
12071 static_trace_marker_id
.c_str ()));
12076 tracepoint::print_mention () const
12078 if (current_uiout
->is_mi_like_p ())
12083 case bp_tracepoint
:
12084 gdb_printf (_("Tracepoint"));
12085 gdb_printf (_(" %d"), number
);
12087 case bp_fast_tracepoint
:
12088 gdb_printf (_("Fast tracepoint"));
12089 gdb_printf (_(" %d"), number
);
12091 case bp_static_tracepoint
:
12092 case bp_static_marker_tracepoint
:
12093 gdb_printf (_("Static tracepoint"));
12094 gdb_printf (_(" %d"), number
);
12097 internal_error (_("unhandled tracepoint type %d"), (int) type
);
12104 tracepoint::print_recreate (struct ui_file
*fp
) const
12106 if (type
== bp_fast_tracepoint
)
12107 gdb_printf (fp
, "ftrace");
12108 else if (type
== bp_static_tracepoint
12109 || type
== bp_static_marker_tracepoint
)
12110 gdb_printf (fp
, "strace");
12111 else if (type
== bp_tracepoint
)
12112 gdb_printf (fp
, "trace");
12114 internal_error (_("unhandled tracepoint type %d"), (int) type
);
12116 gdb_printf (fp
, " %s", locspec
->to_string ());
12117 print_recreate_thread (fp
);
12120 gdb_printf (fp
, " passcount %d\n", pass_count
);
12123 /* Virtual table for tracepoints on static probes. */
12126 tracepoint_probe_create_sals_from_location_spec
12127 (location_spec
*locspec
,
12128 struct linespec_result
*canonical
)
12130 /* We use the same method for breakpoint on probes. */
12131 bkpt_probe_create_sals_from_location_spec (locspec
, canonical
);
12135 dprintf_breakpoint::re_set ()
12139 /* extra_string should never be non-NULL for dprintf. */
12140 gdb_assert (extra_string
!= NULL
);
12142 /* 1 - connect to target 1, that can run breakpoint commands.
12143 2 - create a dprintf, which resolves fine.
12144 3 - disconnect from target 1
12145 4 - connect to target 2, that can NOT run breakpoint commands.
12147 After steps #3/#4, you'll want the dprintf command list to
12148 be updated, because target 1 and 2 may well return different
12149 answers for target_can_run_breakpoint_commands().
12150 Given absence of finer grained resetting, we get to do
12151 it all the time. */
12152 if (extra_string
!= NULL
)
12153 update_dprintf_command_list (this);
12156 /* Implement the "print_recreate" method for dprintf. */
12159 dprintf_breakpoint::print_recreate (struct ui_file
*fp
) const
12161 gdb_printf (fp
, "dprintf %s,%s", locspec
->to_string (), extra_string
.get ());
12162 print_recreate_thread (fp
);
12165 /* Implement the "after_condition_true" method for dprintf.
12167 dprintf's are implemented with regular commands in their command
12168 list, but we run the commands here instead of before presenting the
12169 stop to the user, as dprintf's don't actually cause a stop. This
12170 also makes it so that the commands of multiple dprintfs at the same
12171 address are all handled. */
12174 dprintf_breakpoint::after_condition_true (struct bpstat
*bs
)
12176 /* dprintf's never cause a stop. This wasn't set in the
12177 check_status hook instead because that would make the dprintf's
12178 condition not be evaluated. */
12181 /* Run the command list here. Take ownership of it instead of
12182 copying. We never want these commands to run later in
12183 bpstat_do_actions, if a breakpoint that causes a stop happens to
12184 be set at same address as this dprintf, or even if running the
12185 commands here throws. */
12186 counted_command_line cmds
= std::move (bs
->commands
);
12187 gdb_assert (cmds
!= nullptr);
12188 execute_control_commands (cmds
.get (), 0);
12191 /* The breakpoint_ops structure to be used on static tracepoints with
12195 strace_marker_create_sals_from_location_spec (location_spec
*locspec
,
12196 struct linespec_result
*canonical
)
12198 struct linespec_sals lsal
;
12199 const char *arg_start
, *arg
;
12201 arg
= arg_start
= as_linespec_location_spec (locspec
)->spec_string
;
12202 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
12204 std::string
str (arg_start
, arg
- arg_start
);
12205 const char *ptr
= str
.c_str ();
12207 = new_linespec_location_spec (&ptr
, symbol_name_match_type::FULL
);
12209 lsal
.canonical
= xstrdup (canonical
->locspec
->to_string ());
12210 canonical
->lsals
.push_back (std::move (lsal
));
12214 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12215 struct linespec_result
*canonical
,
12216 gdb::unique_xmalloc_ptr
<char> cond_string
,
12217 gdb::unique_xmalloc_ptr
<char> extra_string
,
12218 enum bptype type_wanted
,
12219 enum bpdisp disposition
,
12221 int task
, int ignore_count
,
12222 int from_tty
, int enabled
,
12223 int internal
, unsigned flags
)
12225 const linespec_sals
&lsal
= canonical
->lsals
[0];
12227 /* If the user is creating a static tracepoint by marker id
12228 (strace -m MARKER_ID), then store the sals index, so that
12229 breakpoint_re_set can try to match up which of the newly
12230 found markers corresponds to this one, and, don't try to
12231 expand multiple locations for each sal, given than SALS
12232 already should contain all sals for MARKER_ID. */
12234 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
12236 location_spec_up locspec
= canonical
->locspec
->clone ();
12238 std::unique_ptr
<tracepoint
> tp
12239 (new tracepoint (gdbarch
,
12242 std::move (locspec
),
12244 std::move (cond_string
),
12245 std::move (extra_string
),
12247 thread
, task
, ignore_count
,
12248 from_tty
, enabled
, flags
,
12249 canonical
->special_display
));
12251 /* Given that its possible to have multiple markers with
12252 the same string id, if the user is creating a static
12253 tracepoint by marker id ("strace -m MARKER_ID"), then
12254 store the sals index, so that breakpoint_re_set can
12255 try to match up which of the newly found markers
12256 corresponds to this one */
12257 tp
->static_trace_marker_id_idx
= i
;
12259 install_breakpoint (internal
, std::move (tp
), 0);
12263 std::vector
<symtab_and_line
>
12264 static_marker_tracepoint::decode_location_spec (location_spec
*locspec
,
12265 program_space
*search_pspace
)
12267 const char *s
= as_linespec_location_spec (locspec
)->spec_string
;
12269 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
12270 if (sals
.size () > static_trace_marker_id_idx
)
12272 sals
[0] = sals
[static_trace_marker_id_idx
];
12277 error (_("marker %s not found"), static_trace_marker_id
.c_str ());
12280 /* Static tracepoints with marker (`-m'). */
12281 static struct breakpoint_ops strace_marker_breakpoint_ops
=
12283 strace_marker_create_sals_from_location_spec
,
12284 strace_marker_create_breakpoints_sal
,
12288 strace_marker_p (struct breakpoint
*b
)
12290 return b
->type
== bp_static_marker_tracepoint
;
12293 /* Delete a breakpoint and clean up all traces of it in the data
12297 delete_breakpoint (struct breakpoint
*bpt
)
12299 gdb_assert (bpt
!= NULL
);
12301 /* Has this bp already been deleted? This can happen because
12302 multiple lists can hold pointers to bp's. bpstat lists are
12305 One example of this happening is a watchpoint's scope bp. When
12306 the scope bp triggers, we notice that the watchpoint is out of
12307 scope, and delete it. We also delete its scope bp. But the
12308 scope bp is marked "auto-deleting", and is already on a bpstat.
12309 That bpstat is then checked for auto-deleting bp's, which are
12312 A real solution to this problem might involve reference counts in
12313 bp's, and/or giving them pointers back to their referencing
12314 bpstat's, and teaching delete_breakpoint to only free a bp's
12315 storage when no more references were extent. A cheaper bandaid
12317 if (bpt
->type
== bp_none
)
12320 /* At least avoid this stale reference until the reference counting
12321 of breakpoints gets resolved. */
12322 if (bpt
->related_breakpoint
!= bpt
)
12324 struct breakpoint
*related
;
12325 struct watchpoint
*w
;
12327 if (bpt
->type
== bp_watchpoint_scope
)
12328 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
12329 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
12330 w
= (struct watchpoint
*) bpt
;
12334 watchpoint_del_at_next_stop (w
);
12336 /* Unlink bpt from the bpt->related_breakpoint ring. */
12337 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
12338 related
= related
->related_breakpoint
);
12339 related
->related_breakpoint
= bpt
->related_breakpoint
;
12340 bpt
->related_breakpoint
= bpt
;
12343 /* watch_command_1 creates a watchpoint but only sets its number if
12344 update_watchpoint succeeds in creating its bp_locations. If there's
12345 a problem in that process, we'll be asked to delete the half-created
12346 watchpoint. In that case, don't announce the deletion. */
12348 gdb::observers::breakpoint_deleted
.notify (bpt
);
12350 if (breakpoint_chain
== bpt
)
12351 breakpoint_chain
= bpt
->next
;
12353 for (breakpoint
*b
: all_breakpoints ())
12354 if (b
->next
== bpt
)
12356 b
->next
= bpt
->next
;
12360 /* Be sure no bpstat's are pointing at the breakpoint after it's
12362 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
12363 in all threads for now. Note that we cannot just remove bpstats
12364 pointing at bpt from the stop_bpstat list entirely, as breakpoint
12365 commands are associated with the bpstat; if we remove it here,
12366 then the later call to bpstat_do_actions (&stop_bpstat); in
12367 event-top.c won't do anything, and temporary breakpoints with
12368 commands won't work. */
12370 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
12372 /* Now that breakpoint is removed from breakpoint list, update the
12373 global location list. This will remove locations that used to
12374 belong to this breakpoint. Do this before freeing the breakpoint
12375 itself, since remove_breakpoint looks at location's owner. It
12376 might be better design to have location completely
12377 self-contained, but it's not the case now. */
12378 update_global_location_list (UGLL_DONT_INSERT
);
12380 /* On the chance that someone will soon try again to delete this
12381 same bp, we mark it as deleted before freeing its storage. */
12382 bpt
->type
= bp_none
;
12386 /* Iterator function to call a user-provided callback function once
12387 for each of B and its related breakpoints. */
12390 iterate_over_related_breakpoints (struct breakpoint
*b
,
12391 gdb::function_view
<void (breakpoint
*)> function
)
12393 struct breakpoint
*related
;
12398 struct breakpoint
*next
;
12400 /* FUNCTION may delete RELATED. */
12401 next
= related
->related_breakpoint
;
12403 if (next
== related
)
12405 /* RELATED is the last ring entry. */
12406 function (related
);
12408 /* FUNCTION may have deleted it, so we'd never reach back to
12409 B. There's nothing left to do anyway, so just break
12414 function (related
);
12418 while (related
!= b
);
12422 delete_command (const char *arg
, int from_tty
)
12428 int breaks_to_delete
= 0;
12430 /* Delete all breakpoints if no argument. Do not delete
12431 internal breakpoints, these have to be deleted with an
12432 explicit breakpoint number argument. */
12433 for (breakpoint
*b
: all_breakpoints ())
12434 if (user_breakpoint_p (b
))
12436 breaks_to_delete
= 1;
12440 /* Ask user only if there are some breakpoints to delete. */
12442 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
12443 for (breakpoint
*b
: all_breakpoints_safe ())
12444 if (user_breakpoint_p (b
))
12445 delete_breakpoint (b
);
12448 map_breakpoint_numbers
12449 (arg
, [&] (breakpoint
*br
)
12451 iterate_over_related_breakpoints (br
, delete_breakpoint
);
12455 /* Return true if all locations of B bound to PSPACE are pending. If
12456 PSPACE is NULL, all locations of all program spaces are
12460 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
12462 for (bp_location
*loc
: b
->locations ())
12463 if ((pspace
== NULL
12464 || loc
->pspace
== pspace
)
12465 && !loc
->shlib_disabled
12466 && !loc
->pspace
->executing_startup
)
12471 /* Subroutine of update_breakpoint_locations to simplify it.
12472 Return true if multiple fns in list LOC have the same name.
12473 Null names are ignored. */
12476 ambiguous_names_p (struct bp_location
*loc
)
12478 struct bp_location
*l
;
12479 htab_up
htab (htab_create_alloc (13, htab_hash_string
, htab_eq_string
, NULL
,
12482 for (l
= loc
; l
!= NULL
; l
= l
->next
)
12485 const char *name
= l
->function_name
.get ();
12487 /* Allow for some names to be NULL, ignore them. */
12491 slot
= (const char **) htab_find_slot (htab
.get (), (const void *) name
,
12493 /* NOTE: We can assume slot != NULL here because xcalloc never
12503 /* When symbols change, it probably means the sources changed as well,
12504 and it might mean the static tracepoint markers are no longer at
12505 the same address or line numbers they used to be at last we
12506 checked. Losing your static tracepoints whenever you rebuild is
12507 undesirable. This function tries to resync/rematch gdb static
12508 tracepoints with the markers on the target, for static tracepoints
12509 that have not been set by marker id. Static tracepoint that have
12510 been set by marker id are reset by marker id in breakpoint_re_set.
12513 1) For a tracepoint set at a specific address, look for a marker at
12514 the old PC. If one is found there, assume to be the same marker.
12515 If the name / string id of the marker found is different from the
12516 previous known name, assume that means the user renamed the marker
12517 in the sources, and output a warning.
12519 2) For a tracepoint set at a given line number, look for a marker
12520 at the new address of the old line number. If one is found there,
12521 assume to be the same marker. If the name / string id of the
12522 marker found is different from the previous known name, assume that
12523 means the user renamed the marker in the sources, and output a
12526 3) If a marker is no longer found at the same address or line, it
12527 may mean the marker no longer exists. But it may also just mean
12528 the code changed a bit. Maybe the user added a few lines of code
12529 that made the marker move up or down (in line number terms). Ask
12530 the target for info about the marker with the string id as we knew
12531 it. If found, update line number and address in the matching
12532 static tracepoint. This will get confused if there's more than one
12533 marker with the same ID (possible in UST, although unadvised
12534 precisely because it confuses tools). */
12536 static struct symtab_and_line
12537 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
12539 struct tracepoint
*tp
= (struct tracepoint
*) b
;
12540 struct static_tracepoint_marker marker
;
12545 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
12547 if (target_static_tracepoint_marker_at (pc
, &marker
))
12549 if (tp
->static_trace_marker_id
!= marker
.str_id
)
12550 warning (_("static tracepoint %d changed probed marker from %s to %s"),
12551 b
->number
, tp
->static_trace_marker_id
.c_str (),
12552 marker
.str_id
.c_str ());
12554 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
12559 /* Old marker wasn't found on target at lineno. Try looking it up
12561 if (!sal
.explicit_pc
12563 && sal
.symtab
!= NULL
12564 && !tp
->static_trace_marker_id
.empty ())
12566 std::vector
<static_tracepoint_marker
> markers
12567 = target_static_tracepoint_markers_by_strid
12568 (tp
->static_trace_marker_id
.c_str ());
12570 if (!markers
.empty ())
12572 struct symbol
*sym
;
12573 struct static_tracepoint_marker
*tpmarker
;
12574 struct ui_out
*uiout
= current_uiout
;
12576 tpmarker
= &markers
[0];
12578 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
12580 warning (_("marker for static tracepoint %d (%s) not "
12581 "found at previous line number"),
12582 b
->number
, tp
->static_trace_marker_id
.c_str ());
12584 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
12585 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
12586 uiout
->text ("Now in ");
12589 uiout
->field_string ("func", sym
->print_name (),
12590 function_name_style
.style ());
12591 uiout
->text (" at ");
12593 uiout
->field_string ("file",
12594 symtab_to_filename_for_display (sal2
.symtab
),
12595 file_name_style
.style ());
12598 if (uiout
->is_mi_like_p ())
12600 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
12602 uiout
->field_string ("fullname", fullname
);
12605 uiout
->field_signed ("line", sal2
.line
);
12606 uiout
->text ("\n");
12608 b
->loc
->line_number
= sal2
.line
;
12609 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
12611 std::unique_ptr
<explicit_location_spec
> els
12612 (new explicit_location_spec ());
12613 els
->source_filename
12614 = xstrdup (symtab_to_filename_for_display (sal2
.symtab
));
12615 els
->line_offset
.offset
= b
->loc
->line_number
;
12616 els
->line_offset
.sign
= LINE_OFFSET_NONE
;
12618 b
->locspec
= std::move (els
);
12620 /* Might be nice to check if function changed, and warn if
12627 /* Returns true iff locations A and B are sufficiently same that
12628 we don't need to report breakpoint as changed. */
12631 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
12635 if (a
->address
!= b
->address
)
12638 if (a
->shlib_disabled
!= b
->shlib_disabled
)
12641 if (a
->enabled
!= b
->enabled
)
12644 if (a
->disabled_by_cond
!= b
->disabled_by_cond
)
12651 if ((a
== NULL
) != (b
== NULL
))
12657 /* Split all locations of B that are bound to PSPACE out of B's
12658 location list to a separate list and return that list's head. If
12659 PSPACE is NULL, hoist out all locations of B. */
12661 static struct bp_location
*
12662 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
12664 struct bp_location head
;
12665 struct bp_location
*i
= b
->loc
;
12666 struct bp_location
**i_link
= &b
->loc
;
12667 struct bp_location
*hoisted
= &head
;
12669 if (pspace
== NULL
)
12680 if (i
->pspace
== pspace
)
12695 /* Create new breakpoint locations for B (a hardware or software
12696 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
12697 zero, then B is a ranged breakpoint. Only recreates locations for
12698 FILTER_PSPACE. Locations of other program spaces are left
12702 update_breakpoint_locations (code_breakpoint
*b
,
12703 struct program_space
*filter_pspace
,
12704 gdb::array_view
<const symtab_and_line
> sals
,
12705 gdb::array_view
<const symtab_and_line
> sals_end
)
12707 struct bp_location
*existing_locations
;
12709 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
12711 /* Ranged breakpoints have only one start location and one end
12713 b
->enable_state
= bp_disabled
;
12714 gdb_printf (gdb_stderr
,
12715 _("Could not reset ranged breakpoint %d: "
12716 "multiple locations found\n"),
12721 /* If there's no new locations, and all existing locations are
12722 pending, don't do anything. This optimizes the common case where
12723 all locations are in the same shared library, that was unloaded.
12724 We'd like to retain the location, so that when the library is
12725 loaded again, we don't loose the enabled/disabled status of the
12726 individual locations. */
12727 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
12730 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
12732 for (const auto &sal
: sals
)
12734 struct bp_location
*new_loc
;
12736 switch_to_program_space_and_thread (sal
.pspace
);
12738 new_loc
= b
->add_location (sal
);
12740 /* Reparse conditions, they might contain references to the
12742 if (b
->cond_string
!= NULL
)
12746 s
= b
->cond_string
.get ();
12749 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
12750 block_for_pc (sal
.pc
),
12753 catch (const gdb_exception_error
&e
)
12755 new_loc
->disabled_by_cond
= true;
12759 if (!sals_end
.empty ())
12761 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
12763 new_loc
->length
= end
- sals
[0].pc
+ 1;
12767 /* If possible, carry over 'disable' status from existing
12770 struct bp_location
*e
= existing_locations
;
12771 /* If there are multiple breakpoints with the same function name,
12772 e.g. for inline functions, comparing function names won't work.
12773 Instead compare pc addresses; this is just a heuristic as things
12774 may have moved, but in practice it gives the correct answer
12775 often enough until a better solution is found. */
12776 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
12778 for (; e
; e
= e
->next
)
12780 if ((!e
->enabled
|| e
->disabled_by_cond
) && e
->function_name
)
12782 if (have_ambiguous_names
)
12784 for (bp_location
*l
: b
->locations ())
12786 /* Ignore software vs hardware location type at
12787 this point, because with "set breakpoint
12788 auto-hw", after a re-set, locations that were
12789 hardware can end up as software, or vice versa.
12790 As mentioned above, this is an heuristic and in
12791 practice should give the correct answer often
12793 if (breakpoint_locations_match (e
, l
, true))
12795 l
->enabled
= e
->enabled
;
12796 l
->disabled_by_cond
= e
->disabled_by_cond
;
12803 for (bp_location
*l
: b
->locations ())
12804 if (l
->function_name
12805 && strcmp (e
->function_name
.get (),
12806 l
->function_name
.get ()) == 0)
12808 l
->enabled
= e
->enabled
;
12809 l
->disabled_by_cond
= e
->disabled_by_cond
;
12817 if (!locations_are_equal (existing_locations
, b
->loc
))
12818 gdb::observers::breakpoint_modified
.notify (b
);
12821 /* Find the SaL locations corresponding to the given LOCSPEC.
12822 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
12824 std::vector
<symtab_and_line
>
12825 code_breakpoint::location_spec_to_sals (location_spec
*locspec
,
12826 struct program_space
*search_pspace
,
12829 struct gdb_exception exception
;
12831 std::vector
<symtab_and_line
> sals
;
12835 sals
= decode_location_spec (locspec
, search_pspace
);
12837 catch (gdb_exception_error
&e
)
12839 int not_found_and_ok
= false;
12841 /* For pending breakpoints, it's expected that parsing will
12842 fail until the right shared library is loaded. User has
12843 already told to create pending breakpoints and don't need
12844 extra messages. If breakpoint is in bp_shlib_disabled
12845 state, then user already saw the message about that
12846 breakpoint being disabled, and don't want to see more
12848 if (e
.error
== NOT_FOUND_ERROR
12849 && (condition_not_parsed
12851 && search_pspace
!= NULL
12852 && loc
->pspace
!= search_pspace
)
12853 || (loc
&& loc
->shlib_disabled
)
12854 || (loc
&& loc
->pspace
->executing_startup
)
12855 || enable_state
== bp_disabled
))
12856 not_found_and_ok
= true;
12858 if (!not_found_and_ok
)
12860 /* We surely don't want to warn about the same breakpoint
12861 10 times. One solution, implemented here, is disable
12862 the breakpoint on error. Another solution would be to
12863 have separate 'warning emitted' flag. Since this
12864 happens only when a binary has changed, I don't know
12865 which approach is better. */
12866 enable_state
= bp_disabled
;
12870 exception
= std::move (e
);
12873 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
12875 for (auto &sal
: sals
)
12876 resolve_sal_pc (&sal
);
12877 if (condition_not_parsed
&& extra_string
!= NULL
)
12879 gdb::unique_xmalloc_ptr
<char> local_cond
, local_extra
;
12880 int local_thread
, local_task
;
12882 find_condition_and_thread_for_sals (sals
, extra_string
.get (),
12883 &local_cond
, &local_thread
,
12884 &local_task
, &local_extra
);
12885 gdb_assert (cond_string
== nullptr);
12886 if (local_cond
!= nullptr)
12887 cond_string
= std::move (local_cond
);
12888 thread
= local_thread
;
12890 if (local_extra
!= nullptr)
12891 extra_string
= std::move (local_extra
);
12892 condition_not_parsed
= 0;
12895 if (type
== bp_static_tracepoint
)
12896 sals
[0] = update_static_tracepoint (this, sals
[0]);
12906 /* The default re_set method, for typical hardware or software
12907 breakpoints. Reevaluate the breakpoint and recreate its
12911 code_breakpoint::re_set_default ()
12913 struct program_space
*filter_pspace
= current_program_space
;
12914 std::vector
<symtab_and_line
> expanded
, expanded_end
;
12917 std::vector
<symtab_and_line
> sals
= location_spec_to_sals (locspec
.get (),
12921 expanded
= std::move (sals
);
12923 if (locspec_range_end
!= nullptr)
12925 std::vector
<symtab_and_line
> sals_end
12926 = location_spec_to_sals (locspec_range_end
.get (),
12927 filter_pspace
, &found
);
12929 expanded_end
= std::move (sals_end
);
12932 update_breakpoint_locations (this, filter_pspace
, expanded
, expanded_end
);
12935 /* Default method for creating SALs from an address string. It basically
12936 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
12939 create_sals_from_location_spec_default (location_spec
*locspec
,
12940 struct linespec_result
*canonical
)
12942 parse_breakpoint_sals (locspec
, canonical
);
12945 /* Reset a breakpoint. */
12948 breakpoint_re_set_one (breakpoint
*b
)
12950 input_radix
= b
->input_radix
;
12951 set_language (b
->language
);
12956 /* Re-set breakpoint locations for the current program space.
12957 Locations bound to other program spaces are left untouched. */
12960 breakpoint_re_set (void)
12963 scoped_restore_current_language save_language
;
12964 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
12965 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
12967 /* breakpoint_re_set_one sets the current_language to the language
12968 of the breakpoint it is resetting (see prepare_re_set_context)
12969 before re-evaluating the breakpoint's location. This change can
12970 unfortunately get undone by accident if the language_mode is set
12971 to auto, and we either switch frames, or more likely in this context,
12972 we select the current frame.
12974 We prevent this by temporarily turning the language_mode to
12975 language_mode_manual. We restore it once all breakpoints
12976 have been reset. */
12977 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
12978 language_mode
= language_mode_manual
;
12980 /* Note: we must not try to insert locations until after all
12981 breakpoints have been re-set. Otherwise, e.g., when re-setting
12982 breakpoint 1, we'd insert the locations of breakpoint 2, which
12983 hadn't been re-set yet, and thus may have stale locations. */
12985 for (breakpoint
*b
: all_breakpoints_safe ())
12989 breakpoint_re_set_one (b
);
12991 catch (const gdb_exception
&ex
)
12993 exception_fprintf (gdb_stderr
, ex
,
12994 "Error in re-setting breakpoint %d: ",
12999 jit_breakpoint_re_set ();
13002 create_overlay_event_breakpoint ();
13003 create_longjmp_master_breakpoint ();
13004 create_std_terminate_master_breakpoint ();
13005 create_exception_master_breakpoint ();
13007 /* Now we can insert. */
13008 update_global_location_list (UGLL_MAY_INSERT
);
13011 /* Reset the thread number of this breakpoint:
13013 - If the breakpoint is for all threads, leave it as-is.
13014 - Else, reset it to the current thread for inferior_ptid. */
13016 breakpoint_re_set_thread (struct breakpoint
*b
)
13018 if (b
->thread
!= -1)
13020 b
->thread
= inferior_thread ()->global_num
;
13022 /* We're being called after following a fork. The new fork is
13023 selected as current, and unless this was a vfork will have a
13024 different program space from the original thread. Reset that
13026 b
->loc
->pspace
= current_program_space
;
13030 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13031 If from_tty is nonzero, it prints a message to that effect,
13032 which ends with a period (no newline). */
13035 set_ignore_count (int bptnum
, int count
, int from_tty
)
13040 for (breakpoint
*b
: all_breakpoints ())
13041 if (b
->number
== bptnum
)
13043 if (is_tracepoint (b
))
13045 if (from_tty
&& count
!= 0)
13046 gdb_printf (_("Ignore count ignored for tracepoint %d."),
13051 b
->ignore_count
= count
;
13055 gdb_printf (_("Will stop next time "
13056 "breakpoint %d is reached."),
13058 else if (count
== 1)
13059 gdb_printf (_("Will ignore next crossing of breakpoint %d."),
13062 gdb_printf (_("Will ignore next %d "
13063 "crossings of breakpoint %d."),
13066 gdb::observers::breakpoint_modified
.notify (b
);
13070 error (_("No breakpoint number %d."), bptnum
);
13073 /* Command to set ignore-count of breakpoint N to COUNT. */
13076 ignore_command (const char *args
, int from_tty
)
13078 const char *p
= args
;
13082 error_no_arg (_("a breakpoint number"));
13084 num
= get_number (&p
);
13086 error (_("bad breakpoint number: '%s'"), args
);
13088 error (_("Second argument (specified ignore-count) is missing."));
13090 set_ignore_count (num
,
13091 longest_to_int (value_as_long (parse_and_eval (p
))),
13098 /* Call FUNCTION on each of the breakpoints with numbers in the range
13099 defined by BP_NUM_RANGE (an inclusive range). */
13102 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
13103 gdb::function_view
<void (breakpoint
*)> function
)
13105 if (bp_num_range
.first
== 0)
13107 warning (_("bad breakpoint number at or near '%d'"),
13108 bp_num_range
.first
);
13112 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
13114 bool match
= false;
13116 for (breakpoint
*b
: all_breakpoints_safe ())
13117 if (b
->number
== i
)
13124 gdb_printf (_("No breakpoint number %d.\n"), i
);
13129 /* Call FUNCTION on each of the breakpoints whose numbers are given in
13133 map_breakpoint_numbers (const char *args
,
13134 gdb::function_view
<void (breakpoint
*)> function
)
13136 if (args
== NULL
|| *args
== '\0')
13137 error_no_arg (_("one or more breakpoint numbers"));
13139 number_or_range_parser
parser (args
);
13141 while (!parser
.finished ())
13143 int num
= parser
.get_number ();
13144 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
13148 /* Return the breakpoint location structure corresponding to the
13149 BP_NUM and LOC_NUM values. */
13151 static struct bp_location
*
13152 find_location_by_number (int bp_num
, int loc_num
)
13154 breakpoint
*b
= get_breakpoint (bp_num
);
13156 if (!b
|| b
->number
!= bp_num
)
13157 error (_("Bad breakpoint number '%d'"), bp_num
);
13160 error (_("Bad breakpoint location number '%d'"), loc_num
);
13163 for (bp_location
*loc
: b
->locations ())
13164 if (++n
== loc_num
)
13167 error (_("Bad breakpoint location number '%d'"), loc_num
);
13170 /* Modes of operation for extract_bp_num. */
13171 enum class extract_bp_kind
13173 /* Extracting a breakpoint number. */
13176 /* Extracting a location number. */
13180 /* Extract a breakpoint or location number (as determined by KIND)
13181 from the string starting at START. TRAILER is a character which
13182 can be found after the number. If you don't want a trailer, use
13183 '\0'. If END_OUT is not NULL, it is set to point after the parsed
13184 string. This always returns a positive integer. */
13187 extract_bp_num (extract_bp_kind kind
, const char *start
,
13188 int trailer
, const char **end_out
= NULL
)
13190 const char *end
= start
;
13191 int num
= get_number_trailer (&end
, trailer
);
13193 error (kind
== extract_bp_kind::bp
13194 ? _("Negative breakpoint number '%.*s'")
13195 : _("Negative breakpoint location number '%.*s'"),
13196 int (end
- start
), start
);
13198 error (kind
== extract_bp_kind::bp
13199 ? _("Bad breakpoint number '%.*s'")
13200 : _("Bad breakpoint location number '%.*s'"),
13201 int (end
- start
), start
);
13203 if (end_out
!= NULL
)
13208 /* Extract a breakpoint or location range (as determined by KIND) in
13209 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
13210 representing the (inclusive) range. The returned pair's elements
13211 are always positive integers. */
13213 static std::pair
<int, int>
13214 extract_bp_or_bp_range (extract_bp_kind kind
,
13215 const std::string
&arg
,
13216 std::string::size_type arg_offset
)
13218 std::pair
<int, int> range
;
13219 const char *bp_loc
= &arg
[arg_offset
];
13220 std::string::size_type dash
= arg
.find ('-', arg_offset
);
13221 if (dash
!= std::string::npos
)
13223 /* bp_loc is a range (x-z). */
13224 if (arg
.length () == dash
+ 1)
13225 error (kind
== extract_bp_kind::bp
13226 ? _("Bad breakpoint number at or near: '%s'")
13227 : _("Bad breakpoint location number at or near: '%s'"),
13231 const char *start_first
= bp_loc
;
13232 const char *start_second
= &arg
[dash
+ 1];
13233 range
.first
= extract_bp_num (kind
, start_first
, '-');
13234 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
13236 if (range
.first
> range
.second
)
13237 error (kind
== extract_bp_kind::bp
13238 ? _("Inverted breakpoint range at '%.*s'")
13239 : _("Inverted breakpoint location range at '%.*s'"),
13240 int (end
- start_first
), start_first
);
13244 /* bp_loc is a single value. */
13245 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
13246 range
.second
= range
.first
;
13251 /* Extract the breakpoint/location range specified by ARG. Returns
13252 the breakpoint range in BP_NUM_RANGE, and the location range in
13255 ARG may be in any of the following forms:
13257 x where 'x' is a breakpoint number.
13258 x-y where 'x' and 'y' specify a breakpoint numbers range.
13259 x.y where 'x' is a breakpoint number and 'y' a location number.
13260 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
13261 location number range.
13265 extract_bp_number_and_location (const std::string
&arg
,
13266 std::pair
<int, int> &bp_num_range
,
13267 std::pair
<int, int> &bp_loc_range
)
13269 std::string::size_type dot
= arg
.find ('.');
13271 if (dot
!= std::string::npos
)
13273 /* Handle 'x.y' and 'x.y-z' cases. */
13275 if (arg
.length () == dot
+ 1 || dot
== 0)
13276 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
13279 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
13280 bp_num_range
.second
= bp_num_range
.first
;
13282 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
13287 /* Handle x and x-y cases. */
13289 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
13290 bp_loc_range
.first
= 0;
13291 bp_loc_range
.second
= 0;
13295 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
13296 specifies whether to enable or disable. */
13299 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
13301 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
13304 if (loc
->disabled_by_cond
&& enable
)
13305 error (_("Breakpoint %d's condition is invalid at location %d, "
13306 "cannot enable."), bp_num
, loc_num
);
13308 if (loc
->enabled
!= enable
)
13310 loc
->enabled
= enable
;
13311 mark_breakpoint_location_modified (loc
);
13313 if (target_supports_enable_disable_tracepoint ()
13314 && current_trace_status ()->running
&& loc
->owner
13315 && is_tracepoint (loc
->owner
))
13316 target_disable_tracepoint (loc
);
13318 update_global_location_list (UGLL_DONT_INSERT
);
13320 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
13323 /* Calculates LOC_NUM for LOC by traversing the bp_location chain of LOC's
13324 owner. 1-based indexing. -1 signals NOT FOUND. */
13327 find_loc_num_by_location (const bp_location
*loc
)
13329 if (loc
!= nullptr && loc
->owner
!= nullptr)
13331 /* Locations use 1-based indexing. */
13333 for (bp_location
*it
: loc
->owner
->locations ())
13343 /* Enable or disable a breakpoint location LOC. ENABLE
13344 specifies whether to enable or disable. */
13347 enable_disable_bp_location (bp_location
*loc
, bool enable
)
13349 if (loc
== nullptr)
13350 error (_("Breakpoint location is invalid."));
13352 if (loc
->owner
== nullptr)
13353 error (_("Breakpoint location does not have an owner breakpoint."));
13355 if (loc
->disabled_by_cond
&& enable
)
13357 int loc_num
= find_loc_num_by_location (loc
);
13359 error (_("Breakpoint location LOC_NUM could not be found."));
13361 error (_("Breakpoint %d's condition is invalid at location %d, "
13362 "cannot enable."), loc
->owner
->number
, loc_num
);
13365 if (loc
->enabled
!= enable
)
13367 loc
->enabled
= enable
;
13368 mark_breakpoint_location_modified (loc
);
13371 if (target_supports_enable_disable_tracepoint ()
13372 && current_trace_status ()->running
&& loc
->owner
13373 && is_tracepoint (loc
->owner
))
13374 target_disable_tracepoint (loc
);
13376 update_global_location_list (UGLL_DONT_INSERT
);
13377 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
13380 /* Enable or disable a range of breakpoint locations. BP_NUM is the
13381 number of the breakpoint, and BP_LOC_RANGE specifies the
13382 (inclusive) range of location numbers of that breakpoint to
13383 enable/disable. ENABLE specifies whether to enable or disable the
13387 enable_disable_breakpoint_location_range (int bp_num
,
13388 std::pair
<int, int> &bp_loc_range
,
13391 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
13392 enable_disable_bp_num_loc (bp_num
, i
, enable
);
13395 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13396 If from_tty is nonzero, it prints a message to that effect,
13397 which ends with a period (no newline). */
13400 disable_breakpoint (struct breakpoint
*bpt
)
13402 /* Never disable a watchpoint scope breakpoint; we want to
13403 hit them when we leave scope so we can delete both the
13404 watchpoint and its scope breakpoint at that time. */
13405 if (bpt
->type
== bp_watchpoint_scope
)
13408 bpt
->enable_state
= bp_disabled
;
13410 /* Mark breakpoint locations modified. */
13411 mark_breakpoint_modified (bpt
);
13413 if (target_supports_enable_disable_tracepoint ()
13414 && current_trace_status ()->running
&& is_tracepoint (bpt
))
13416 for (bp_location
*location
: bpt
->locations ())
13417 target_disable_tracepoint (location
);
13420 update_global_location_list (UGLL_DONT_INSERT
);
13422 gdb::observers::breakpoint_modified
.notify (bpt
);
13425 /* Enable or disable the breakpoint(s) or breakpoint location(s)
13426 specified in ARGS. ARGS may be in any of the formats handled by
13427 extract_bp_number_and_location. ENABLE specifies whether to enable
13428 or disable the breakpoints/locations. */
13431 enable_disable_command (const char *args
, int from_tty
, bool enable
)
13435 for (breakpoint
*bpt
: all_breakpoints ())
13436 if (user_breakpoint_p (bpt
))
13439 enable_breakpoint (bpt
);
13441 disable_breakpoint (bpt
);
13446 std::string num
= extract_arg (&args
);
13448 while (!num
.empty ())
13450 std::pair
<int, int> bp_num_range
, bp_loc_range
;
13452 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
13454 if (bp_loc_range
.first
== bp_loc_range
.second
13455 && (bp_loc_range
.first
== 0
13456 || (bp_loc_range
.first
== 1
13457 && bp_num_range
.first
== bp_num_range
.second
13458 && !has_multiple_locations (bp_num_range
.first
))))
13460 /* Handle breakpoint ids with formats 'x' or 'x-z'
13461 or 'y.1' where y has only one code location. */
13462 map_breakpoint_number_range (bp_num_range
,
13464 ? enable_breakpoint
13465 : disable_breakpoint
);
13469 /* Handle breakpoint ids with formats 'x.y' or
13471 enable_disable_breakpoint_location_range
13472 (bp_num_range
.first
, bp_loc_range
, enable
);
13474 num
= extract_arg (&args
);
13479 /* The disable command disables the specified breakpoints/locations
13480 (or all defined breakpoints) so they're no longer effective in
13481 stopping the inferior. ARGS may be in any of the forms defined in
13482 extract_bp_number_and_location. */
13485 disable_command (const char *args
, int from_tty
)
13487 enable_disable_command (args
, from_tty
, false);
13491 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
13494 int target_resources_ok
;
13496 if (bpt
->type
== bp_hardware_breakpoint
)
13499 i
= hw_breakpoint_used_count ();
13500 target_resources_ok
=
13501 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
13503 if (target_resources_ok
== 0)
13504 error (_("No hardware breakpoint support in the target."));
13505 else if (target_resources_ok
< 0)
13506 error (_("Hardware breakpoints used exceeds limit."));
13509 if (is_watchpoint (bpt
))
13511 /* Initialize it just to avoid a GCC false warning. */
13512 enum enable_state orig_enable_state
= bp_disabled
;
13516 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
13518 orig_enable_state
= bpt
->enable_state
;
13519 bpt
->enable_state
= bp_enabled
;
13520 update_watchpoint (w
, true /* reparse */);
13522 catch (const gdb_exception
&e
)
13524 bpt
->enable_state
= orig_enable_state
;
13525 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
13531 bpt
->enable_state
= bp_enabled
;
13533 /* Mark breakpoint locations modified. */
13534 mark_breakpoint_modified (bpt
);
13536 if (target_supports_enable_disable_tracepoint ()
13537 && current_trace_status ()->running
&& is_tracepoint (bpt
))
13539 for (bp_location
*location
: bpt
->locations ())
13540 target_enable_tracepoint (location
);
13543 bpt
->disposition
= disposition
;
13544 bpt
->enable_count
= count
;
13545 update_global_location_list (UGLL_MAY_INSERT
);
13547 gdb::observers::breakpoint_modified
.notify (bpt
);
13552 enable_breakpoint (struct breakpoint
*bpt
)
13554 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
13557 /* The enable command enables the specified breakpoints/locations (or
13558 all defined breakpoints) so they once again become (or continue to
13559 be) effective in stopping the inferior. ARGS may be in any of the
13560 forms defined in extract_bp_number_and_location. */
13563 enable_command (const char *args
, int from_tty
)
13565 enable_disable_command (args
, from_tty
, true);
13569 enable_once_command (const char *args
, int from_tty
)
13571 map_breakpoint_numbers
13572 (args
, [&] (breakpoint
*b
)
13574 iterate_over_related_breakpoints
13575 (b
, [&] (breakpoint
*bpt
)
13577 enable_breakpoint_disp (bpt
, disp_disable
, 1);
13583 enable_count_command (const char *args
, int from_tty
)
13588 error_no_arg (_("hit count"));
13590 count
= get_number (&args
);
13592 map_breakpoint_numbers
13593 (args
, [&] (breakpoint
*b
)
13595 iterate_over_related_breakpoints
13596 (b
, [&] (breakpoint
*bpt
)
13598 enable_breakpoint_disp (bpt
, disp_disable
, count
);
13604 enable_delete_command (const char *args
, int from_tty
)
13606 map_breakpoint_numbers
13607 (args
, [&] (breakpoint
*b
)
13609 iterate_over_related_breakpoints
13610 (b
, [&] (breakpoint
*bpt
)
13612 enable_breakpoint_disp (bpt
, disp_del
, 1);
13617 /* Invalidate last known value of any hardware watchpoint if
13618 the memory which that value represents has been written to by
13622 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
13623 CORE_ADDR addr
, ssize_t len
,
13624 const bfd_byte
*data
)
13626 for (breakpoint
*bp
: all_breakpoints ())
13627 if (bp
->enable_state
== bp_enabled
13628 && bp
->type
== bp_hardware_watchpoint
)
13630 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
13632 if (wp
->val_valid
&& wp
->val
!= nullptr)
13634 for (bp_location
*loc
: bp
->locations ())
13635 if (loc
->loc_type
== bp_loc_hardware_watchpoint
13636 && loc
->address
+ loc
->length
> addr
13637 && addr
+ len
> loc
->address
)
13640 wp
->val_valid
= false;
13646 /* Create and insert a breakpoint for software single step. */
13649 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
13650 const address_space
*aspace
,
13653 struct thread_info
*tp
= inferior_thread ();
13654 struct symtab_and_line sal
;
13655 CORE_ADDR pc
= next_pc
;
13657 if (tp
->control
.single_step_breakpoints
== NULL
)
13659 std::unique_ptr
<breakpoint
> b
13660 (new momentary_breakpoint (gdbarch
, bp_single_step
,
13661 current_program_space
,
13665 tp
->control
.single_step_breakpoints
13666 = add_to_breakpoint_chain (std::move (b
));
13669 sal
= find_pc_line (pc
, 0);
13671 sal
.section
= find_pc_overlay (pc
);
13672 sal
.explicit_pc
= 1;
13675 = (gdb::checked_static_cast
<momentary_breakpoint
*>
13676 (tp
->control
.single_step_breakpoints
));
13677 ss_bp
->add_location (sal
);
13679 update_global_location_list (UGLL_INSERT
);
13682 /* Insert single step breakpoints according to the current state. */
13685 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
13687 struct regcache
*regcache
= get_current_regcache ();
13688 std::vector
<CORE_ADDR
> next_pcs
;
13690 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
13692 if (!next_pcs
.empty ())
13694 frame_info_ptr frame
= get_current_frame ();
13695 const address_space
*aspace
= get_frame_address_space (frame
);
13697 for (CORE_ADDR pc
: next_pcs
)
13698 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
13706 /* See breakpoint.h. */
13709 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
13710 const address_space
*aspace
,
13713 for (bp_location
*loc
: bp
->locations ())
13715 && breakpoint_location_address_match (loc
, aspace
, pc
))
13721 /* Check whether a software single-step breakpoint is inserted at
13725 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
13728 for (breakpoint
*bpt
: all_breakpoints ())
13730 if (bpt
->type
== bp_single_step
13731 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
13737 /* Tracepoint-specific operations. */
13739 /* Set tracepoint count to NUM. */
13741 set_tracepoint_count (int num
)
13743 tracepoint_count
= num
;
13744 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
13748 trace_command (const char *arg
, int from_tty
)
13750 location_spec_up locspec
= string_to_location_spec (&arg
,
13752 const struct breakpoint_ops
*ops
= breakpoint_ops_for_location_spec
13753 (locspec
.get (), true /* is_tracepoint */);
13755 create_breakpoint (get_current_arch (),
13757 NULL
, 0, arg
, false, 1 /* parse arg */,
13759 bp_tracepoint
/* type_wanted */,
13760 0 /* Ignore count */,
13761 pending_break_support
,
13765 0 /* internal */, 0);
13769 ftrace_command (const char *arg
, int from_tty
)
13771 location_spec_up locspec
= string_to_location_spec (&arg
,
13773 create_breakpoint (get_current_arch (),
13775 NULL
, 0, arg
, false, 1 /* parse arg */,
13777 bp_fast_tracepoint
/* type_wanted */,
13778 0 /* Ignore count */,
13779 pending_break_support
,
13780 &code_breakpoint_ops
,
13783 0 /* internal */, 0);
13786 /* strace command implementation. Creates a static tracepoint. */
13789 strace_command (const char *arg
, int from_tty
)
13791 const struct breakpoint_ops
*ops
;
13792 location_spec_up locspec
;
13795 /* Decide if we are dealing with a static tracepoint marker (`-m'),
13796 or with a normal static tracepoint. */
13797 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
13799 ops
= &strace_marker_breakpoint_ops
;
13800 locspec
= new_linespec_location_spec (&arg
,
13801 symbol_name_match_type::FULL
);
13802 type
= bp_static_marker_tracepoint
;
13806 ops
= &code_breakpoint_ops
;
13807 locspec
= string_to_location_spec (&arg
, current_language
);
13808 type
= bp_static_tracepoint
;
13811 create_breakpoint (get_current_arch (),
13813 NULL
, 0, arg
, false, 1 /* parse arg */,
13815 type
/* type_wanted */,
13816 0 /* Ignore count */,
13817 pending_break_support
,
13821 0 /* internal */, 0);
13824 /* Set up a fake reader function that gets command lines from a linked
13825 list that was acquired during tracepoint uploading. */
13827 static struct uploaded_tp
*this_utp
;
13828 static int next_cmd
;
13830 static const char *
13831 read_uploaded_action (std::string
&buffer
)
13833 char *rslt
= nullptr;
13835 if (next_cmd
< this_utp
->cmd_strings
.size ())
13837 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
13844 /* Given information about a tracepoint as recorded on a target (which
13845 can be either a live system or a trace file), attempt to create an
13846 equivalent GDB tracepoint. This is not a reliable process, since
13847 the target does not necessarily have all the information used when
13848 the tracepoint was originally defined. */
13850 struct tracepoint
*
13851 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
13853 const char *addr_str
;
13854 char small_buf
[100];
13855 struct tracepoint
*tp
;
13857 if (utp
->at_string
)
13858 addr_str
= utp
->at_string
.get ();
13861 /* In the absence of a source location, fall back to raw
13862 address. Since there is no way to confirm that the address
13863 means the same thing as when the trace was started, warn the
13865 warning (_("Uploaded tracepoint %d has no "
13866 "source location, using raw address"),
13868 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
13869 addr_str
= small_buf
;
13872 /* There's not much we can do with a sequence of bytecodes. */
13873 if (utp
->cond
&& !utp
->cond_string
)
13874 warning (_("Uploaded tracepoint %d condition "
13875 "has no source form, ignoring it"),
13878 location_spec_up locspec
= string_to_location_spec (&addr_str
,
13880 if (!create_breakpoint (get_current_arch (),
13882 utp
->cond_string
.get (), -1, addr_str
,
13883 false /* force_condition */,
13884 0 /* parse cond/thread */,
13886 utp
->type
/* type_wanted */,
13887 0 /* Ignore count */,
13888 pending_break_support
,
13889 &code_breakpoint_ops
,
13891 utp
->enabled
/* enabled */,
13893 CREATE_BREAKPOINT_FLAGS_INSERTED
))
13896 /* Get the tracepoint we just created. */
13897 tp
= get_tracepoint (tracepoint_count
);
13898 gdb_assert (tp
!= NULL
);
13902 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
13905 trace_pass_command (small_buf
, 0);
13908 /* If we have uploaded versions of the original commands, set up a
13909 special-purpose "reader" function and call the usual command line
13910 reader, then pass the result to the breakpoint command-setting
13912 if (!utp
->cmd_strings
.empty ())
13914 counted_command_line cmd_list
;
13919 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
13921 breakpoint_set_commands (tp
, std::move (cmd_list
));
13923 else if (!utp
->actions
.empty ()
13924 || !utp
->step_actions
.empty ())
13925 warning (_("Uploaded tracepoint %d actions "
13926 "have no source form, ignoring them"),
13929 /* Copy any status information that might be available. */
13930 tp
->hit_count
= utp
->hit_count
;
13931 tp
->traceframe_usage
= utp
->traceframe_usage
;
13936 /* Print information on tracepoint number TPNUM_EXP, or all if
13940 info_tracepoints_command (const char *args
, int from_tty
)
13942 struct ui_out
*uiout
= current_uiout
;
13945 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
13947 if (num_printed
== 0)
13949 if (args
== NULL
|| *args
== '\0')
13950 uiout
->message ("No tracepoints.\n");
13952 uiout
->message ("No tracepoint matching '%s'.\n", args
);
13955 default_collect_info ();
13958 /* The 'enable trace' command enables tracepoints.
13959 Not supported by all targets. */
13961 enable_trace_command (const char *args
, int from_tty
)
13963 enable_command (args
, from_tty
);
13966 /* The 'disable trace' command disables tracepoints.
13967 Not supported by all targets. */
13969 disable_trace_command (const char *args
, int from_tty
)
13971 disable_command (args
, from_tty
);
13974 /* Remove a tracepoint (or all if no argument). */
13976 delete_trace_command (const char *arg
, int from_tty
)
13982 int breaks_to_delete
= 0;
13984 /* Delete all breakpoints if no argument.
13985 Do not delete internal or call-dummy breakpoints, these
13986 have to be deleted with an explicit breakpoint number
13988 for (breakpoint
*tp
: all_tracepoints ())
13989 if (is_tracepoint (tp
) && user_breakpoint_p (tp
))
13991 breaks_to_delete
= 1;
13995 /* Ask user only if there are some breakpoints to delete. */
13997 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
13999 for (breakpoint
*b
: all_breakpoints_safe ())
14000 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14001 delete_breakpoint (b
);
14005 map_breakpoint_numbers
14006 (arg
, [&] (breakpoint
*br
)
14008 iterate_over_related_breakpoints (br
, delete_breakpoint
);
14012 /* Helper function for trace_pass_command. */
14015 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14017 tp
->pass_count
= count
;
14018 gdb::observers::breakpoint_modified
.notify (tp
);
14020 gdb_printf (_("Setting tracepoint %d's passcount to %d\n"),
14021 tp
->number
, count
);
14024 /* Set passcount for tracepoint.
14026 First command argument is passcount, second is tracepoint number.
14027 If tracepoint number omitted, apply to most recently defined.
14028 Also accepts special argument "all". */
14031 trace_pass_command (const char *args
, int from_tty
)
14033 struct tracepoint
*t1
;
14036 if (args
== 0 || *args
== 0)
14037 error (_("passcount command requires an "
14038 "argument (count + optional TP num)"));
14040 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14042 args
= skip_spaces (args
);
14043 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14045 args
+= 3; /* Skip special argument "all". */
14047 error (_("Junk at end of arguments."));
14049 for (breakpoint
*b
: all_tracepoints ())
14051 t1
= (struct tracepoint
*) b
;
14052 trace_pass_set_count (t1
, count
, from_tty
);
14055 else if (*args
== '\0')
14057 t1
= get_tracepoint_by_number (&args
, NULL
);
14059 trace_pass_set_count (t1
, count
, from_tty
);
14063 number_or_range_parser
parser (args
);
14064 while (!parser
.finished ())
14066 t1
= get_tracepoint_by_number (&args
, &parser
);
14068 trace_pass_set_count (t1
, count
, from_tty
);
14073 struct tracepoint
*
14074 get_tracepoint (int num
)
14076 for (breakpoint
*t
: all_tracepoints ())
14077 if (t
->number
== num
)
14078 return (struct tracepoint
*) t
;
14083 /* Find the tracepoint with the given target-side number (which may be
14084 different from the tracepoint number after disconnecting and
14087 struct tracepoint
*
14088 get_tracepoint_by_number_on_target (int num
)
14090 for (breakpoint
*b
: all_tracepoints ())
14092 struct tracepoint
*t
= (struct tracepoint
*) b
;
14094 if (t
->number_on_target
== num
)
14101 /* Utility: parse a tracepoint number and look it up in the list.
14102 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14103 If the argument is missing, the most recent tracepoint
14104 (tracepoint_count) is returned. */
14106 struct tracepoint
*
14107 get_tracepoint_by_number (const char **arg
,
14108 number_or_range_parser
*parser
)
14111 const char *instring
= arg
== NULL
? NULL
: *arg
;
14113 if (parser
!= NULL
)
14115 gdb_assert (!parser
->finished ());
14116 tpnum
= parser
->get_number ();
14118 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
14119 tpnum
= tracepoint_count
;
14121 tpnum
= get_number (arg
);
14125 if (instring
&& *instring
)
14126 gdb_printf (_("bad tracepoint number at or near '%s'\n"),
14129 gdb_printf (_("No previous tracepoint\n"));
14133 for (breakpoint
*t
: all_tracepoints ())
14134 if (t
->number
== tpnum
)
14135 return (struct tracepoint
*) t
;
14137 gdb_printf ("No tracepoint number %d.\n", tpnum
);
14142 breakpoint::print_recreate_thread (struct ui_file
*fp
) const
14145 gdb_printf (fp
, " thread %d", thread
);
14148 gdb_printf (fp
, " task %d", task
);
14150 gdb_printf (fp
, "\n");
14153 /* Save information on user settable breakpoints (watchpoints, etc) to
14154 a new script file named FILENAME. If FILTER is non-NULL, call it
14155 on each breakpoint and only include the ones for which it returns
14159 save_breakpoints (const char *filename
, int from_tty
,
14160 bool (*filter
) (const struct breakpoint
*))
14163 int extra_trace_bits
= 0;
14165 if (filename
== 0 || *filename
== 0)
14166 error (_("Argument required (file name in which to save)"));
14168 /* See if we have anything to save. */
14169 for (breakpoint
*tp
: all_breakpoints ())
14171 /* Skip internal and momentary breakpoints. */
14172 if (!user_breakpoint_p (tp
))
14175 /* If we have a filter, only save the breakpoints it accepts. */
14176 if (filter
&& !filter (tp
))
14181 if (is_tracepoint (tp
))
14183 extra_trace_bits
= 1;
14185 /* We can stop searching. */
14192 warning (_("Nothing to save."));
14196 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
14200 if (!fp
.open (expanded_filename
.get (), "w"))
14201 error (_("Unable to open file '%s' for saving (%s)"),
14202 expanded_filename
.get (), safe_strerror (errno
));
14204 if (extra_trace_bits
)
14205 save_trace_state_variables (&fp
);
14207 for (breakpoint
*tp
: all_breakpoints ())
14209 /* Skip internal and momentary breakpoints. */
14210 if (!user_breakpoint_p (tp
))
14213 /* If we have a filter, only save the breakpoints it accepts. */
14214 if (filter
&& !filter (tp
))
14217 tp
->print_recreate (&fp
);
14219 /* Note, we can't rely on tp->number for anything, as we can't
14220 assume the recreated breakpoint numbers will match. Use $bpnum
14223 if (tp
->cond_string
)
14224 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
.get ());
14226 if (tp
->ignore_count
)
14227 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
14229 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
14231 fp
.puts (" commands\n");
14233 ui_out_redirect_pop
redir (current_uiout
, &fp
);
14234 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
14236 fp
.puts (" end\n");
14239 if (tp
->enable_state
== bp_disabled
)
14240 fp
.puts ("disable $bpnum\n");
14242 /* If this is a multi-location breakpoint, check if the locations
14243 should be individually disabled. Watchpoint locations are
14244 special, and not user visible. */
14245 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
14249 for (bp_location
*loc
: tp
->locations ())
14252 fp
.printf ("disable $bpnum.%d\n", n
);
14259 if (extra_trace_bits
&& !default_collect
.empty ())
14260 fp
.printf ("set default-collect %s\n", default_collect
.c_str ());
14263 gdb_printf (_("Saved to file '%s'.\n"), expanded_filename
.get ());
14266 /* The `save breakpoints' command. */
14269 save_breakpoints_command (const char *args
, int from_tty
)
14271 save_breakpoints (args
, from_tty
, NULL
);
14274 /* The `save tracepoints' command. */
14277 save_tracepoints_command (const char *args
, int from_tty
)
14279 save_breakpoints (args
, from_tty
, is_tracepoint
);
14283 /* This help string is used to consolidate all the help string for specifying
14284 locations used by several commands. */
14286 #define LOCATION_SPEC_HELP_STRING \
14287 "Linespecs are colon-separated lists of location parameters, such as\n\
14288 source filename, function name, label name, and line number.\n\
14289 Example: To specify the start of a label named \"the_top\" in the\n\
14290 function \"fact\" in the file \"factorial.c\", use\n\
14291 \"factorial.c:fact:the_top\".\n\
14293 Address locations begin with \"*\" and specify an exact address in the\n\
14294 program. Example: To specify the fourth byte past the start function\n\
14295 \"main\", use \"*main + 4\".\n\
14297 Explicit locations are similar to linespecs but use an option/argument\n\
14298 syntax to specify location parameters.\n\
14299 Example: To specify the start of the label named \"the_top\" in the\n\
14300 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
14301 -function fact -label the_top\".\n\
14303 By default, a specified function is matched against the program's\n\
14304 functions in all scopes. For C++, this means in all namespaces and\n\
14305 classes. For Ada, this means in all packages. E.g., in C++,\n\
14306 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
14307 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
14308 specified name as a complete fully-qualified name instead."
14310 /* This help string is used for the break, hbreak, tbreak and thbreak
14311 commands. It is defined as a macro to prevent duplication.
14312 COMMAND should be a string constant containing the name of the
14315 #define BREAK_ARGS_HELP(command) \
14316 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM]\n\
14317 \t[-force-condition] [if CONDITION]\n\
14318 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
14319 probe point. Accepted values are `-probe' (for a generic, automatically\n\
14320 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
14321 `-probe-dtrace' (for a DTrace probe).\n\
14322 LOCATION may be a linespec, address, or explicit location as described\n\
14325 With no LOCATION, uses current execution address of the selected\n\
14326 stack frame. This is useful for breaking on return to a stack frame.\n\
14328 THREADNUM is the number from \"info threads\".\n\
14329 CONDITION is a boolean expression.\n\
14331 With the \"-force-condition\" flag, the condition is defined even when\n\
14332 it is invalid for all current locations.\n\
14333 \n" LOCATION_SPEC_HELP_STRING "\n\n\
14334 Multiple breakpoints at one place are permitted, and useful if their\n\
14335 conditions are different.\n\
14337 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
14339 /* List of subcommands for "catch". */
14340 static struct cmd_list_element
*catch_cmdlist
;
14342 /* List of subcommands for "tcatch". */
14343 static struct cmd_list_element
*tcatch_cmdlist
;
14346 add_catch_command (const char *name
, const char *docstring
,
14347 cmd_func_ftype
*func
,
14348 completer_ftype
*completer
,
14349 void *user_data_catch
,
14350 void *user_data_tcatch
)
14352 struct cmd_list_element
*command
;
14354 command
= add_cmd (name
, class_breakpoint
, docstring
,
14356 command
->func
= func
;
14357 command
->set_context (user_data_catch
);
14358 set_cmd_completer (command
, completer
);
14360 command
= add_cmd (name
, class_breakpoint
, docstring
,
14362 command
->func
= func
;
14363 command
->set_context (user_data_tcatch
);
14364 set_cmd_completer (command
, completer
);
14367 /* False if any of the breakpoint's locations could be a location where
14368 functions have been inlined, true otherwise. */
14371 is_non_inline_function (struct breakpoint
*b
)
14373 /* The shared library event breakpoint is set on the address of a
14374 non-inline function. */
14375 return (b
->type
== bp_shlib_event
);
14378 /* Nonzero if the specified PC cannot be a location where functions
14379 have been inlined. */
14382 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
14383 const target_waitstatus
&ws
)
14385 for (breakpoint
*b
: all_breakpoints ())
14387 if (!is_non_inline_function (b
))
14390 for (bp_location
*bl
: b
->locations ())
14392 if (!bl
->shlib_disabled
14393 && bpstat_check_location (bl
, aspace
, pc
, ws
))
14401 /* Remove any references to OBJFILE which is going to be freed. */
14404 breakpoint_free_objfile (struct objfile
*objfile
)
14406 for (bp_location
*loc
: all_bp_locations ())
14407 if (loc
->symtab
!= NULL
&& loc
->symtab
->compunit ()->objfile () == objfile
)
14408 loc
->symtab
= NULL
;
14411 /* Chain containing all defined "enable breakpoint" subcommands. */
14413 static struct cmd_list_element
*enablebreaklist
= NULL
;
14415 /* See breakpoint.h. */
14417 cmd_list_element
*commands_cmd_element
= nullptr;
14419 void _initialize_breakpoint ();
14421 _initialize_breakpoint ()
14423 struct cmd_list_element
*c
;
14425 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
,
14427 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
,
14429 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
,
14432 breakpoint_chain
= 0;
14433 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
14434 before a breakpoint is set. */
14435 breakpoint_count
= 0;
14437 tracepoint_count
= 0;
14439 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
14440 Set ignore-count of breakpoint number N to COUNT.\n\
14441 Usage is `ignore N COUNT'."));
14443 commands_cmd_element
= add_com ("commands", class_breakpoint
,
14444 commands_command
, _("\
14445 Set commands to be executed when the given breakpoints are hit.\n\
14446 Give a space-separated breakpoint list as argument after \"commands\".\n\
14447 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
14449 With no argument, the targeted breakpoint is the last one set.\n\
14450 The commands themselves follow starting on the next line.\n\
14451 Type a line containing \"end\" to indicate the end of them.\n\
14452 Give \"silent\" as the first line to make the breakpoint silent;\n\
14453 then no output is printed when it is hit, except what the commands print."));
14455 const auto cc_opts
= make_condition_command_options_def_group (nullptr);
14456 static std::string condition_command_help
14457 = gdb::option::build_help (_("\
14458 Specify breakpoint number N to break only if COND is true.\n\
14459 Usage is `condition [OPTION] N COND', where N is an integer and COND\n\
14460 is an expression to be evaluated whenever breakpoint N is reached.\n\
14463 %OPTIONS%"), cc_opts
);
14465 c
= add_com ("condition", class_breakpoint
, condition_command
,
14466 condition_command_help
.c_str ());
14467 set_cmd_completer_handle_brkchars (c
, condition_completer
);
14469 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
14470 Set a temporary breakpoint.\n\
14471 Like \"break\" except the breakpoint is only temporary,\n\
14472 so it will be deleted when hit. Equivalent to \"break\" followed\n\
14473 by using \"enable delete\" on the breakpoint number.\n\
14475 BREAK_ARGS_HELP ("tbreak")));
14476 set_cmd_completer (c
, location_completer
);
14478 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
14479 Set a hardware assisted breakpoint.\n\
14480 Like \"break\" except the breakpoint requires hardware support,\n\
14481 some target hardware may not have this support.\n\
14483 BREAK_ARGS_HELP ("hbreak")));
14484 set_cmd_completer (c
, location_completer
);
14486 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
14487 Set a temporary hardware assisted breakpoint.\n\
14488 Like \"hbreak\" except the breakpoint is only temporary,\n\
14489 so it will be deleted when hit.\n\
14491 BREAK_ARGS_HELP ("thbreak")));
14492 set_cmd_completer (c
, location_completer
);
14494 cmd_list_element
*enable_cmd
14495 = add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
14496 Enable all or some breakpoints.\n\
14497 Usage: enable [BREAKPOINTNUM]...\n\
14498 Give breakpoint numbers (separated by spaces) as arguments.\n\
14499 With no subcommand, breakpoints are enabled until you command otherwise.\n\
14500 This is used to cancel the effect of the \"disable\" command.\n\
14501 With a subcommand you can enable temporarily."),
14502 &enablelist
, 1, &cmdlist
);
14504 add_com_alias ("en", enable_cmd
, class_breakpoint
, 1);
14506 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
14507 Enable all or some breakpoints.\n\
14508 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
14509 Give breakpoint numbers (separated by spaces) as arguments.\n\
14510 This is used to cancel the effect of the \"disable\" command.\n\
14511 May be abbreviated to simply \"enable\"."),
14512 &enablebreaklist
, 1, &enablelist
);
14514 add_cmd ("once", no_class
, enable_once_command
, _("\
14515 Enable some breakpoints for one hit.\n\
14516 Usage: enable breakpoints once BREAKPOINTNUM...\n\
14517 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
14520 add_cmd ("delete", no_class
, enable_delete_command
, _("\
14521 Enable some breakpoints and delete when hit.\n\
14522 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
14523 If a breakpoint is hit while enabled in this fashion, it is deleted."),
14526 add_cmd ("count", no_class
, enable_count_command
, _("\
14527 Enable some breakpoints for COUNT hits.\n\
14528 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
14529 If a breakpoint is hit while enabled in this fashion,\n\
14530 the count is decremented; when it reaches zero, the breakpoint is disabled."),
14533 add_cmd ("delete", no_class
, enable_delete_command
, _("\
14534 Enable some breakpoints and delete when hit.\n\
14535 Usage: enable delete BREAKPOINTNUM...\n\
14536 If a breakpoint is hit while enabled in this fashion, it is deleted."),
14539 add_cmd ("once", no_class
, enable_once_command
, _("\
14540 Enable some breakpoints for one hit.\n\
14541 Usage: enable once BREAKPOINTNUM...\n\
14542 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
14545 add_cmd ("count", no_class
, enable_count_command
, _("\
14546 Enable some breakpoints for COUNT hits.\n\
14547 Usage: enable count COUNT BREAKPOINTNUM...\n\
14548 If a breakpoint is hit while enabled in this fashion,\n\
14549 the count is decremented; when it reaches zero, the breakpoint is disabled."),
14552 cmd_list_element
*disable_cmd
14553 = add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
14554 Disable all or some breakpoints.\n\
14555 Usage: disable [BREAKPOINTNUM]...\n\
14556 Arguments are breakpoint numbers with spaces in between.\n\
14557 To disable all breakpoints, give no argument.\n\
14558 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
14559 &disablelist
, 1, &cmdlist
);
14560 add_com_alias ("dis", disable_cmd
, class_breakpoint
, 1);
14561 add_com_alias ("disa", disable_cmd
, class_breakpoint
, 1);
14563 add_cmd ("breakpoints", class_breakpoint
, disable_command
, _("\
14564 Disable all or some breakpoints.\n\
14565 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
14566 Arguments are breakpoint numbers with spaces in between.\n\
14567 To disable all breakpoints, give no argument.\n\
14568 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
14569 This command may be abbreviated \"disable\"."),
14572 cmd_list_element
*delete_cmd
14573 = add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
14574 Delete all or some breakpoints.\n\
14575 Usage: delete [BREAKPOINTNUM]...\n\
14576 Arguments are breakpoint numbers with spaces in between.\n\
14577 To delete all breakpoints, give no argument.\n\
14579 Also a prefix command for deletion of other GDB objects."),
14580 &deletelist
, 1, &cmdlist
);
14581 add_com_alias ("d", delete_cmd
, class_breakpoint
, 1);
14582 add_com_alias ("del", delete_cmd
, class_breakpoint
, 1);
14584 add_cmd ("breakpoints", class_breakpoint
, delete_command
, _("\
14585 Delete all or some breakpoints or auto-display expressions.\n\
14586 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
14587 Arguments are breakpoint numbers with spaces in between.\n\
14588 To delete all breakpoints, give no argument.\n\
14589 This command may be abbreviated \"delete\"."),
14592 cmd_list_element
*clear_cmd
14593 = add_com ("clear", class_breakpoint
, clear_command
, _("\
14594 Clear breakpoint at specified location.\n\
14595 Argument may be a linespec, explicit, or address location as described below.\n\
14597 With no argument, clears all breakpoints in the line that the selected frame\n\
14598 is executing in.\n"
14599 "\n" LOCATION_SPEC_HELP_STRING
"\n\n\
14600 See also the \"delete\" command which clears breakpoints by number."));
14601 add_com_alias ("cl", clear_cmd
, class_breakpoint
, 1);
14603 cmd_list_element
*break_cmd
14604 = add_com ("break", class_breakpoint
, break_command
, _("\
14605 Set breakpoint at specified location.\n"
14606 BREAK_ARGS_HELP ("break")));
14607 set_cmd_completer (break_cmd
, location_completer
);
14609 add_com_alias ("b", break_cmd
, class_run
, 1);
14610 add_com_alias ("br", break_cmd
, class_run
, 1);
14611 add_com_alias ("bre", break_cmd
, class_run
, 1);
14612 add_com_alias ("brea", break_cmd
, class_run
, 1);
14614 cmd_list_element
*info_breakpoints_cmd
14615 = add_info ("breakpoints", info_breakpoints_command
, _("\
14616 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
14617 The \"Type\" column indicates one of:\n\
14618 \tbreakpoint - normal breakpoint\n\
14619 \twatchpoint - watchpoint\n\
14620 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14621 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14622 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14623 address and file/line number respectively.\n\
14625 Convenience variable \"$_\" and default examine address for \"x\"\n\
14626 are set to the address of the last breakpoint listed unless the command\n\
14627 is prefixed with \"server \".\n\n\
14628 Convenience variable \"$bpnum\" contains the number of the last\n\
14629 breakpoint set."));
14631 add_info_alias ("b", info_breakpoints_cmd
, 1);
14633 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
14634 Status of all breakpoints, or breakpoint number NUMBER.\n\
14635 The \"Type\" column indicates one of:\n\
14636 \tbreakpoint - normal breakpoint\n\
14637 \twatchpoint - watchpoint\n\
14638 \tlongjmp - internal breakpoint used to step through longjmp()\n\
14639 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
14640 \tuntil - internal breakpoint used by the \"until\" command\n\
14641 \tfinish - internal breakpoint used by the \"finish\" command\n\
14642 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
14643 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
14644 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
14645 address and file/line number respectively.\n\
14647 Convenience variable \"$_\" and default examine address for \"x\"\n\
14648 are set to the address of the last breakpoint listed unless the command\n\
14649 is prefixed with \"server \".\n\n\
14650 Convenience variable \"$bpnum\" contains the number of the last\n\
14652 &maintenanceinfolist
);
14654 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
14655 Set catchpoints to catch events."),
14657 0/*allow-unknown*/, &cmdlist
);
14659 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
14660 Set temporary catchpoints to catch events."),
14662 0/*allow-unknown*/, &cmdlist
);
14664 const auto opts
= make_watch_options_def_group (nullptr);
14666 static const std::string watch_help
= gdb::option::build_help (_("\
14667 Set a watchpoint for EXPRESSION.\n\
14668 Usage: watch [-location] EXPRESSION\n\
14673 A watchpoint stops execution of your program whenever the value of\n\
14674 an expression changes."), opts
);
14675 c
= add_com ("watch", class_breakpoint
, watch_command
,
14676 watch_help
.c_str ());
14677 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
14679 static const std::string rwatch_help
= gdb::option::build_help (_("\
14680 Set a read watchpoint for EXPRESSION.\n\
14681 Usage: rwatch [-location] EXPRESSION\n\
14686 A read watchpoint stops execution of your program whenever the value of\n\
14687 an expression is read."), opts
);
14688 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
,
14689 rwatch_help
.c_str ());
14690 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
14692 static const std::string awatch_help
= gdb::option::build_help (_("\
14693 Set an access watchpoint for EXPRESSION.\n\
14694 Usage: awatch [-location] EXPRESSION\n\
14699 An access watchpoint stops execution of your program whenever the value\n\
14700 of an expression is either read or written."), opts
);
14701 c
= add_com ("awatch", class_breakpoint
, awatch_command
,
14702 awatch_help
.c_str ());
14703 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
14705 add_info ("watchpoints", info_watchpoints_command
, _("\
14706 Status of specified watchpoints (all watchpoints if no argument)."));
14708 /* XXX: cagney/2005-02-23: This should be a boolean, and should
14709 respond to changes - contrary to the description. */
14710 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
14711 &can_use_hw_watchpoints
, _("\
14712 Set debugger's willingness to use watchpoint hardware."), _("\
14713 Show debugger's willingness to use watchpoint hardware."), _("\
14714 If zero, gdb will not use hardware for new watchpoints, even if\n\
14715 such is available. (However, any hardware watchpoints that were\n\
14716 created before setting this to nonzero, will continue to use watchpoint\n\
14719 show_can_use_hw_watchpoints
,
14720 &setlist
, &showlist
);
14722 can_use_hw_watchpoints
= 1;
14724 /* Tracepoint manipulation commands. */
14726 cmd_list_element
*trace_cmd
14727 = add_com ("trace", class_breakpoint
, trace_command
, _("\
14728 Set a tracepoint at specified location.\n\
14730 BREAK_ARGS_HELP ("trace") "\n\
14731 Do \"help tracepoints\" for info on other tracepoint commands."));
14732 set_cmd_completer (trace_cmd
, location_completer
);
14734 add_com_alias ("tp", trace_cmd
, class_breakpoint
, 0);
14735 add_com_alias ("tr", trace_cmd
, class_breakpoint
, 1);
14736 add_com_alias ("tra", trace_cmd
, class_breakpoint
, 1);
14737 add_com_alias ("trac", trace_cmd
, class_breakpoint
, 1);
14739 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
14740 Set a fast tracepoint at specified location.\n\
14742 BREAK_ARGS_HELP ("ftrace") "\n\
14743 Do \"help tracepoints\" for info on other tracepoint commands."));
14744 set_cmd_completer (c
, location_completer
);
14746 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
14747 Set a static tracepoint at location or marker.\n\
14749 strace [LOCATION] [if CONDITION]\n\
14750 LOCATION may be a linespec, explicit, or address location (described below) \n\
14751 or -m MARKER_ID.\n\n\
14752 If a marker id is specified, probe the marker with that name. With\n\
14753 no LOCATION, uses current execution address of the selected stack frame.\n\
14754 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
14755 This collects arbitrary user data passed in the probe point call to the\n\
14756 tracing library. You can inspect it when analyzing the trace buffer,\n\
14757 by printing the $_sdata variable like any other convenience variable.\n\
14759 CONDITION is a boolean expression.\n\
14760 \n" LOCATION_SPEC_HELP_STRING
"\n\n\
14761 Multiple tracepoints at one place are permitted, and useful if their\n\
14762 conditions are different.\n\
14764 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
14765 Do \"help tracepoints\" for info on other tracepoint commands."));
14766 set_cmd_completer (c
, location_completer
);
14768 cmd_list_element
*info_tracepoints_cmd
14769 = add_info ("tracepoints", info_tracepoints_command
, _("\
14770 Status of specified tracepoints (all tracepoints if no argument).\n\
14771 Convenience variable \"$tpnum\" contains the number of the\n\
14772 last tracepoint set."));
14774 add_info_alias ("tp", info_tracepoints_cmd
, 1);
14776 cmd_list_element
*delete_tracepoints_cmd
14777 = add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
14778 Delete specified tracepoints.\n\
14779 Arguments are tracepoint numbers, separated by spaces.\n\
14780 No argument means delete all tracepoints."),
14782 add_alias_cmd ("tr", delete_tracepoints_cmd
, class_trace
, 1, &deletelist
);
14784 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
14785 Disable specified tracepoints.\n\
14786 Arguments are tracepoint numbers, separated by spaces.\n\
14787 No argument means disable all tracepoints."),
14789 deprecate_cmd (c
, "disable");
14791 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
14792 Enable specified tracepoints.\n\
14793 Arguments are tracepoint numbers, separated by spaces.\n\
14794 No argument means enable all tracepoints."),
14796 deprecate_cmd (c
, "enable");
14798 add_com ("passcount", class_trace
, trace_pass_command
, _("\
14799 Set the passcount for a tracepoint.\n\
14800 The trace will end when the tracepoint has been passed 'count' times.\n\
14801 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
14802 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
14804 add_basic_prefix_cmd ("save", class_breakpoint
,
14805 _("Save breakpoint definitions as a script."),
14807 0/*allow-unknown*/, &cmdlist
);
14809 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
14810 Save current breakpoint definitions as a script.\n\
14811 This includes all types of breakpoints (breakpoints, watchpoints,\n\
14812 catchpoints, tracepoints). Use the 'source' command in another debug\n\
14813 session to restore them."),
14815 set_cmd_completer (c
, filename_completer
);
14817 cmd_list_element
*save_tracepoints_cmd
14818 = add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
14819 Save current tracepoint definitions as a script.\n\
14820 Use the 'source' command in another debug session to restore them."),
14822 set_cmd_completer (save_tracepoints_cmd
, filename_completer
);
14824 c
= add_com_alias ("save-tracepoints", save_tracepoints_cmd
, class_trace
, 0);
14825 deprecate_cmd (c
, "save tracepoints");
14827 add_setshow_prefix_cmd ("breakpoint", class_maintenance
,
14829 Breakpoint specific settings.\n\
14830 Configure various breakpoint-specific variables such as\n\
14831 pending breakpoint behavior."),
14833 Breakpoint specific settings.\n\
14834 Configure various breakpoint-specific variables such as\n\
14835 pending breakpoint behavior."),
14836 &breakpoint_set_cmdlist
, &breakpoint_show_cmdlist
,
14837 &setlist
, &showlist
);
14839 add_setshow_auto_boolean_cmd ("pending", no_class
,
14840 &pending_break_support
, _("\
14841 Set debugger's behavior regarding pending breakpoints."), _("\
14842 Show debugger's behavior regarding pending breakpoints."), _("\
14843 If on, an unrecognized breakpoint location will cause gdb to create a\n\
14844 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
14845 an error. If auto, an unrecognized breakpoint location results in a\n\
14846 user-query to see if a pending breakpoint should be created."),
14848 show_pending_break_support
,
14849 &breakpoint_set_cmdlist
,
14850 &breakpoint_show_cmdlist
);
14852 pending_break_support
= AUTO_BOOLEAN_AUTO
;
14854 add_setshow_boolean_cmd ("auto-hw", no_class
,
14855 &automatic_hardware_breakpoints
, _("\
14856 Set automatic usage of hardware breakpoints."), _("\
14857 Show automatic usage of hardware breakpoints."), _("\
14858 If set, the debugger will automatically use hardware breakpoints for\n\
14859 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
14860 a warning will be emitted for such breakpoints."),
14862 show_automatic_hardware_breakpoints
,
14863 &breakpoint_set_cmdlist
,
14864 &breakpoint_show_cmdlist
);
14866 add_setshow_boolean_cmd ("always-inserted", class_support
,
14867 &always_inserted_mode
, _("\
14868 Set mode for inserting breakpoints."), _("\
14869 Show mode for inserting breakpoints."), _("\
14870 When this mode is on, breakpoints are inserted immediately as soon as\n\
14871 they're created, kept inserted even when execution stops, and removed\n\
14872 only when the user deletes them. When this mode is off (the default),\n\
14873 breakpoints are inserted only when execution continues, and removed\n\
14874 when execution stops."),
14876 &show_always_inserted_mode
,
14877 &breakpoint_set_cmdlist
,
14878 &breakpoint_show_cmdlist
);
14880 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
14881 condition_evaluation_enums
,
14882 &condition_evaluation_mode_1
, _("\
14883 Set mode of breakpoint condition evaluation."), _("\
14884 Show mode of breakpoint condition evaluation."), _("\
14885 When this is set to \"host\", breakpoint conditions will be\n\
14886 evaluated on the host's side by GDB. When it is set to \"target\",\n\
14887 breakpoint conditions will be downloaded to the target (if the target\n\
14888 supports such feature) and conditions will be evaluated on the target's side.\n\
14889 If this is set to \"auto\" (default), this will be automatically set to\n\
14890 \"target\" if it supports condition evaluation, otherwise it will\n\
14891 be set to \"host\"."),
14892 &set_condition_evaluation_mode
,
14893 &show_condition_evaluation_mode
,
14894 &breakpoint_set_cmdlist
,
14895 &breakpoint_show_cmdlist
);
14897 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
14898 Set a breakpoint for an address range.\n\
14899 break-range START-LOCATION, END-LOCATION\n\
14900 where START-LOCATION and END-LOCATION can be one of the following:\n\
14901 LINENUM, for that line in the current file,\n\
14902 FILE:LINENUM, for that line in that file,\n\
14903 +OFFSET, for that number of lines after the current line\n\
14904 or the start of the range\n\
14905 FUNCTION, for the first line in that function,\n\
14906 FILE:FUNCTION, to distinguish among like-named static functions.\n\
14907 *ADDRESS, for the instruction at that address.\n\
14909 The breakpoint will stop execution of the inferior whenever it executes\n\
14910 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
14911 range (including START-LOCATION and END-LOCATION)."));
14913 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
14914 Set a dynamic printf at specified location.\n\
14915 dprintf location,format string,arg1,arg2,...\n\
14916 location may be a linespec, explicit, or address location.\n"
14917 "\n" LOCATION_SPEC_HELP_STRING
));
14918 set_cmd_completer (c
, location_completer
);
14920 add_setshow_enum_cmd ("dprintf-style", class_support
,
14921 dprintf_style_enums
, &dprintf_style
, _("\
14922 Set the style of usage for dynamic printf."), _("\
14923 Show the style of usage for dynamic printf."), _("\
14924 This setting chooses how GDB will do a dynamic printf.\n\
14925 If the value is \"gdb\", then the printing is done by GDB to its own\n\
14926 console, as with the \"printf\" command.\n\
14927 If the value is \"call\", the print is done by calling a function in your\n\
14928 program; by default printf(), but you can choose a different function or\n\
14929 output stream by setting dprintf-function and dprintf-channel."),
14930 update_dprintf_commands
, NULL
,
14931 &setlist
, &showlist
);
14933 add_setshow_string_cmd ("dprintf-function", class_support
,
14934 &dprintf_function
, _("\
14935 Set the function to use for dynamic printf."), _("\
14936 Show the function to use for dynamic printf."), NULL
,
14937 update_dprintf_commands
, NULL
,
14938 &setlist
, &showlist
);
14940 add_setshow_string_cmd ("dprintf-channel", class_support
,
14941 &dprintf_channel
, _("\
14942 Set the channel to use for dynamic printf."), _("\
14943 Show the channel to use for dynamic printf."), NULL
,
14944 update_dprintf_commands
, NULL
,
14945 &setlist
, &showlist
);
14947 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
14948 &disconnected_dprintf
, _("\
14949 Set whether dprintf continues after GDB disconnects."), _("\
14950 Show whether dprintf continues after GDB disconnects."), _("\
14951 Use this to let dprintf commands continue to hit and produce output\n\
14952 even if GDB disconnects or detaches from the target."),
14955 &setlist
, &showlist
);
14957 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
14958 Target agent only formatted printing, like the C \"printf\" function.\n\
14959 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
14960 This supports most C printf format specifications, like %s, %d, etc.\n\
14961 This is useful for formatted output in user-defined commands."));
14963 automatic_hardware_breakpoints
= true;
14965 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
,
14967 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
,