1 /* Everything about breakpoints, for GDB.
3 Copyright (C) 1986-2021 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 "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"
71 /* readline include files */
72 #include "readline/tilde.h"
74 /* readline defines this. */
77 #include "mi/mi-common.h"
78 #include "extension.h"
80 #include "progspace-and-thread.h"
81 #include "gdbsupport/array-view.h"
82 #include "gdbsupport/gdb_optional.h"
84 /* Prototypes for local functions. */
86 static void map_breakpoint_numbers (const char *,
87 gdb::function_view
<void (breakpoint
*)>);
89 static void breakpoint_re_set_default (struct breakpoint
*);
92 create_sals_from_location_default (struct event_location
*location
,
93 struct linespec_result
*canonical
,
94 enum bptype type_wanted
);
96 static void create_breakpoints_sal_default (struct gdbarch
*,
97 struct linespec_result
*,
98 gdb::unique_xmalloc_ptr
<char>,
99 gdb::unique_xmalloc_ptr
<char>,
101 enum bpdisp
, int, int,
103 const struct breakpoint_ops
*,
104 int, int, int, unsigned);
106 static std::vector
<symtab_and_line
> decode_location_default
107 (struct breakpoint
*b
, struct event_location
*location
,
108 struct program_space
*search_pspace
);
110 static int can_use_hardware_watchpoint
111 (const std::vector
<value_ref_ptr
> &vals
);
113 static void mention (struct breakpoint
*);
115 static struct breakpoint
*set_raw_breakpoint_without_location (struct gdbarch
*,
117 const struct breakpoint_ops
*);
118 static struct bp_location
*add_location_to_breakpoint (struct breakpoint
*,
119 const struct symtab_and_line
*);
121 /* This function is used in gdbtk sources and thus can not be made
123 struct breakpoint
*set_raw_breakpoint (struct gdbarch
*gdbarch
,
124 struct symtab_and_line
,
126 const struct breakpoint_ops
*);
128 static struct breakpoint
*
129 momentary_breakpoint_from_master (struct breakpoint
*orig
,
131 const struct breakpoint_ops
*ops
,
134 static void breakpoint_adjustment_warning (CORE_ADDR
, CORE_ADDR
, int, int);
136 static CORE_ADDR
adjust_breakpoint_address (struct gdbarch
*gdbarch
,
140 static void describe_other_breakpoints (struct gdbarch
*,
141 struct program_space
*, CORE_ADDR
,
142 struct obj_section
*, int);
144 static int watchpoint_locations_match (struct bp_location
*loc1
,
145 struct bp_location
*loc2
);
147 static int breakpoint_locations_match (struct bp_location
*loc1
,
148 struct bp_location
*loc2
,
149 bool sw_hw_bps_match
= false);
151 static int breakpoint_location_address_match (struct bp_location
*bl
,
152 const struct address_space
*aspace
,
155 static int breakpoint_location_address_range_overlap (struct bp_location
*,
156 const address_space
*,
159 static int remove_breakpoint (struct bp_location
*);
160 static int remove_breakpoint_1 (struct bp_location
*, enum remove_bp_reason
);
162 static enum print_stop_action
print_bp_stop_message (bpstat bs
);
164 static int hw_breakpoint_used_count (void);
166 static int hw_watchpoint_use_count (struct breakpoint
*);
168 static int hw_watchpoint_used_count_others (struct breakpoint
*except
,
170 int *other_type_used
);
172 static void enable_breakpoint_disp (struct breakpoint
*, enum bpdisp
,
175 static void decref_bp_location (struct bp_location
**loc
);
177 static struct bp_location
*allocate_bp_location (struct breakpoint
*bpt
);
179 /* update_global_location_list's modes of operation wrt to whether to
180 insert locations now. */
181 enum ugll_insert_mode
183 /* Don't insert any breakpoint locations into the inferior, only
184 remove already-inserted locations that no longer should be
185 inserted. Functions that delete a breakpoint or breakpoints
186 should specify this mode, so that deleting a breakpoint doesn't
187 have the side effect of inserting the locations of other
188 breakpoints that are marked not-inserted, but should_be_inserted
189 returns true on them.
191 This behavior is useful is situations close to tear-down -- e.g.,
192 after an exec, while the target still has execution, but
193 breakpoint shadows of the previous executable image should *NOT*
194 be restored to the new image; or before detaching, where the
195 target still has execution and wants to delete breakpoints from
196 GDB's lists, and all breakpoints had already been removed from
200 /* May insert breakpoints iff breakpoints_should_be_inserted_now
201 claims breakpoints should be inserted now. */
204 /* Insert locations now, irrespective of
205 breakpoints_should_be_inserted_now. E.g., say all threads are
206 stopped right now, and the user did "continue". We need to
207 insert breakpoints _before_ resuming the target, but
208 UGLL_MAY_INSERT wouldn't insert them, because
209 breakpoints_should_be_inserted_now returns false at that point,
210 as no thread is running yet. */
214 static void update_global_location_list (enum ugll_insert_mode
);
216 static void update_global_location_list_nothrow (enum ugll_insert_mode
);
218 static void insert_breakpoint_locations (void);
220 static void trace_pass_command (const char *, int);
222 static void set_tracepoint_count (int num
);
224 static bool is_masked_watchpoint (const struct breakpoint
*b
);
226 /* Return 1 if B refers to a static tracepoint set by marker ("-m"), zero
229 static int strace_marker_p (struct breakpoint
*b
);
231 /* The breakpoint_ops structure to be inherited by all breakpoint_ops
232 that are implemented on top of software or hardware breakpoints
233 (user breakpoints, internal and momentary breakpoints, etc.). */
234 static struct breakpoint_ops bkpt_base_breakpoint_ops
;
236 /* Internal breakpoints class type. */
237 static struct breakpoint_ops internal_breakpoint_ops
;
239 /* Momentary breakpoints class type. */
240 static struct breakpoint_ops momentary_breakpoint_ops
;
242 /* The breakpoint_ops structure to be used in regular user created
244 struct breakpoint_ops bkpt_breakpoint_ops
;
246 /* Breakpoints set on probes. */
247 static struct breakpoint_ops bkpt_probe_breakpoint_ops
;
249 /* Tracepoints set on probes. */
250 static struct breakpoint_ops tracepoint_probe_breakpoint_ops
;
252 /* Dynamic printf class type. */
253 struct breakpoint_ops dprintf_breakpoint_ops
;
255 /* The style in which to perform a dynamic printf. This is a user
256 option because different output options have different tradeoffs;
257 if GDB does the printing, there is better error handling if there
258 is a problem with any of the arguments, but using an inferior
259 function lets you have special-purpose printers and sending of
260 output to the same place as compiled-in print functions. */
262 static const char dprintf_style_gdb
[] = "gdb";
263 static const char dprintf_style_call
[] = "call";
264 static const char dprintf_style_agent
[] = "agent";
265 static const char *const dprintf_style_enums
[] = {
271 static const char *dprintf_style
= dprintf_style_gdb
;
273 /* The function to use for dynamic printf if the preferred style is to
274 call into the inferior. The value is simply a string that is
275 copied into the command, so it can be anything that GDB can
276 evaluate to a callable address, not necessarily a function name. */
278 static char *dprintf_function
;
280 /* The channel to use for dynamic printf if the preferred style is to
281 call into the inferior; if a nonempty string, it will be passed to
282 the call as the first argument, with the format string as the
283 second. As with the dprintf function, this can be anything that
284 GDB knows how to evaluate, so in addition to common choices like
285 "stderr", this could be an app-specific expression like
286 "mystreams[curlogger]". */
288 static char *dprintf_channel
;
290 /* True if dprintf commands should continue to operate even if GDB
292 static bool disconnected_dprintf
= true;
294 struct command_line
*
295 breakpoint_commands (struct breakpoint
*b
)
297 return b
->commands
? b
->commands
.get () : NULL
;
300 /* Flag indicating that a command has proceeded the inferior past the
301 current breakpoint. */
303 static bool breakpoint_proceeded
;
306 bpdisp_text (enum bpdisp disp
)
308 /* NOTE: the following values are a part of MI protocol and
309 represent values of 'disp' field returned when inferior stops at
311 static const char * const bpdisps
[] = {"del", "dstp", "dis", "keep"};
313 return bpdisps
[(int) disp
];
316 /* Prototypes for exported functions. */
317 /* If FALSE, gdb will not use hardware support for watchpoints, even
318 if such is available. */
319 static int can_use_hw_watchpoints
;
322 show_can_use_hw_watchpoints (struct ui_file
*file
, int from_tty
,
323 struct cmd_list_element
*c
,
326 fprintf_filtered (file
,
327 _("Debugger's willingness to use "
328 "watchpoint hardware is %s.\n"),
332 /* If AUTO_BOOLEAN_FALSE, gdb will not attempt to create pending breakpoints.
333 If AUTO_BOOLEAN_TRUE, gdb will automatically create pending breakpoints
334 for unrecognized breakpoint locations.
335 If AUTO_BOOLEAN_AUTO, gdb will query when breakpoints are unrecognized. */
336 static enum auto_boolean pending_break_support
;
338 show_pending_break_support (struct ui_file
*file
, int from_tty
,
339 struct cmd_list_element
*c
,
342 fprintf_filtered (file
,
343 _("Debugger's behavior regarding "
344 "pending breakpoints is %s.\n"),
348 /* If true, gdb will automatically use hardware breakpoints for breakpoints
349 set with "break" but falling in read-only memory.
350 If false, gdb will warn about such breakpoints, but won't automatically
351 use hardware breakpoints. */
352 static bool automatic_hardware_breakpoints
;
354 show_automatic_hardware_breakpoints (struct ui_file
*file
, int from_tty
,
355 struct cmd_list_element
*c
,
358 fprintf_filtered (file
,
359 _("Automatic usage of hardware breakpoints is %s.\n"),
363 /* If on, GDB keeps breakpoints inserted even if the inferior is
364 stopped, and immediately inserts any new breakpoints as soon as
365 they're created. If off (default), GDB keeps breakpoints off of
366 the target as long as possible. That is, it delays inserting
367 breakpoints until the next resume, and removes them again when the
368 target fully stops. This is a bit safer in case GDB crashes while
369 processing user input. */
370 static bool always_inserted_mode
= false;
373 show_always_inserted_mode (struct ui_file
*file
, int from_tty
,
374 struct cmd_list_element
*c
, const char *value
)
376 fprintf_filtered (file
, _("Always inserted breakpoint mode is %s.\n"),
380 /* See breakpoint.h. */
383 breakpoints_should_be_inserted_now (void)
385 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
387 /* If breakpoints are global, they should be inserted even if no
388 thread under gdb's control is running, or even if there are
389 no threads under GDB's control yet. */
394 if (always_inserted_mode
)
396 /* The user wants breakpoints inserted even if all threads
401 for (inferior
*inf
: all_inferiors ())
402 if (inf
->has_execution ()
403 && threads_are_executing (inf
->process_target ()))
406 /* Don't remove breakpoints yet if, even though all threads are
407 stopped, we still have events to process. */
408 for (thread_info
*tp
: all_non_exited_threads ())
410 && tp
->suspend
.waitstatus_pending_p
)
416 static const char condition_evaluation_both
[] = "host or target";
418 /* Modes for breakpoint condition evaluation. */
419 static const char condition_evaluation_auto
[] = "auto";
420 static const char condition_evaluation_host
[] = "host";
421 static const char condition_evaluation_target
[] = "target";
422 static const char *const condition_evaluation_enums
[] = {
423 condition_evaluation_auto
,
424 condition_evaluation_host
,
425 condition_evaluation_target
,
429 /* Global that holds the current mode for breakpoint condition evaluation. */
430 static const char *condition_evaluation_mode_1
= condition_evaluation_auto
;
432 /* Global that we use to display information to the user (gets its value from
433 condition_evaluation_mode_1. */
434 static const char *condition_evaluation_mode
= condition_evaluation_auto
;
436 /* Translate a condition evaluation mode MODE into either "host"
437 or "target". This is used mostly to translate from "auto" to the
438 real setting that is being used. It returns the translated
442 translate_condition_evaluation_mode (const char *mode
)
444 if (mode
== condition_evaluation_auto
)
446 if (target_supports_evaluation_of_breakpoint_conditions ())
447 return condition_evaluation_target
;
449 return condition_evaluation_host
;
455 /* Discovers what condition_evaluation_auto translates to. */
458 breakpoint_condition_evaluation_mode (void)
460 return translate_condition_evaluation_mode (condition_evaluation_mode
);
463 /* Return true if GDB should evaluate breakpoint conditions or false
467 gdb_evaluates_breakpoint_condition_p (void)
469 const char *mode
= breakpoint_condition_evaluation_mode ();
471 return (mode
== condition_evaluation_host
);
474 /* Are we executing breakpoint commands? */
475 static int executing_breakpoint_commands
;
477 /* Are overlay event breakpoints enabled? */
478 static int overlay_events_enabled
;
480 /* See description in breakpoint.h. */
481 bool target_exact_watchpoints
= false;
483 /* Walk the following statement or block through all breakpoints.
484 ALL_BREAKPOINTS_SAFE does so even if the statement deletes the
485 current breakpoint. */
487 #define ALL_BREAKPOINTS_SAFE(B,TMP) \
488 for (B = breakpoint_chain; \
489 B ? (TMP=B->next, 1): 0; \
492 /* Chains of all breakpoints defined. */
494 static struct breakpoint
*breakpoint_chain
;
496 /* See breakpoint.h. */
501 return breakpoint_range (breakpoint_chain
);
504 /* See breakpoint.h. */
506 breakpoint_safe_range
507 all_breakpoints_safe ()
509 return breakpoint_safe_range (all_breakpoints ());
512 /* See breakpoint.h. */
517 return tracepoint_range (breakpoint_chain
);
520 /* Array is sorted by bp_location_is_less_than - primarily by the ADDRESS. */
522 static std::vector
<bp_location
*> bp_locations
;
524 /* See breakpoint.h. */
526 const std::vector
<bp_location
*> &
532 /* Range to iterate over breakpoint locations at a given address. */
534 struct bp_locations_at_addr_range
536 using iterator
= std::vector
<bp_location
*>::iterator
;
538 bp_locations_at_addr_range (CORE_ADDR addr
)
542 bool operator() (const bp_location
*loc
, CORE_ADDR addr_
) const
543 { return loc
->address
< addr_
; }
545 bool operator() (CORE_ADDR addr_
, const bp_location
*loc
) const
546 { return addr_
< loc
->address
; }
549 auto it_pair
= std::equal_range (bp_locations
.begin (), bp_locations
.end (),
552 m_begin
= it_pair
.first
;
553 m_end
= it_pair
.second
;
556 iterator
begin () const
559 iterator
end () const
567 /* Return a range to iterate over all breakpoint locations exactly at address
570 If it's needed to iterate multiple times on the same range, it's possible
571 to save the range in a local variable and use it multiple times:
573 auto range = all_bp_locations_at_addr (addr);
575 for (bp_location *loc : range)
578 for (bp_location *loc : range)
581 This saves a bit of time, as it avoids re-doing the binary searches to find
582 the range's boundaries. Just remember not to change the bp_locations vector
583 in the mean time, as it could make the range's iterators stale. */
585 static bp_locations_at_addr_range
586 all_bp_locations_at_addr (CORE_ADDR addr
)
588 return bp_locations_at_addr_range (addr
);
591 /* Maximum alignment offset between bp_target_info.PLACED_ADDRESS and
592 ADDRESS for the current elements of BP_LOCATIONS which get a valid
593 result from bp_location_has_shadow. You can use it for roughly
594 limiting the subrange of BP_LOCATIONS to scan for shadow bytes for
595 an address you need to read. */
597 static CORE_ADDR bp_locations_placed_address_before_address_max
;
599 /* Maximum offset plus alignment between bp_target_info.PLACED_ADDRESS
600 + bp_target_info.SHADOW_LEN and ADDRESS for the current elements of
601 BP_LOCATIONS which get a valid result from bp_location_has_shadow.
602 You can use it for roughly limiting the subrange of BP_LOCATIONS to
603 scan for shadow bytes for an address you need to read. */
605 static CORE_ADDR bp_locations_shadow_len_after_address_max
;
607 /* The locations that no longer correspond to any breakpoint, unlinked
608 from the bp_locations array, but for which a hit may still be
609 reported by a target. */
610 static std::vector
<bp_location
*> moribund_locations
;
612 /* Number of last breakpoint made. */
614 static int breakpoint_count
;
616 /* The value of `breakpoint_count' before the last command that
617 created breakpoints. If the last (break-like) command created more
618 than one breakpoint, then the difference between BREAKPOINT_COUNT
619 and PREV_BREAKPOINT_COUNT is more than one. */
620 static int prev_breakpoint_count
;
622 /* Number of last tracepoint made. */
624 static int tracepoint_count
;
626 static struct cmd_list_element
*breakpoint_set_cmdlist
;
627 static struct cmd_list_element
*breakpoint_show_cmdlist
;
628 struct cmd_list_element
*save_cmdlist
;
630 /* See declaration at breakpoint.h. */
633 breakpoint_find_if (int (*func
) (struct breakpoint
*b
, void *d
),
636 for (breakpoint
*b
: all_breakpoints ())
637 if (func (b
, user_data
) != 0)
643 /* Return whether a breakpoint is an active enabled breakpoint. */
645 breakpoint_enabled (struct breakpoint
*b
)
647 return (b
->enable_state
== bp_enabled
);
650 /* Set breakpoint count to NUM. */
653 set_breakpoint_count (int num
)
655 prev_breakpoint_count
= breakpoint_count
;
656 breakpoint_count
= num
;
657 set_internalvar_integer (lookup_internalvar ("bpnum"), num
);
660 /* Used by `start_rbreak_breakpoints' below, to record the current
661 breakpoint count before "rbreak" creates any breakpoint. */
662 static int rbreak_start_breakpoint_count
;
664 /* Called at the start an "rbreak" command to record the first
667 scoped_rbreak_breakpoints::scoped_rbreak_breakpoints ()
669 rbreak_start_breakpoint_count
= breakpoint_count
;
672 /* Called at the end of an "rbreak" command to record the last
675 scoped_rbreak_breakpoints::~scoped_rbreak_breakpoints ()
677 prev_breakpoint_count
= rbreak_start_breakpoint_count
;
680 /* Used in run_command to zero the hit count when a new run starts. */
683 clear_breakpoint_hit_counts (void)
685 for (breakpoint
*b
: all_breakpoints ())
690 /* Return the breakpoint with the specified number, or NULL
691 if the number does not refer to an existing breakpoint. */
694 get_breakpoint (int num
)
696 for (breakpoint
*b
: all_breakpoints ())
697 if (b
->number
== num
)
705 /* Mark locations as "conditions have changed" in case the target supports
706 evaluating conditions on its side. */
709 mark_breakpoint_modified (struct breakpoint
*b
)
711 /* This is only meaningful if the target is
712 evaluating conditions and if the user has
713 opted for condition evaluation on the target's
715 if (gdb_evaluates_breakpoint_condition_p ()
716 || !target_supports_evaluation_of_breakpoint_conditions ())
719 if (!is_breakpoint (b
))
722 for (bp_location
*loc
: b
->locations ())
723 loc
->condition_changed
= condition_modified
;
726 /* Mark location as "conditions have changed" in case the target supports
727 evaluating conditions on its side. */
730 mark_breakpoint_location_modified (struct bp_location
*loc
)
732 /* This is only meaningful if the target is
733 evaluating conditions and if the user has
734 opted for condition evaluation on the target's
736 if (gdb_evaluates_breakpoint_condition_p ()
737 || !target_supports_evaluation_of_breakpoint_conditions ())
741 if (!is_breakpoint (loc
->owner
))
744 loc
->condition_changed
= condition_modified
;
747 /* Sets the condition-evaluation mode using the static global
748 condition_evaluation_mode. */
751 set_condition_evaluation_mode (const char *args
, int from_tty
,
752 struct cmd_list_element
*c
)
754 const char *old_mode
, *new_mode
;
756 if ((condition_evaluation_mode_1
== condition_evaluation_target
)
757 && !target_supports_evaluation_of_breakpoint_conditions ())
759 condition_evaluation_mode_1
= condition_evaluation_mode
;
760 warning (_("Target does not support breakpoint condition evaluation.\n"
761 "Using host evaluation mode instead."));
765 new_mode
= translate_condition_evaluation_mode (condition_evaluation_mode_1
);
766 old_mode
= translate_condition_evaluation_mode (condition_evaluation_mode
);
768 /* Flip the switch. Flip it even if OLD_MODE == NEW_MODE as one of the
769 settings was "auto". */
770 condition_evaluation_mode
= condition_evaluation_mode_1
;
772 /* Only update the mode if the user picked a different one. */
773 if (new_mode
!= old_mode
)
775 /* If the user switched to a different evaluation mode, we
776 need to synch the changes with the target as follows:
778 "host" -> "target": Send all (valid) conditions to the target.
779 "target" -> "host": Remove all the conditions from the target.
782 if (new_mode
== condition_evaluation_target
)
784 /* Mark everything modified and synch conditions with the
786 for (bp_location
*loc
: all_bp_locations ())
787 mark_breakpoint_location_modified (loc
);
791 /* Manually mark non-duplicate locations to synch conditions
792 with the target. We do this to remove all the conditions the
793 target knows about. */
794 for (bp_location
*loc
: all_bp_locations ())
795 if (is_breakpoint (loc
->owner
) && loc
->inserted
)
796 loc
->needs_update
= 1;
800 update_global_location_list (UGLL_MAY_INSERT
);
806 /* Shows the current mode of breakpoint condition evaluation. Explicitly shows
807 what "auto" is translating to. */
810 show_condition_evaluation_mode (struct ui_file
*file
, int from_tty
,
811 struct cmd_list_element
*c
, const char *value
)
813 if (condition_evaluation_mode
== condition_evaluation_auto
)
814 fprintf_filtered (file
,
815 _("Breakpoint condition evaluation "
816 "mode is %s (currently %s).\n"),
818 breakpoint_condition_evaluation_mode ());
820 fprintf_filtered (file
, _("Breakpoint condition evaluation mode is %s.\n"),
824 /* Parse COND_STRING in the context of LOC and set as the condition
825 expression of LOC. BP_NUM is the number of LOC's owner, LOC_NUM is
826 the number of LOC within its owner. In case of parsing error, mark
827 LOC as DISABLED_BY_COND. In case of success, unset DISABLED_BY_COND. */
830 set_breakpoint_location_condition (const char *cond_string
, bp_location
*loc
,
831 int bp_num
, int loc_num
)
833 bool has_junk
= false;
836 expression_up new_exp
= parse_exp_1 (&cond_string
, loc
->address
,
837 block_for_pc (loc
->address
), 0);
838 if (*cond_string
!= 0)
842 loc
->cond
= std::move (new_exp
);
843 if (loc
->disabled_by_cond
&& loc
->enabled
)
844 printf_filtered (_("Breakpoint %d's condition is now valid at "
845 "location %d, enabling.\n"),
848 loc
->disabled_by_cond
= false;
851 catch (const gdb_exception_error
&e
)
855 /* Warn if a user-enabled location is now becoming disabled-by-cond.
856 BP_NUM is 0 if the breakpoint is being defined for the first
857 time using the "break ... if ..." command, and non-zero if
860 warning (_("failed to validate condition at location %d.%d, "
861 "disabling:\n %s"), bp_num
, loc_num
, e
.what ());
863 warning (_("failed to validate condition at location %d, "
864 "disabling:\n %s"), loc_num
, e
.what ());
867 loc
->disabled_by_cond
= true;
871 error (_("Garbage '%s' follows condition"), cond_string
);
875 set_breakpoint_condition (struct breakpoint
*b
, const char *exp
,
876 int from_tty
, bool force
)
880 xfree (b
->cond_string
);
881 b
->cond_string
= nullptr;
883 if (is_watchpoint (b
))
884 static_cast<watchpoint
*> (b
)->cond_exp
.reset ();
888 for (bp_location
*loc
: b
->locations ())
891 if (loc
->disabled_by_cond
&& loc
->enabled
)
892 printf_filtered (_("Breakpoint %d's condition is now valid at "
893 "location %d, enabling.\n"),
895 loc
->disabled_by_cond
= false;
898 /* No need to free the condition agent expression
899 bytecode (if we have one). We will handle this
900 when we go through update_global_location_list. */
905 printf_filtered (_("Breakpoint %d now unconditional.\n"), b
->number
);
909 if (is_watchpoint (b
))
911 innermost_block_tracker tracker
;
912 const char *arg
= exp
;
913 expression_up new_exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
915 error (_("Junk at end of expression"));
916 watchpoint
*w
= static_cast<watchpoint
*> (b
);
917 w
->cond_exp
= std::move (new_exp
);
918 w
->cond_exp_valid_block
= tracker
.block ();
922 /* Parse and set condition expressions. We make two passes.
923 In the first, we parse the condition string to see if it
924 is valid in at least one location. If so, the condition
925 would be accepted. So we go ahead and set the locations'
926 conditions. In case no valid case is found, we throw
927 the error and the condition string will be rejected.
928 This two-pass approach is taken to avoid setting the
929 state of locations in case of a reject. */
930 for (bp_location
*loc
: b
->locations ())
934 const char *arg
= exp
;
935 parse_exp_1 (&arg
, loc
->address
,
936 block_for_pc (loc
->address
), 0);
938 error (_("Junk at end of expression"));
941 catch (const gdb_exception_error
&e
)
943 /* Condition string is invalid. If this happens to
944 be the last loc, abandon (if not forced) or continue
946 if (loc
->next
== nullptr && !force
)
951 /* If we reach here, the condition is valid at some locations. */
953 for (bp_location
*loc
: b
->locations ())
955 set_breakpoint_location_condition (exp
, loc
, b
->number
, loc_num
);
960 /* We know that the new condition parsed successfully. The
961 condition string of the breakpoint can be safely updated. */
962 xfree (b
->cond_string
);
963 b
->cond_string
= xstrdup (exp
);
964 b
->condition_not_parsed
= 0;
966 mark_breakpoint_modified (b
);
968 gdb::observers::breakpoint_modified
.notify (b
);
971 /* See breakpoint.h. */
974 set_breakpoint_condition (int bpnum
, const char *exp
, int from_tty
,
977 for (breakpoint
*b
: all_breakpoints ())
978 if (b
->number
== bpnum
)
980 /* Check if this breakpoint has a "stop" method implemented in an
981 extension language. This method and conditions entered into GDB
982 from the CLI are mutually exclusive. */
983 const struct extension_language_defn
*extlang
984 = get_breakpoint_cond_ext_lang (b
, EXT_LANG_NONE
);
988 error (_("Only one stop condition allowed. There is currently"
989 " a %s stop condition defined for this breakpoint."),
990 ext_lang_capitalized_name (extlang
));
992 set_breakpoint_condition (b
, exp
, from_tty
, force
);
994 if (is_breakpoint (b
))
995 update_global_location_list (UGLL_MAY_INSERT
);
1000 error (_("No breakpoint number %d."), bpnum
);
1003 /* The options for the "condition" command. */
1005 struct condition_command_opts
1008 bool force_condition
= false;
1011 static const gdb::option::option_def condition_command_option_defs
[] = {
1013 gdb::option::flag_option_def
<condition_command_opts
> {
1015 [] (condition_command_opts
*opts
) { return &opts
->force_condition
; },
1016 N_("Set the condition even if it is invalid for all current locations."),
1021 /* Create an option_def_group for the "condition" options, with
1022 CC_OPTS as context. */
1024 static inline gdb::option::option_def_group
1025 make_condition_command_options_def_group (condition_command_opts
*cc_opts
)
1027 return {{condition_command_option_defs
}, cc_opts
};
1030 /* Completion for the "condition" command. */
1033 condition_completer (struct cmd_list_element
*cmd
,
1034 completion_tracker
&tracker
,
1035 const char *text
, const char * /*word*/)
1037 bool has_no_arguments
= (*text
== '\0');
1038 condition_command_opts cc_opts
;
1039 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1040 if (gdb::option::complete_options
1041 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
))
1044 text
= skip_spaces (text
);
1045 const char *space
= skip_to_space (text
);
1052 tracker
.advance_custom_word_point_by (1);
1053 /* We don't support completion of history indices. */
1054 if (!isdigit (text
[1]))
1055 complete_internalvar (tracker
, &text
[1]);
1059 /* Suggest the "-force" flag if no arguments are given. If
1060 arguments were passed, they either already include the flag,
1061 or we are beyond the point of suggesting it because it's
1062 positionally the first argument. */
1063 if (has_no_arguments
)
1064 gdb::option::complete_on_all_options (tracker
, group
);
1066 /* We're completing the breakpoint number. */
1067 len
= strlen (text
);
1069 for (breakpoint
*b
: all_breakpoints ())
1073 xsnprintf (number
, sizeof (number
), "%d", b
->number
);
1075 if (strncmp (number
, text
, len
) == 0)
1076 tracker
.add_completion (make_unique_xstrdup (number
));
1082 /* We're completing the expression part. Skip the breakpoint num. */
1083 const char *exp_start
= skip_spaces (space
);
1084 tracker
.advance_custom_word_point_by (exp_start
- text
);
1086 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
1087 expression_completer (cmd
, tracker
, text
, word
);
1090 /* condition N EXP -- set break condition of breakpoint N to EXP. */
1093 condition_command (const char *arg
, int from_tty
)
1099 error_no_arg (_("breakpoint number"));
1103 /* Check if the "-force" flag was passed. */
1104 condition_command_opts cc_opts
;
1105 const auto group
= make_condition_command_options_def_group (&cc_opts
);
1106 gdb::option::process_options
1107 (&p
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_ERROR
, group
);
1109 bnum
= get_number (&p
);
1111 error (_("Bad breakpoint argument: '%s'"), arg
);
1113 set_breakpoint_condition (bnum
, p
, from_tty
, cc_opts
.force_condition
);
1116 /* Check that COMMAND do not contain commands that are suitable
1117 only for tracepoints and not suitable for ordinary breakpoints.
1118 Throw if any such commands is found. */
1121 check_no_tracepoint_commands (struct command_line
*commands
)
1123 struct command_line
*c
;
1125 for (c
= commands
; c
; c
= c
->next
)
1127 if (c
->control_type
== while_stepping_control
)
1128 error (_("The 'while-stepping' command can "
1129 "only be used for tracepoints"));
1131 check_no_tracepoint_commands (c
->body_list_0
.get ());
1132 check_no_tracepoint_commands (c
->body_list_1
.get ());
1134 /* Not that command parsing removes leading whitespace and comment
1135 lines and also empty lines. So, we only need to check for
1136 command directly. */
1137 if (strstr (c
->line
, "collect ") == c
->line
)
1138 error (_("The 'collect' command can only be used for tracepoints"));
1140 if (strstr (c
->line
, "teval ") == c
->line
)
1141 error (_("The 'teval' command can only be used for tracepoints"));
1145 struct longjmp_breakpoint
: public breakpoint
1147 ~longjmp_breakpoint () override
;
1150 /* Encapsulate tests for different types of tracepoints. */
1153 is_tracepoint_type (bptype type
)
1155 return (type
== bp_tracepoint
1156 || type
== bp_fast_tracepoint
1157 || type
== bp_static_tracepoint
);
1161 is_longjmp_type (bptype type
)
1163 return type
== bp_longjmp
|| type
== bp_exception
;
1166 /* See breakpoint.h. */
1169 is_tracepoint (const struct breakpoint
*b
)
1171 return is_tracepoint_type (b
->type
);
1174 /* Factory function to create an appropriate instance of breakpoint given
1177 static std::unique_ptr
<breakpoint
>
1178 new_breakpoint_from_type (bptype type
)
1182 if (is_tracepoint_type (type
))
1183 b
= new tracepoint ();
1184 else if (is_longjmp_type (type
))
1185 b
= new longjmp_breakpoint ();
1187 b
= new breakpoint ();
1189 return std::unique_ptr
<breakpoint
> (b
);
1192 /* A helper function that validates that COMMANDS are valid for a
1193 breakpoint. This function will throw an exception if a problem is
1197 validate_commands_for_breakpoint (struct breakpoint
*b
,
1198 struct command_line
*commands
)
1200 if (is_tracepoint (b
))
1202 struct tracepoint
*t
= (struct tracepoint
*) b
;
1203 struct command_line
*c
;
1204 struct command_line
*while_stepping
= 0;
1206 /* Reset the while-stepping step count. The previous commands
1207 might have included a while-stepping action, while the new
1211 /* We need to verify that each top-level element of commands is
1212 valid for tracepoints, that there's at most one
1213 while-stepping element, and that the while-stepping's body
1214 has valid tracing commands excluding nested while-stepping.
1215 We also need to validate the tracepoint action line in the
1216 context of the tracepoint --- validate_actionline actually
1217 has side effects, like setting the tracepoint's
1218 while-stepping STEP_COUNT, in addition to checking if the
1219 collect/teval actions parse and make sense in the
1220 tracepoint's context. */
1221 for (c
= commands
; c
; c
= c
->next
)
1223 if (c
->control_type
== while_stepping_control
)
1225 if (b
->type
== bp_fast_tracepoint
)
1226 error (_("The 'while-stepping' command "
1227 "cannot be used for fast tracepoint"));
1228 else if (b
->type
== bp_static_tracepoint
)
1229 error (_("The 'while-stepping' command "
1230 "cannot be used for static tracepoint"));
1233 error (_("The 'while-stepping' command "
1234 "can be used only once"));
1239 validate_actionline (c
->line
, b
);
1243 struct command_line
*c2
;
1245 gdb_assert (while_stepping
->body_list_1
== nullptr);
1246 c2
= while_stepping
->body_list_0
.get ();
1247 for (; c2
; c2
= c2
->next
)
1249 if (c2
->control_type
== while_stepping_control
)
1250 error (_("The 'while-stepping' command cannot be nested"));
1256 check_no_tracepoint_commands (commands
);
1260 /* Return a vector of all the static tracepoints set at ADDR. The
1261 caller is responsible for releasing the vector. */
1263 std::vector
<breakpoint
*>
1264 static_tracepoints_here (CORE_ADDR addr
)
1266 std::vector
<breakpoint
*> found
;
1268 for (breakpoint
*b
: all_breakpoints ())
1269 if (b
->type
== bp_static_tracepoint
)
1271 for (bp_location
*loc
: b
->locations ())
1272 if (loc
->address
== addr
)
1273 found
.push_back (b
);
1279 /* Set the command list of B to COMMANDS. If breakpoint is tracepoint,
1280 validate that only allowed commands are included. */
1283 breakpoint_set_commands (struct breakpoint
*b
,
1284 counted_command_line
&&commands
)
1286 validate_commands_for_breakpoint (b
, commands
.get ());
1288 b
->commands
= std::move (commands
);
1289 gdb::observers::breakpoint_modified
.notify (b
);
1292 /* Set the internal `silent' flag on the breakpoint. Note that this
1293 is not the same as the "silent" that may appear in the breakpoint's
1297 breakpoint_set_silent (struct breakpoint
*b
, int silent
)
1299 int old_silent
= b
->silent
;
1302 if (old_silent
!= silent
)
1303 gdb::observers::breakpoint_modified
.notify (b
);
1306 /* Set the thread for this breakpoint. If THREAD is -1, make the
1307 breakpoint work for any thread. */
1310 breakpoint_set_thread (struct breakpoint
*b
, int thread
)
1312 int old_thread
= b
->thread
;
1315 if (old_thread
!= thread
)
1316 gdb::observers::breakpoint_modified
.notify (b
);
1319 /* Set the task for this breakpoint. If TASK is 0, make the
1320 breakpoint work for any task. */
1323 breakpoint_set_task (struct breakpoint
*b
, int task
)
1325 int old_task
= b
->task
;
1328 if (old_task
!= task
)
1329 gdb::observers::breakpoint_modified
.notify (b
);
1333 commands_command_1 (const char *arg
, int from_tty
,
1334 struct command_line
*control
)
1336 counted_command_line cmd
;
1337 /* cmd_read will be true once we have read cmd. Note that cmd might still be
1338 NULL after the call to read_command_lines if the user provides an empty
1339 list of command by just typing "end". */
1340 bool cmd_read
= false;
1342 std::string new_arg
;
1344 if (arg
== NULL
|| !*arg
)
1346 /* Argument not explicitly given. Synthesize it. */
1347 if (breakpoint_count
- prev_breakpoint_count
> 1)
1348 new_arg
= string_printf ("%d-%d", prev_breakpoint_count
+ 1,
1350 else if (breakpoint_count
> 0)
1351 new_arg
= string_printf ("%d", breakpoint_count
);
1355 /* Create a copy of ARG. This is needed because the "commands"
1356 command may be coming from a script. In that case, the read
1357 line buffer is going to be overwritten in the lambda of
1358 'map_breakpoint_numbers' below when reading the next line
1359 before we are are done parsing the breakpoint numbers. */
1362 arg
= new_arg
.c_str ();
1364 map_breakpoint_numbers
1365 (arg
, [&] (breakpoint
*b
)
1369 gdb_assert (cmd
== NULL
);
1370 if (control
!= NULL
)
1371 cmd
= control
->body_list_0
;
1375 = string_printf (_("Type commands for breakpoint(s) "
1376 "%s, one per line."),
1379 auto do_validate
= [=] (const char *line
)
1381 validate_actionline (line
, b
);
1383 gdb::function_view
<void (const char *)> validator
;
1384 if (is_tracepoint (b
))
1385 validator
= do_validate
;
1387 cmd
= read_command_lines (str
.c_str (), from_tty
, 1, validator
);
1392 /* If a breakpoint was on the list more than once, we don't need to
1394 if (b
->commands
!= cmd
)
1396 validate_commands_for_breakpoint (b
, cmd
.get ());
1398 gdb::observers::breakpoint_modified
.notify (b
);
1404 commands_command (const char *arg
, int from_tty
)
1406 commands_command_1 (arg
, from_tty
, NULL
);
1409 /* Like commands_command, but instead of reading the commands from
1410 input stream, takes them from an already parsed command structure.
1412 This is used by cli-script.c to DTRT with breakpoint commands
1413 that are part of if and while bodies. */
1414 enum command_control_type
1415 commands_from_control_command (const char *arg
, struct command_line
*cmd
)
1417 commands_command_1 (arg
, 0, cmd
);
1418 return simple_control
;
1421 /* Return non-zero if BL->TARGET_INFO contains valid information. */
1424 bp_location_has_shadow (struct bp_location
*bl
)
1426 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
1430 if (bl
->target_info
.shadow_len
== 0)
1431 /* BL isn't valid, or doesn't shadow memory. */
1436 /* Update BUF, which is LEN bytes read from the target address
1437 MEMADDR, by replacing a memory breakpoint with its shadowed
1440 If READBUF is not NULL, this buffer must not overlap with the of
1441 the breakpoint location's shadow_contents buffer. Otherwise, a
1442 failed assertion internal error will be raised. */
1445 one_breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1446 const gdb_byte
*writebuf_org
,
1447 ULONGEST memaddr
, LONGEST len
,
1448 struct bp_target_info
*target_info
,
1449 struct gdbarch
*gdbarch
)
1451 /* Now do full processing of the found relevant range of elements. */
1452 CORE_ADDR bp_addr
= 0;
1456 if (!breakpoint_address_match (target_info
->placed_address_space
, 0,
1457 current_program_space
->aspace
, 0))
1459 /* The breakpoint is inserted in a different address space. */
1463 /* Addresses and length of the part of the breakpoint that
1465 bp_addr
= target_info
->placed_address
;
1466 bp_size
= target_info
->shadow_len
;
1468 if (bp_addr
+ bp_size
<= memaddr
)
1470 /* The breakpoint is entirely before the chunk of memory we are
1475 if (bp_addr
>= memaddr
+ len
)
1477 /* The breakpoint is entirely after the chunk of memory we are
1482 /* Offset within shadow_contents. */
1483 if (bp_addr
< memaddr
)
1485 /* Only copy the second part of the breakpoint. */
1486 bp_size
-= memaddr
- bp_addr
;
1487 bptoffset
= memaddr
- bp_addr
;
1491 if (bp_addr
+ bp_size
> memaddr
+ len
)
1493 /* Only copy the first part of the breakpoint. */
1494 bp_size
-= (bp_addr
+ bp_size
) - (memaddr
+ len
);
1497 if (readbuf
!= NULL
)
1499 /* Verify that the readbuf buffer does not overlap with the
1500 shadow_contents buffer. */
1501 gdb_assert (target_info
->shadow_contents
>= readbuf
+ len
1502 || readbuf
>= (target_info
->shadow_contents
1503 + target_info
->shadow_len
));
1505 /* Update the read buffer with this inserted breakpoint's
1507 memcpy (readbuf
+ bp_addr
- memaddr
,
1508 target_info
->shadow_contents
+ bptoffset
, bp_size
);
1512 const unsigned char *bp
;
1513 CORE_ADDR addr
= target_info
->reqstd_address
;
1516 /* Update the shadow with what we want to write to memory. */
1517 memcpy (target_info
->shadow_contents
+ bptoffset
,
1518 writebuf_org
+ bp_addr
- memaddr
, bp_size
);
1520 /* Determine appropriate breakpoint contents and size for this
1522 bp
= gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &placed_size
);
1524 /* Update the final write buffer with this inserted
1525 breakpoint's INSN. */
1526 memcpy (writebuf
+ bp_addr
- memaddr
, bp
+ bptoffset
, bp_size
);
1530 /* Update BUF, which is LEN bytes read from the target address MEMADDR,
1531 by replacing any memory breakpoints with their shadowed contents.
1533 If READBUF is not NULL, this buffer must not overlap with any of
1534 the breakpoint location's shadow_contents buffers. Otherwise,
1535 a failed assertion internal error will be raised.
1537 The range of shadowed area by each bp_location is:
1538 bl->address - bp_locations_placed_address_before_address_max
1539 up to bl->address + bp_locations_shadow_len_after_address_max
1540 The range we were requested to resolve shadows for is:
1541 memaddr ... memaddr + len
1542 Thus the safe cutoff boundaries for performance optimization are
1543 memaddr + len <= (bl->address
1544 - bp_locations_placed_address_before_address_max)
1546 bl->address + bp_locations_shadow_len_after_address_max <= memaddr */
1549 breakpoint_xfer_memory (gdb_byte
*readbuf
, gdb_byte
*writebuf
,
1550 const gdb_byte
*writebuf_org
,
1551 ULONGEST memaddr
, LONGEST len
)
1553 /* Left boundary, right boundary and median element of our binary
1555 unsigned bc_l
, bc_r
, bc
;
1557 /* Find BC_L which is a leftmost element which may affect BUF
1558 content. It is safe to report lower value but a failure to
1559 report higher one. */
1562 bc_r
= bp_locations
.size ();
1563 while (bc_l
+ 1 < bc_r
)
1565 struct bp_location
*bl
;
1567 bc
= (bc_l
+ bc_r
) / 2;
1568 bl
= bp_locations
[bc
];
1570 /* Check first BL->ADDRESS will not overflow due to the added
1571 constant. Then advance the left boundary only if we are sure
1572 the BC element can in no way affect the BUF content (MEMADDR
1573 to MEMADDR + LEN range).
1575 Use the BP_LOCATIONS_SHADOW_LEN_AFTER_ADDRESS_MAX safety
1576 offset so that we cannot miss a breakpoint with its shadow
1577 range tail still reaching MEMADDR. */
1579 if ((bl
->address
+ bp_locations_shadow_len_after_address_max
1581 && (bl
->address
+ bp_locations_shadow_len_after_address_max
1588 /* Due to the binary search above, we need to make sure we pick the
1589 first location that's at BC_L's address. E.g., if there are
1590 multiple locations at the same address, BC_L may end up pointing
1591 at a duplicate location, and miss the "master"/"inserted"
1592 location. Say, given locations L1, L2 and L3 at addresses A and
1595 L1@A, L2@A, L3@B, ...
1597 BC_L could end up pointing at location L2, while the "master"
1598 location could be L1. Since the `loc->inserted' flag is only set
1599 on "master" locations, we'd forget to restore the shadow of L1
1602 && bp_locations
[bc_l
]->address
== bp_locations
[bc_l
- 1]->address
)
1605 /* Now do full processing of the found relevant range of elements. */
1607 for (bc
= bc_l
; bc
< bp_locations
.size (); bc
++)
1609 struct bp_location
*bl
= bp_locations
[bc
];
1611 /* bp_location array has BL->OWNER always non-NULL. */
1612 if (bl
->owner
->type
== bp_none
)
1613 warning (_("reading through apparently deleted breakpoint #%d?"),
1616 /* Performance optimization: any further element can no longer affect BUF
1619 if (bl
->address
>= bp_locations_placed_address_before_address_max
1622 - bp_locations_placed_address_before_address_max
)))
1625 if (!bp_location_has_shadow (bl
))
1628 one_breakpoint_xfer_memory (readbuf
, writebuf
, writebuf_org
,
1629 memaddr
, len
, &bl
->target_info
, bl
->gdbarch
);
1633 /* See breakpoint.h. */
1636 is_breakpoint (const struct breakpoint
*bpt
)
1638 return (bpt
->type
== bp_breakpoint
1639 || bpt
->type
== bp_hardware_breakpoint
1640 || bpt
->type
== bp_dprintf
);
1643 /* Return true if BPT is of any hardware watchpoint kind. */
1646 is_hardware_watchpoint (const struct breakpoint
*bpt
)
1648 return (bpt
->type
== bp_hardware_watchpoint
1649 || bpt
->type
== bp_read_watchpoint
1650 || bpt
->type
== bp_access_watchpoint
);
1653 /* See breakpoint.h. */
1656 is_watchpoint (const struct breakpoint
*bpt
)
1658 return (is_hardware_watchpoint (bpt
)
1659 || bpt
->type
== bp_watchpoint
);
1662 /* Returns true if the current thread and its running state are safe
1663 to evaluate or update watchpoint B. Watchpoints on local
1664 expressions need to be evaluated in the context of the thread that
1665 was current when the watchpoint was created, and, that thread needs
1666 to be stopped to be able to select the correct frame context.
1667 Watchpoints on global expressions can be evaluated on any thread,
1668 and in any state. It is presently left to the target allowing
1669 memory accesses when threads are running. */
1672 watchpoint_in_thread_scope (struct watchpoint
*b
)
1674 return (b
->pspace
== current_program_space
1675 && (b
->watchpoint_thread
== null_ptid
1676 || (inferior_ptid
== b
->watchpoint_thread
1677 && !inferior_thread ()->executing
)));
1680 /* Set watchpoint B to disp_del_at_next_stop, even including its possible
1681 associated bp_watchpoint_scope breakpoint. */
1684 watchpoint_del_at_next_stop (struct watchpoint
*w
)
1686 if (w
->related_breakpoint
!= w
)
1688 gdb_assert (w
->related_breakpoint
->type
== bp_watchpoint_scope
);
1689 gdb_assert (w
->related_breakpoint
->related_breakpoint
== w
);
1690 w
->related_breakpoint
->disposition
= disp_del_at_next_stop
;
1691 w
->related_breakpoint
->related_breakpoint
= w
->related_breakpoint
;
1692 w
->related_breakpoint
= w
;
1694 w
->disposition
= disp_del_at_next_stop
;
1697 /* Extract a bitfield value from value VAL using the bit parameters contained in
1700 static struct value
*
1701 extract_bitfield_from_watchpoint_value (struct watchpoint
*w
, struct value
*val
)
1703 struct value
*bit_val
;
1708 bit_val
= allocate_value (value_type (val
));
1710 unpack_value_bitfield (bit_val
,
1713 value_contents_for_printing (val
),
1720 /* Allocate a dummy location and add it to B, which must be a software
1721 watchpoint. This is required because even if a software watchpoint
1722 is not watching any memory, bpstat_stop_status requires a location
1723 to be able to report stops. */
1726 software_watchpoint_add_no_memory_location (struct breakpoint
*b
,
1727 struct program_space
*pspace
)
1729 gdb_assert (b
->type
== bp_watchpoint
&& b
->loc
== NULL
);
1731 b
->loc
= allocate_bp_location (b
);
1732 b
->loc
->pspace
= pspace
;
1733 b
->loc
->address
= -1;
1734 b
->loc
->length
= -1;
1737 /* Returns true if B is a software watchpoint that is not watching any
1738 memory (e.g., "watch $pc"). */
1741 is_no_memory_software_watchpoint (struct breakpoint
*b
)
1743 return (b
->type
== bp_watchpoint
1745 && b
->loc
->next
== NULL
1746 && b
->loc
->address
== -1
1747 && b
->loc
->length
== -1);
1750 /* Assuming that B is a watchpoint:
1751 - Reparse watchpoint expression, if REPARSE is non-zero
1752 - Evaluate expression and store the result in B->val
1753 - Evaluate the condition if there is one, and store the result
1755 - Update the list of values that must be watched in B->loc.
1757 If the watchpoint disposition is disp_del_at_next_stop, then do
1758 nothing. If this is local watchpoint that is out of scope, delete
1761 Even with `set breakpoint always-inserted on' the watchpoints are
1762 removed + inserted on each stop here. Normal breakpoints must
1763 never be removed because they might be missed by a running thread
1764 when debugging in non-stop mode. On the other hand, hardware
1765 watchpoints (is_hardware_watchpoint; processed here) are specific
1766 to each LWP since they are stored in each LWP's hardware debug
1767 registers. Therefore, such LWP must be stopped first in order to
1768 be able to modify its hardware watchpoints.
1770 Hardware watchpoints must be reset exactly once after being
1771 presented to the user. It cannot be done sooner, because it would
1772 reset the data used to present the watchpoint hit to the user. And
1773 it must not be done later because it could display the same single
1774 watchpoint hit during multiple GDB stops. Note that the latter is
1775 relevant only to the hardware watchpoint types bp_read_watchpoint
1776 and bp_access_watchpoint. False hit by bp_hardware_watchpoint is
1777 not user-visible - its hit is suppressed if the memory content has
1780 The following constraints influence the location where we can reset
1781 hardware watchpoints:
1783 * target_stopped_by_watchpoint and target_stopped_data_address are
1784 called several times when GDB stops.
1787 * Multiple hardware watchpoints can be hit at the same time,
1788 causing GDB to stop. GDB only presents one hardware watchpoint
1789 hit at a time as the reason for stopping, and all the other hits
1790 are presented later, one after the other, each time the user
1791 requests the execution to be resumed. Execution is not resumed
1792 for the threads still having pending hit event stored in
1793 LWP_INFO->STATUS. While the watchpoint is already removed from
1794 the inferior on the first stop the thread hit event is kept being
1795 reported from its cached value by linux_nat_stopped_data_address
1796 until the real thread resume happens after the watchpoint gets
1797 presented and thus its LWP_INFO->STATUS gets reset.
1799 Therefore the hardware watchpoint hit can get safely reset on the
1800 watchpoint removal from inferior. */
1803 update_watchpoint (struct watchpoint
*b
, int reparse
)
1805 int within_current_scope
;
1806 struct frame_id saved_frame_id
;
1809 /* If this is a local watchpoint, we only want to check if the
1810 watchpoint frame is in scope if the current thread is the thread
1811 that was used to create the watchpoint. */
1812 if (!watchpoint_in_thread_scope (b
))
1815 if (b
->disposition
== disp_del_at_next_stop
)
1820 /* Determine if the watchpoint is within scope. */
1821 if (b
->exp_valid_block
== NULL
)
1822 within_current_scope
= 1;
1825 struct frame_info
*fi
= get_current_frame ();
1826 struct gdbarch
*frame_arch
= get_frame_arch (fi
);
1827 CORE_ADDR frame_pc
= get_frame_pc (fi
);
1829 /* If we're at a point where the stack has been destroyed
1830 (e.g. in a function epilogue), unwinding may not work
1831 properly. Do not attempt to recreate locations at this
1832 point. See similar comments in watchpoint_check. */
1833 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
1836 /* Save the current frame's ID so we can restore it after
1837 evaluating the watchpoint expression on its own frame. */
1838 /* FIXME drow/2003-09-09: It would be nice if evaluate_expression
1839 took a frame parameter, so that we didn't have to change the
1842 saved_frame_id
= get_frame_id (get_selected_frame (NULL
));
1844 fi
= frame_find_by_id (b
->watchpoint_frame
);
1845 within_current_scope
= (fi
!= NULL
);
1846 if (within_current_scope
)
1850 /* We don't free locations. They are stored in the bp_location array
1851 and update_global_location_list will eventually delete them and
1852 remove breakpoints if needed. */
1855 if (within_current_scope
&& reparse
)
1860 s
= b
->exp_string_reparse
? b
->exp_string_reparse
: b
->exp_string
;
1861 b
->exp
= parse_exp_1 (&s
, 0, b
->exp_valid_block
, 0);
1862 /* If the meaning of expression itself changed, the old value is
1863 no longer relevant. We don't want to report a watchpoint hit
1864 to the user when the old value and the new value may actually
1865 be completely different objects. */
1867 b
->val_valid
= false;
1869 /* Note that unlike with breakpoints, the watchpoint's condition
1870 expression is stored in the breakpoint object, not in the
1871 locations (re)created below. */
1872 if (b
->cond_string
!= NULL
)
1874 b
->cond_exp
.reset ();
1877 b
->cond_exp
= parse_exp_1 (&s
, 0, b
->cond_exp_valid_block
, 0);
1881 /* If we failed to parse the expression, for example because
1882 it refers to a global variable in a not-yet-loaded shared library,
1883 don't try to insert watchpoint. We don't automatically delete
1884 such watchpoint, though, since failure to parse expression
1885 is different from out-of-scope watchpoint. */
1886 if (!target_has_execution ())
1888 /* Without execution, memory can't change. No use to try and
1889 set watchpoint locations. The watchpoint will be reset when
1890 the target gains execution, through breakpoint_re_set. */
1891 if (!can_use_hw_watchpoints
)
1893 if (b
->ops
->works_in_software_mode (b
))
1894 b
->type
= bp_watchpoint
;
1896 error (_("Can't set read/access watchpoint when "
1897 "hardware watchpoints are disabled."));
1900 else if (within_current_scope
&& b
->exp
)
1902 std::vector
<value_ref_ptr
> val_chain
;
1903 struct value
*v
, *result
;
1904 struct program_space
*frame_pspace
;
1906 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &v
, &result
,
1909 /* Avoid setting b->val if it's already set. The meaning of
1910 b->val is 'the last value' user saw, and we should update
1911 it only if we reported that last value to user. As it
1912 happens, the code that reports it updates b->val directly.
1913 We don't keep track of the memory value for masked
1915 if (!b
->val_valid
&& !is_masked_watchpoint (b
))
1917 if (b
->val_bitsize
!= 0)
1918 v
= extract_bitfield_from_watchpoint_value (b
, v
);
1919 b
->val
= release_value (v
);
1920 b
->val_valid
= true;
1923 frame_pspace
= get_frame_program_space (get_selected_frame (NULL
));
1925 /* Look at each value on the value chain. */
1926 gdb_assert (!val_chain
.empty ());
1927 for (const value_ref_ptr
&iter
: val_chain
)
1931 /* If it's a memory location, and GDB actually needed
1932 its contents to evaluate the expression, then we
1933 must watch it. If the first value returned is
1934 still lazy, that means an error occurred reading it;
1935 watch it anyway in case it becomes readable. */
1936 if (VALUE_LVAL (v
) == lval_memory
1937 && (v
== val_chain
[0] || ! value_lazy (v
)))
1939 struct type
*vtype
= check_typedef (value_type (v
));
1941 /* We only watch structs and arrays if user asked
1942 for it explicitly, never if they just happen to
1943 appear in the middle of some value chain. */
1945 || (vtype
->code () != TYPE_CODE_STRUCT
1946 && vtype
->code () != TYPE_CODE_ARRAY
))
1949 enum target_hw_bp_type type
;
1950 struct bp_location
*loc
, **tmp
;
1951 int bitpos
= 0, bitsize
= 0;
1953 if (value_bitsize (v
) != 0)
1955 /* Extract the bit parameters out from the bitfield
1957 bitpos
= value_bitpos (v
);
1958 bitsize
= value_bitsize (v
);
1960 else if (v
== result
&& b
->val_bitsize
!= 0)
1962 /* If VAL_BITSIZE != 0 then RESULT is actually a bitfield
1963 lvalue whose bit parameters are saved in the fields
1964 VAL_BITPOS and VAL_BITSIZE. */
1965 bitpos
= b
->val_bitpos
;
1966 bitsize
= b
->val_bitsize
;
1969 addr
= value_address (v
);
1972 /* Skip the bytes that don't contain the bitfield. */
1977 if (b
->type
== bp_read_watchpoint
)
1979 else if (b
->type
== bp_access_watchpoint
)
1982 loc
= allocate_bp_location (b
);
1983 for (tmp
= &(b
->loc
); *tmp
!= NULL
; tmp
= &((*tmp
)->next
))
1986 loc
->gdbarch
= value_type (v
)->arch ();
1988 loc
->pspace
= frame_pspace
;
1989 loc
->address
= address_significant (loc
->gdbarch
, addr
);
1993 /* Just cover the bytes that make up the bitfield. */
1994 loc
->length
= ((bitpos
% 8) + bitsize
+ 7) / 8;
1997 loc
->length
= TYPE_LENGTH (value_type (v
));
1999 loc
->watchpoint_type
= type
;
2004 /* Change the type of breakpoint between hardware assisted or
2005 an ordinary watchpoint depending on the hardware support
2006 and free hardware slots. REPARSE is set when the inferior
2011 enum bp_loc_type loc_type
;
2013 reg_cnt
= can_use_hardware_watchpoint (val_chain
);
2017 int i
, target_resources_ok
, other_type_used
;
2020 /* Use an exact watchpoint when there's only one memory region to be
2021 watched, and only one debug register is needed to watch it. */
2022 b
->exact
= target_exact_watchpoints
&& reg_cnt
== 1;
2024 /* We need to determine how many resources are already
2025 used for all other hardware watchpoints plus this one
2026 to see if we still have enough resources to also fit
2027 this watchpoint in as well. */
2029 /* If this is a software watchpoint, we try to turn it
2030 to a hardware one -- count resources as if B was of
2031 hardware watchpoint type. */
2033 if (type
== bp_watchpoint
)
2034 type
= bp_hardware_watchpoint
;
2036 /* This watchpoint may or may not have been placed on
2037 the list yet at this point (it won't be in the list
2038 if we're trying to create it for the first time,
2039 through watch_command), so always account for it
2042 /* Count resources used by all watchpoints except B. */
2043 i
= hw_watchpoint_used_count_others (b
, type
, &other_type_used
);
2045 /* Add in the resources needed for B. */
2046 i
+= hw_watchpoint_use_count (b
);
2049 = target_can_use_hardware_watchpoint (type
, i
, other_type_used
);
2050 if (target_resources_ok
<= 0)
2052 int sw_mode
= b
->ops
->works_in_software_mode (b
);
2054 if (target_resources_ok
== 0 && !sw_mode
)
2055 error (_("Target does not support this type of "
2056 "hardware watchpoint."));
2057 else if (target_resources_ok
< 0 && !sw_mode
)
2058 error (_("There are not enough available hardware "
2059 "resources for this watchpoint."));
2061 /* Downgrade to software watchpoint. */
2062 b
->type
= bp_watchpoint
;
2066 /* If this was a software watchpoint, we've just
2067 found we have enough resources to turn it to a
2068 hardware watchpoint. Otherwise, this is a
2073 else if (!b
->ops
->works_in_software_mode (b
))
2075 if (!can_use_hw_watchpoints
)
2076 error (_("Can't set read/access watchpoint when "
2077 "hardware watchpoints are disabled."));
2079 error (_("Expression cannot be implemented with "
2080 "read/access watchpoint."));
2083 b
->type
= bp_watchpoint
;
2085 loc_type
= (b
->type
== bp_watchpoint
? bp_loc_other
2086 : bp_loc_hardware_watchpoint
);
2087 for (bp_location
*bl
: b
->locations ())
2088 bl
->loc_type
= loc_type
;
2091 /* If a software watchpoint is not watching any memory, then the
2092 above left it without any location set up. But,
2093 bpstat_stop_status requires a location to be able to report
2094 stops, so make sure there's at least a dummy one. */
2095 if (b
->type
== bp_watchpoint
&& b
->loc
== NULL
)
2096 software_watchpoint_add_no_memory_location (b
, frame_pspace
);
2098 else if (!within_current_scope
)
2100 printf_filtered (_("\
2101 Watchpoint %d deleted because the program has left the block\n\
2102 in which its expression is valid.\n"),
2104 watchpoint_del_at_next_stop (b
);
2107 /* Restore the selected frame. */
2109 select_frame (frame_find_by_id (saved_frame_id
));
2113 /* Returns 1 iff breakpoint location should be
2114 inserted in the inferior. We don't differentiate the type of BL's owner
2115 (breakpoint vs. tracepoint), although insert_location in tracepoint's
2116 breakpoint_ops is not defined, because in insert_bp_location,
2117 tracepoint's insert_location will not be called. */
2119 should_be_inserted (struct bp_location
*bl
)
2121 if (bl
->owner
== NULL
|| !breakpoint_enabled (bl
->owner
))
2124 if (bl
->owner
->disposition
== disp_del_at_next_stop
)
2127 if (!bl
->enabled
|| bl
->disabled_by_cond
2128 || bl
->shlib_disabled
|| bl
->duplicate
)
2131 if (user_breakpoint_p (bl
->owner
) && bl
->pspace
->executing_startup
)
2134 /* This is set for example, when we're attached to the parent of a
2135 vfork, and have detached from the child. The child is running
2136 free, and we expect it to do an exec or exit, at which point the
2137 OS makes the parent schedulable again (and the target reports
2138 that the vfork is done). Until the child is done with the shared
2139 memory region, do not insert breakpoints in the parent, otherwise
2140 the child could still trip on the parent's breakpoints. Since
2141 the parent is blocked anyway, it won't miss any breakpoint. */
2142 if (bl
->pspace
->breakpoints_not_allowed
)
2145 /* Don't insert a breakpoint if we're trying to step past its
2146 location, except if the breakpoint is a single-step breakpoint,
2147 and the breakpoint's thread is the thread which is stepping past
2149 if ((bl
->loc_type
== bp_loc_software_breakpoint
2150 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2151 && stepping_past_instruction_at (bl
->pspace
->aspace
,
2153 /* The single-step breakpoint may be inserted at the location
2154 we're trying to step if the instruction branches to itself.
2155 However, the instruction won't be executed at all and it may
2156 break the semantics of the instruction, for example, the
2157 instruction is a conditional branch or updates some flags.
2158 We can't fix it unless GDB is able to emulate the instruction
2159 or switch to displaced stepping. */
2160 && !(bl
->owner
->type
== bp_single_step
2161 && thread_is_stepping_over_breakpoint (bl
->owner
->thread
)))
2163 infrun_debug_printf ("skipping breakpoint: stepping past insn at: %s",
2164 paddress (bl
->gdbarch
, bl
->address
));
2168 /* Don't insert watchpoints if we're trying to step past the
2169 instruction that triggered one. */
2170 if ((bl
->loc_type
== bp_loc_hardware_watchpoint
)
2171 && stepping_past_nonsteppable_watchpoint ())
2173 infrun_debug_printf ("stepping past non-steppable watchpoint. "
2174 "skipping watchpoint at %s:%d",
2175 paddress (bl
->gdbarch
, bl
->address
), bl
->length
);
2182 /* Same as should_be_inserted but does the check assuming
2183 that the location is not duplicated. */
2186 unduplicated_should_be_inserted (struct bp_location
*bl
)
2189 const int save_duplicate
= bl
->duplicate
;
2192 result
= should_be_inserted (bl
);
2193 bl
->duplicate
= save_duplicate
;
2197 /* Parses a conditional described by an expression COND into an
2198 agent expression bytecode suitable for evaluation
2199 by the bytecode interpreter. Return NULL if there was
2200 any error during parsing. */
2202 static agent_expr_up
2203 parse_cond_to_aexpr (CORE_ADDR scope
, struct expression
*cond
)
2208 agent_expr_up aexpr
;
2210 /* We don't want to stop processing, so catch any errors
2211 that may show up. */
2214 aexpr
= gen_eval_for_expr (scope
, cond
);
2217 catch (const gdb_exception_error
&ex
)
2219 /* If we got here, it means the condition could not be parsed to a valid
2220 bytecode expression and thus can't be evaluated on the target's side.
2221 It's no use iterating through the conditions. */
2224 /* We have a valid agent expression. */
2228 /* Based on location BL, create a list of breakpoint conditions to be
2229 passed on to the target. If we have duplicated locations with different
2230 conditions, we will add such conditions to the list. The idea is that the
2231 target will evaluate the list of conditions and will only notify GDB when
2232 one of them is true. */
2235 build_target_condition_list (struct bp_location
*bl
)
2237 int null_condition_or_parse_error
= 0;
2238 int modified
= bl
->needs_update
;
2240 /* Release conditions left over from a previous insert. */
2241 bl
->target_info
.conditions
.clear ();
2243 /* This is only meaningful if the target is
2244 evaluating conditions and if the user has
2245 opted for condition evaluation on the target's
2247 if (gdb_evaluates_breakpoint_condition_p ()
2248 || !target_supports_evaluation_of_breakpoint_conditions ())
2251 auto loc_range
= all_bp_locations_at_addr (bl
->address
);
2253 /* Do a first pass to check for locations with no assigned
2254 conditions or conditions that fail to parse to a valid agent
2255 expression bytecode. If any of these happen, then it's no use to
2256 send conditions to the target since this location will always
2257 trigger and generate a response back to GDB. Note we consider
2258 all locations at the same address irrespective of type, i.e.,
2259 even if the locations aren't considered duplicates (e.g.,
2260 software breakpoint and hardware breakpoint at the same
2262 for (bp_location
*loc
: loc_range
)
2264 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2268 /* Re-parse the conditions since something changed. In that
2269 case we already freed the condition bytecodes (see
2270 force_breakpoint_reinsertion). We just
2271 need to parse the condition to bytecodes again. */
2272 loc
->cond_bytecode
= parse_cond_to_aexpr (bl
->address
,
2276 /* If we have a NULL bytecode expression, it means something
2277 went wrong or we have a null condition expression. */
2278 if (!loc
->cond_bytecode
)
2280 null_condition_or_parse_error
= 1;
2286 /* If any of these happened, it means we will have to evaluate the conditions
2287 for the location's address on gdb's side. It is no use keeping bytecodes
2288 for all the other duplicate locations, thus we free all of them here.
2290 This is so we have a finer control over which locations' conditions are
2291 being evaluated by GDB or the remote stub. */
2292 if (null_condition_or_parse_error
)
2294 for (bp_location
*loc
: loc_range
)
2296 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2298 /* Only go as far as the first NULL bytecode is
2300 if (!loc
->cond_bytecode
)
2303 loc
->cond_bytecode
.reset ();
2308 /* No NULL conditions or failed bytecode generation. Build a
2309 condition list for this location's address. If we have software
2310 and hardware locations at the same address, they aren't
2311 considered duplicates, but we still marge all the conditions
2312 anyway, as it's simpler, and doesn't really make a practical
2314 for (bp_location
*loc
: loc_range
)
2316 && is_breakpoint (loc
->owner
)
2317 && loc
->pspace
->num
== bl
->pspace
->num
2318 && loc
->owner
->enable_state
== bp_enabled
2320 && !loc
->disabled_by_cond
)
2322 /* Add the condition to the vector. This will be used later
2323 to send the conditions to the target. */
2324 bl
->target_info
.conditions
.push_back (loc
->cond_bytecode
.get ());
2330 /* Parses a command described by string CMD into an agent expression
2331 bytecode suitable for evaluation by the bytecode interpreter.
2332 Return NULL if there was any error during parsing. */
2334 static agent_expr_up
2335 parse_cmd_to_aexpr (CORE_ADDR scope
, char *cmd
)
2337 const char *cmdrest
;
2338 const char *format_start
, *format_end
;
2339 struct gdbarch
*gdbarch
= get_current_arch ();
2346 if (*cmdrest
== ',')
2348 cmdrest
= skip_spaces (cmdrest
);
2350 if (*cmdrest
++ != '"')
2351 error (_("No format string following the location"));
2353 format_start
= cmdrest
;
2355 format_pieces
fpieces (&cmdrest
);
2357 format_end
= cmdrest
;
2359 if (*cmdrest
++ != '"')
2360 error (_("Bad format string, non-terminated '\"'."));
2362 cmdrest
= skip_spaces (cmdrest
);
2364 if (!(*cmdrest
== ',' || *cmdrest
== '\0'))
2365 error (_("Invalid argument syntax"));
2367 if (*cmdrest
== ',')
2369 cmdrest
= skip_spaces (cmdrest
);
2371 /* For each argument, make an expression. */
2373 std::vector
<struct expression
*> argvec
;
2374 while (*cmdrest
!= '\0')
2379 expression_up expr
= parse_exp_1 (&cmd1
, scope
, block_for_pc (scope
), 1);
2380 argvec
.push_back (expr
.release ());
2382 if (*cmdrest
== ',')
2386 agent_expr_up aexpr
;
2388 /* We don't want to stop processing, so catch any errors
2389 that may show up. */
2392 aexpr
= gen_printf (scope
, gdbarch
, 0, 0,
2393 format_start
, format_end
- format_start
,
2394 argvec
.size (), argvec
.data ());
2396 catch (const gdb_exception_error
&ex
)
2398 /* If we got here, it means the command could not be parsed to a valid
2399 bytecode expression and thus can't be evaluated on the target's side.
2400 It's no use iterating through the other commands. */
2403 /* We have a valid agent expression, return it. */
2407 /* Based on location BL, create a list of breakpoint commands to be
2408 passed on to the target. If we have duplicated locations with
2409 different commands, we will add any such to the list. */
2412 build_target_command_list (struct bp_location
*bl
)
2414 int null_command_or_parse_error
= 0;
2415 int modified
= bl
->needs_update
;
2417 /* Clear commands left over from a previous insert. */
2418 bl
->target_info
.tcommands
.clear ();
2420 if (!target_can_run_breakpoint_commands ())
2423 /* For now, limit to agent-style dprintf breakpoints. */
2424 if (dprintf_style
!= dprintf_style_agent
)
2427 auto loc_range
= all_bp_locations_at_addr (bl
->address
);
2429 /* For now, if we have any location at the same address that isn't a
2430 dprintf, don't install the target-side commands, as that would
2431 make the breakpoint not be reported to the core, and we'd lose
2433 for (bp_location
*loc
: loc_range
)
2434 if (is_breakpoint (loc
->owner
)
2435 && loc
->pspace
->num
== bl
->pspace
->num
2436 && loc
->owner
->type
!= bp_dprintf
)
2439 /* Do a first pass to check for locations with no assigned
2440 conditions or conditions that fail to parse to a valid agent expression
2441 bytecode. If any of these happen, then it's no use to send conditions
2442 to the target since this location will always trigger and generate a
2443 response back to GDB. */
2444 for (bp_location
*loc
: loc_range
)
2446 if (is_breakpoint (loc
->owner
) && loc
->pspace
->num
== bl
->pspace
->num
)
2450 /* Re-parse the commands since something changed. In that
2451 case we already freed the command bytecodes (see
2452 force_breakpoint_reinsertion). We just
2453 need to parse the command to bytecodes again. */
2455 = parse_cmd_to_aexpr (bl
->address
,
2456 loc
->owner
->extra_string
);
2459 /* If we have a NULL bytecode expression, it means something
2460 went wrong or we have a null command expression. */
2461 if (!loc
->cmd_bytecode
)
2463 null_command_or_parse_error
= 1;
2469 /* If anything failed, then we're not doing target-side commands,
2471 if (null_command_or_parse_error
)
2473 for (bp_location
*loc
: loc_range
)
2474 if (is_breakpoint (loc
->owner
)
2475 && loc
->pspace
->num
== bl
->pspace
->num
)
2477 /* Only go as far as the first NULL bytecode is
2479 if (loc
->cmd_bytecode
== NULL
)
2482 loc
->cmd_bytecode
.reset ();
2486 /* No NULL commands or failed bytecode generation. Build a command
2487 list for all duplicate locations at this location's address.
2488 Note that here we must care for whether the breakpoint location
2489 types are considered duplicates, otherwise, say, if we have a
2490 software and hardware location at the same address, the target
2491 could end up running the commands twice. For the moment, we only
2492 support targets-side commands with dprintf, but it doesn't hurt
2493 to be pedantically correct in case that changes. */
2494 for (bp_location
*loc
: loc_range
)
2495 if (breakpoint_locations_match (bl
, loc
)
2496 && loc
->owner
->extra_string
2497 && is_breakpoint (loc
->owner
)
2498 && loc
->pspace
->num
== bl
->pspace
->num
2499 && loc
->owner
->enable_state
== bp_enabled
2501 && !loc
->disabled_by_cond
)
2503 /* Add the command to the vector. This will be used later
2504 to send the commands to the target. */
2505 bl
->target_info
.tcommands
.push_back (loc
->cmd_bytecode
.get ());
2508 bl
->target_info
.persist
= 0;
2509 /* Maybe flag this location as persistent. */
2510 if (bl
->owner
->type
== bp_dprintf
&& disconnected_dprintf
)
2511 bl
->target_info
.persist
= 1;
2514 /* Return the kind of breakpoint on address *ADDR. Get the kind
2515 of breakpoint according to ADDR except single-step breakpoint.
2516 Get the kind of single-step breakpoint according to the current
2520 breakpoint_kind (struct bp_location
*bl
, CORE_ADDR
*addr
)
2522 if (bl
->owner
->type
== bp_single_step
)
2524 struct thread_info
*thr
= find_thread_global_id (bl
->owner
->thread
);
2525 struct regcache
*regcache
;
2527 regcache
= get_thread_regcache (thr
);
2529 return gdbarch_breakpoint_kind_from_current_state (bl
->gdbarch
,
2533 return gdbarch_breakpoint_kind_from_pc (bl
->gdbarch
, addr
);
2536 /* Insert a low-level "breakpoint" of some type. BL is the breakpoint
2537 location. Any error messages are printed to TMP_ERROR_STREAM; and
2538 DISABLED_BREAKS, and HW_BREAKPOINT_ERROR are used to report problems.
2539 Returns 0 for success, 1 if the bp_location type is not supported or
2542 NOTE drow/2003-09-09: This routine could be broken down to an
2543 object-style method for each breakpoint or catchpoint type. */
2545 insert_bp_location (struct bp_location
*bl
,
2546 struct ui_file
*tmp_error_stream
,
2547 int *disabled_breaks
,
2548 int *hw_breakpoint_error
,
2549 int *hw_bp_error_explained_already
)
2551 gdb_exception bp_excpt
;
2553 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
2556 /* Note we don't initialize bl->target_info, as that wipes out
2557 the breakpoint location's shadow_contents if the breakpoint
2558 is still inserted at that location. This in turn breaks
2559 target_read_memory which depends on these buffers when
2560 a memory read is requested at the breakpoint location:
2561 Once the target_info has been wiped, we fail to see that
2562 we have a breakpoint inserted at that address and thus
2563 read the breakpoint instead of returning the data saved in
2564 the breakpoint location's shadow contents. */
2565 bl
->target_info
.reqstd_address
= bl
->address
;
2566 bl
->target_info
.placed_address_space
= bl
->pspace
->aspace
;
2567 bl
->target_info
.length
= bl
->length
;
2569 /* When working with target-side conditions, we must pass all the conditions
2570 for the same breakpoint address down to the target since GDB will not
2571 insert those locations. With a list of breakpoint conditions, the target
2572 can decide when to stop and notify GDB. */
2574 if (is_breakpoint (bl
->owner
))
2576 build_target_condition_list (bl
);
2577 build_target_command_list (bl
);
2578 /* Reset the modification marker. */
2579 bl
->needs_update
= 0;
2582 /* If "set breakpoint auto-hw" is "on" and a software breakpoint was
2583 set at a read-only address, then a breakpoint location will have
2584 been changed to hardware breakpoint before we get here. If it is
2585 "off" however, error out before actually trying to insert the
2586 breakpoint, with a nicer error message. */
2587 if (bl
->loc_type
== bp_loc_software_breakpoint
2588 && !automatic_hardware_breakpoints
)
2590 mem_region
*mr
= lookup_mem_region (bl
->address
);
2592 if (mr
!= nullptr && mr
->attrib
.mode
!= MEM_RW
)
2594 fprintf_unfiltered (tmp_error_stream
,
2595 _("Cannot insert breakpoint %d.\n"
2596 "Cannot set software breakpoint "
2597 "at read-only address %s\n"),
2599 paddress (bl
->gdbarch
, bl
->address
));
2604 if (bl
->loc_type
== bp_loc_software_breakpoint
2605 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
2607 /* First check to see if we have to handle an overlay. */
2608 if (overlay_debugging
== ovly_off
2609 || bl
->section
== NULL
2610 || !(section_is_overlay (bl
->section
)))
2612 /* No overlay handling: just set the breakpoint. */
2617 val
= bl
->owner
->ops
->insert_location (bl
);
2619 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2621 catch (gdb_exception
&e
)
2623 bp_excpt
= std::move (e
);
2628 /* This breakpoint is in an overlay section.
2629 Shall we set a breakpoint at the LMA? */
2630 if (!overlay_events_enabled
)
2632 /* Yes -- overlay event support is not active,
2633 so we must try to set a breakpoint at the LMA.
2634 This will not work for a hardware breakpoint. */
2635 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2636 warning (_("hardware breakpoint %d not supported in overlay!"),
2640 CORE_ADDR addr
= overlay_unmapped_address (bl
->address
,
2642 /* Set a software (trap) breakpoint at the LMA. */
2643 bl
->overlay_target_info
= bl
->target_info
;
2644 bl
->overlay_target_info
.reqstd_address
= addr
;
2646 /* No overlay handling: just set the breakpoint. */
2651 bl
->overlay_target_info
.kind
2652 = breakpoint_kind (bl
, &addr
);
2653 bl
->overlay_target_info
.placed_address
= addr
;
2654 val
= target_insert_breakpoint (bl
->gdbarch
,
2655 &bl
->overlay_target_info
);
2658 = gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2660 catch (gdb_exception
&e
)
2662 bp_excpt
= std::move (e
);
2665 if (bp_excpt
.reason
!= 0)
2666 fprintf_unfiltered (tmp_error_stream
,
2667 "Overlay breakpoint %d "
2668 "failed: in ROM?\n",
2672 /* Shall we set a breakpoint at the VMA? */
2673 if (section_is_mapped (bl
->section
))
2675 /* Yes. This overlay section is mapped into memory. */
2680 val
= bl
->owner
->ops
->insert_location (bl
);
2682 bp_excpt
= gdb_exception
{RETURN_ERROR
, GENERIC_ERROR
};
2684 catch (gdb_exception
&e
)
2686 bp_excpt
= std::move (e
);
2691 /* No. This breakpoint will not be inserted.
2692 No error, but do not mark the bp as 'inserted'. */
2697 if (bp_excpt
.reason
!= 0)
2699 /* Can't set the breakpoint. */
2701 /* If the target has closed then it will have deleted any
2702 breakpoints inserted within the target inferior, as a result
2703 any further attempts to interact with the breakpoint objects
2704 is not possible. Just rethrow the error. */
2705 if (bp_excpt
.error
== TARGET_CLOSE_ERROR
)
2707 gdb_assert (bl
->owner
!= nullptr);
2709 /* In some cases, we might not be able to insert a
2710 breakpoint in a shared library that has already been
2711 removed, but we have not yet processed the shlib unload
2712 event. Unfortunately, some targets that implement
2713 breakpoint insertion themselves can't tell why the
2714 breakpoint insertion failed (e.g., the remote target
2715 doesn't define error codes), so we must treat generic
2716 errors as memory errors. */
2717 if (bp_excpt
.reason
== RETURN_ERROR
2718 && (bp_excpt
.error
== GENERIC_ERROR
2719 || bp_excpt
.error
== MEMORY_ERROR
)
2720 && bl
->loc_type
== bp_loc_software_breakpoint
2721 && (solib_name_from_address (bl
->pspace
, bl
->address
)
2722 || shared_objfile_contains_address_p (bl
->pspace
,
2725 /* See also: disable_breakpoints_in_shlibs. */
2726 bl
->shlib_disabled
= 1;
2727 gdb::observers::breakpoint_modified
.notify (bl
->owner
);
2728 if (!*disabled_breaks
)
2730 fprintf_unfiltered (tmp_error_stream
,
2731 "Cannot insert breakpoint %d.\n",
2733 fprintf_unfiltered (tmp_error_stream
,
2734 "Temporarily disabling shared "
2735 "library breakpoints:\n");
2737 *disabled_breaks
= 1;
2738 fprintf_unfiltered (tmp_error_stream
,
2739 "breakpoint #%d\n", bl
->owner
->number
);
2744 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
2746 *hw_breakpoint_error
= 1;
2747 *hw_bp_error_explained_already
= bp_excpt
.message
!= NULL
;
2748 fprintf_unfiltered (tmp_error_stream
,
2749 "Cannot insert hardware breakpoint %d%s",
2751 bp_excpt
.message
? ":" : ".\n");
2752 if (bp_excpt
.message
!= NULL
)
2753 fprintf_unfiltered (tmp_error_stream
, "%s.\n",
2758 if (bp_excpt
.message
== NULL
)
2761 = memory_error_message (TARGET_XFER_E_IO
,
2762 bl
->gdbarch
, bl
->address
);
2764 fprintf_unfiltered (tmp_error_stream
,
2765 "Cannot insert breakpoint %d.\n"
2767 bl
->owner
->number
, message
.c_str ());
2771 fprintf_unfiltered (tmp_error_stream
,
2772 "Cannot insert breakpoint %d: %s\n",
2787 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
2788 /* NOTE drow/2003-09-08: This state only exists for removing
2789 watchpoints. It's not clear that it's necessary... */
2790 && bl
->owner
->disposition
!= disp_del_at_next_stop
)
2794 gdb_assert (bl
->owner
->ops
!= NULL
2795 && bl
->owner
->ops
->insert_location
!= NULL
);
2797 val
= bl
->owner
->ops
->insert_location (bl
);
2799 /* If trying to set a read-watchpoint, and it turns out it's not
2800 supported, try emulating one with an access watchpoint. */
2801 if (val
== 1 && bl
->watchpoint_type
== hw_read
)
2803 /* But don't try to insert it, if there's already another
2804 hw_access location that would be considered a duplicate
2806 for (bp_location
*loc
: all_bp_locations ())
2808 && loc
->watchpoint_type
== hw_access
2809 && watchpoint_locations_match (bl
, loc
))
2813 bl
->target_info
= loc
->target_info
;
2814 bl
->watchpoint_type
= hw_access
;
2821 bl
->watchpoint_type
= hw_access
;
2822 val
= bl
->owner
->ops
->insert_location (bl
);
2825 /* Back to the original value. */
2826 bl
->watchpoint_type
= hw_read
;
2830 bl
->inserted
= (val
== 0);
2833 else if (bl
->owner
->type
== bp_catchpoint
)
2837 gdb_assert (bl
->owner
->ops
!= NULL
2838 && bl
->owner
->ops
->insert_location
!= NULL
);
2840 val
= bl
->owner
->ops
->insert_location (bl
);
2843 bl
->owner
->enable_state
= bp_disabled
;
2847 Error inserting catchpoint %d: Your system does not support this type\n\
2848 of catchpoint."), bl
->owner
->number
);
2850 warning (_("Error inserting catchpoint %d."), bl
->owner
->number
);
2853 bl
->inserted
= (val
== 0);
2855 /* We've already printed an error message if there was a problem
2856 inserting this catchpoint, and we've disabled the catchpoint,
2857 so just return success. */
2864 /* This function is called when program space PSPACE is about to be
2865 deleted. It takes care of updating breakpoints to not reference
2869 breakpoint_program_space_exit (struct program_space
*pspace
)
2871 /* Remove any breakpoint that was set through this program space. */
2872 for (breakpoint
*b
: all_breakpoints_safe ())
2873 if (b
->pspace
== pspace
)
2874 delete_breakpoint (b
);
2876 /* Breakpoints set through other program spaces could have locations
2877 bound to PSPACE as well. Remove those. */
2878 for (bp_location
*loc
: all_bp_locations ())
2880 struct bp_location
*tmp
;
2882 if (loc
->pspace
== pspace
)
2884 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
2885 if (loc
->owner
->loc
== loc
)
2886 loc
->owner
->loc
= loc
->next
;
2888 for (tmp
= loc
->owner
->loc
; tmp
->next
!= NULL
; tmp
= tmp
->next
)
2889 if (tmp
->next
== loc
)
2891 tmp
->next
= loc
->next
;
2897 /* Now update the global location list to permanently delete the
2898 removed locations above. */
2899 update_global_location_list (UGLL_DONT_INSERT
);
2902 /* Make sure all breakpoints are inserted in inferior.
2903 Throws exception on any error.
2904 A breakpoint that is already inserted won't be inserted
2905 again, so calling this function twice is safe. */
2907 insert_breakpoints (void)
2909 for (breakpoint
*bpt
: all_breakpoints ())
2910 if (is_hardware_watchpoint (bpt
))
2912 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
2914 update_watchpoint (w
, 0 /* don't reparse. */);
2917 /* Updating watchpoints creates new locations, so update the global
2918 location list. Explicitly tell ugll to insert locations and
2919 ignore breakpoints_always_inserted_mode. Also,
2920 update_global_location_list tries to "upgrade" software
2921 breakpoints to hardware breakpoints to handle "set breakpoint
2922 auto-hw", so we need to call it even if we don't have new
2924 update_global_location_list (UGLL_INSERT
);
2927 /* This is used when we need to synch breakpoint conditions between GDB and the
2928 target. It is the case with deleting and disabling of breakpoints when using
2929 always-inserted mode. */
2932 update_inserted_breakpoint_locations (void)
2936 int disabled_breaks
= 0;
2937 int hw_breakpoint_error
= 0;
2938 int hw_bp_details_reported
= 0;
2940 string_file tmp_error_stream
;
2942 /* Explicitly mark the warning -- this will only be printed if
2943 there was an error. */
2944 tmp_error_stream
.puts ("Warning:\n");
2946 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
2948 for (bp_location
*bl
: all_bp_locations ())
2950 /* We only want to update software breakpoints and hardware
2952 if (!is_breakpoint (bl
->owner
))
2955 /* We only want to update locations that are already inserted
2956 and need updating. This is to avoid unwanted insertion during
2957 deletion of breakpoints. */
2958 if (!bl
->inserted
|| !bl
->needs_update
)
2961 switch_to_program_space_and_thread (bl
->pspace
);
2963 /* For targets that support global breakpoints, there's no need
2964 to select an inferior to insert breakpoint to. In fact, even
2965 if we aren't attached to any process yet, we should still
2966 insert breakpoints. */
2967 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
2968 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
2971 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
2972 &hw_breakpoint_error
, &hw_bp_details_reported
);
2979 target_terminal::ours_for_output ();
2980 error_stream (tmp_error_stream
);
2984 /* Used when starting or continuing the program. */
2987 insert_breakpoint_locations (void)
2991 int disabled_breaks
= 0;
2992 int hw_breakpoint_error
= 0;
2993 int hw_bp_error_explained_already
= 0;
2995 string_file tmp_error_stream
;
2997 /* Explicitly mark the warning -- this will only be printed if
2998 there was an error. */
2999 tmp_error_stream
.puts ("Warning:\n");
3001 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3003 for (bp_location
*bl
: all_bp_locations ())
3005 if (!should_be_inserted (bl
) || (bl
->inserted
&& !bl
->needs_update
))
3008 /* There is no point inserting thread-specific breakpoints if
3009 the thread no longer exists. ALL_BP_LOCATIONS bp_location
3010 has BL->OWNER always non-NULL. */
3011 if (bl
->owner
->thread
!= -1
3012 && !valid_global_thread_id (bl
->owner
->thread
))
3015 switch_to_program_space_and_thread (bl
->pspace
);
3017 /* For targets that support global breakpoints, there's no need
3018 to select an inferior to insert breakpoint to. In fact, even
3019 if we aren't attached to any process yet, we should still
3020 insert breakpoints. */
3021 if (!gdbarch_has_global_breakpoints (target_gdbarch ())
3022 && (inferior_ptid
== null_ptid
|| !target_has_execution ()))
3025 val
= insert_bp_location (bl
, &tmp_error_stream
, &disabled_breaks
,
3026 &hw_breakpoint_error
, &hw_bp_error_explained_already
);
3031 /* If we failed to insert all locations of a watchpoint, remove
3032 them, as half-inserted watchpoint is of limited use. */
3033 for (breakpoint
*bpt
: all_breakpoints ())
3035 int some_failed
= 0;
3037 if (!is_hardware_watchpoint (bpt
))
3040 if (!breakpoint_enabled (bpt
))
3043 if (bpt
->disposition
== disp_del_at_next_stop
)
3046 for (bp_location
*loc
: bpt
->locations ())
3047 if (!loc
->inserted
&& should_be_inserted (loc
))
3055 for (bp_location
*loc
: bpt
->locations ())
3057 remove_breakpoint (loc
);
3059 hw_breakpoint_error
= 1;
3060 tmp_error_stream
.printf ("Could not insert "
3061 "hardware watchpoint %d.\n",
3069 /* If a hardware breakpoint or watchpoint was inserted, add a
3070 message about possibly exhausted resources. */
3071 if (hw_breakpoint_error
&& !hw_bp_error_explained_already
)
3073 tmp_error_stream
.printf ("Could not insert hardware breakpoints:\n\
3074 You may have requested too many hardware breakpoints/watchpoints.\n");
3076 target_terminal::ours_for_output ();
3077 error_stream (tmp_error_stream
);
3081 /* Used when the program stops.
3082 Returns zero if successful, or non-zero if there was a problem
3083 removing a breakpoint location. */
3086 remove_breakpoints (void)
3090 for (bp_location
*bl
: all_bp_locations ())
3091 if (bl
->inserted
&& !is_tracepoint (bl
->owner
))
3092 val
|= remove_breakpoint (bl
);
3097 /* When a thread exits, remove breakpoints that are related to
3101 remove_threaded_breakpoints (struct thread_info
*tp
, int silent
)
3103 for (breakpoint
*b
: all_breakpoints_safe ())
3105 if (b
->thread
== tp
->global_num
&& user_breakpoint_p (b
))
3107 b
->disposition
= disp_del_at_next_stop
;
3109 printf_filtered (_("\
3110 Thread-specific breakpoint %d deleted - thread %s no longer in the thread list.\n"),
3111 b
->number
, print_thread_id (tp
));
3113 /* Hide it from the user. */
3119 /* See breakpoint.h. */
3122 remove_breakpoints_inf (inferior
*inf
)
3126 for (bp_location
*bl
: all_bp_locations ())
3128 if (bl
->pspace
!= inf
->pspace
)
3131 if (bl
->inserted
&& !bl
->target_info
.persist
)
3133 val
= remove_breakpoint (bl
);
3140 static int internal_breakpoint_number
= -1;
3142 /* Set the breakpoint number of B, depending on the value of INTERNAL.
3143 If INTERNAL is non-zero, the breakpoint number will be populated
3144 from internal_breakpoint_number and that variable decremented.
3145 Otherwise the breakpoint number will be populated from
3146 breakpoint_count and that value incremented. Internal breakpoints
3147 do not set the internal var bpnum. */
3149 set_breakpoint_number (int internal
, struct breakpoint
*b
)
3152 b
->number
= internal_breakpoint_number
--;
3155 set_breakpoint_count (breakpoint_count
+ 1);
3156 b
->number
= breakpoint_count
;
3160 static struct breakpoint
*
3161 create_internal_breakpoint (struct gdbarch
*gdbarch
,
3162 CORE_ADDR address
, enum bptype type
,
3163 const struct breakpoint_ops
*ops
)
3165 symtab_and_line sal
;
3167 sal
.section
= find_pc_overlay (sal
.pc
);
3168 sal
.pspace
= current_program_space
;
3170 breakpoint
*b
= set_raw_breakpoint (gdbarch
, sal
, type
, ops
);
3171 b
->number
= internal_breakpoint_number
--;
3172 b
->disposition
= disp_donttouch
;
3177 static const char *const longjmp_names
[] =
3179 "longjmp", "_longjmp", "siglongjmp", "_siglongjmp"
3181 #define NUM_LONGJMP_NAMES ARRAY_SIZE(longjmp_names)
3183 /* Per-objfile data private to breakpoint.c. */
3184 struct breakpoint_objfile_data
3186 /* Minimal symbol for "_ovly_debug_event" (if any). */
3187 struct bound_minimal_symbol overlay_msym
{};
3189 /* Minimal symbol(s) for "longjmp", "siglongjmp", etc. (if any). */
3190 struct bound_minimal_symbol longjmp_msym
[NUM_LONGJMP_NAMES
] {};
3192 /* True if we have looked for longjmp probes. */
3193 int longjmp_searched
= 0;
3195 /* SystemTap probe points for longjmp (if any). These are non-owning
3197 std::vector
<probe
*> longjmp_probes
;
3199 /* Minimal symbol for "std::terminate()" (if any). */
3200 struct bound_minimal_symbol terminate_msym
{};
3202 /* Minimal symbol for "_Unwind_DebugHook" (if any). */
3203 struct bound_minimal_symbol exception_msym
{};
3205 /* True if we have looked for exception probes. */
3206 int exception_searched
= 0;
3208 /* SystemTap probe points for unwinding (if any). These are non-owning
3210 std::vector
<probe
*> exception_probes
;
3213 static const struct objfile_key
<breakpoint_objfile_data
>
3214 breakpoint_objfile_key
;
3216 /* Minimal symbol not found sentinel. */
3217 static struct minimal_symbol msym_not_found
;
3219 /* Returns TRUE if MSYM point to the "not found" sentinel. */
3222 msym_not_found_p (const struct minimal_symbol
*msym
)
3224 return msym
== &msym_not_found
;
3227 /* Return per-objfile data needed by breakpoint.c.
3228 Allocate the data if necessary. */
3230 static struct breakpoint_objfile_data
*
3231 get_breakpoint_objfile_data (struct objfile
*objfile
)
3233 struct breakpoint_objfile_data
*bp_objfile_data
;
3235 bp_objfile_data
= breakpoint_objfile_key
.get (objfile
);
3236 if (bp_objfile_data
== NULL
)
3237 bp_objfile_data
= breakpoint_objfile_key
.emplace (objfile
);
3238 return bp_objfile_data
;
3242 create_overlay_event_breakpoint (void)
3244 const char *const func_name
= "_ovly_debug_event";
3246 for (objfile
*objfile
: current_program_space
->objfiles ())
3248 struct breakpoint
*b
;
3249 struct breakpoint_objfile_data
*bp_objfile_data
;
3251 struct explicit_location explicit_loc
;
3253 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3255 if (msym_not_found_p (bp_objfile_data
->overlay_msym
.minsym
))
3258 if (bp_objfile_data
->overlay_msym
.minsym
== NULL
)
3260 struct bound_minimal_symbol m
;
3262 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3263 if (m
.minsym
== NULL
)
3265 /* Avoid future lookups in this objfile. */
3266 bp_objfile_data
->overlay_msym
.minsym
= &msym_not_found
;
3269 bp_objfile_data
->overlay_msym
= m
;
3272 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->overlay_msym
);
3273 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3275 &internal_breakpoint_ops
);
3276 initialize_explicit_location (&explicit_loc
);
3277 explicit_loc
.function_name
= ASTRDUP (func_name
);
3278 b
->location
= new_explicit_location (&explicit_loc
);
3280 if (overlay_debugging
== ovly_auto
)
3282 b
->enable_state
= bp_enabled
;
3283 overlay_events_enabled
= 1;
3287 b
->enable_state
= bp_disabled
;
3288 overlay_events_enabled
= 0;
3293 /* Install a master longjmp breakpoint for OBJFILE using a probe. Return
3294 true if a breakpoint was installed. */
3297 create_longjmp_master_breakpoint_probe (objfile
*objfile
)
3299 struct gdbarch
*gdbarch
= objfile
->arch ();
3300 struct breakpoint_objfile_data
*bp_objfile_data
3301 = get_breakpoint_objfile_data (objfile
);
3303 if (!bp_objfile_data
->longjmp_searched
)
3305 std::vector
<probe
*> ret
3306 = find_probes_in_objfile (objfile
, "libc", "longjmp");
3310 /* We are only interested in checking one element. */
3313 if (!p
->can_evaluate_arguments ())
3315 /* We cannot use the probe interface here,
3316 because it does not know how to evaluate
3321 bp_objfile_data
->longjmp_probes
= ret
;
3322 bp_objfile_data
->longjmp_searched
= 1;
3325 if (bp_objfile_data
->longjmp_probes
.empty ())
3328 for (probe
*p
: bp_objfile_data
->longjmp_probes
)
3330 struct breakpoint
*b
;
3332 b
= create_internal_breakpoint (gdbarch
,
3333 p
->get_relocated_address (objfile
),
3335 &internal_breakpoint_ops
);
3336 b
->location
= new_probe_location ("-probe-stap libc:longjmp");
3337 b
->enable_state
= bp_disabled
;
3343 /* Install master longjmp breakpoints for OBJFILE using longjmp_names.
3344 Return true if at least one breakpoint was installed. */
3347 create_longjmp_master_breakpoint_names (objfile
*objfile
)
3349 struct gdbarch
*gdbarch
= objfile
->arch ();
3350 if (!gdbarch_get_longjmp_target_p (gdbarch
))
3353 struct breakpoint_objfile_data
*bp_objfile_data
3354 = get_breakpoint_objfile_data (objfile
);
3355 unsigned int installed_bp
= 0;
3357 for (int i
= 0; i
< NUM_LONGJMP_NAMES
; i
++)
3359 struct breakpoint
*b
;
3360 const char *func_name
;
3362 struct explicit_location explicit_loc
;
3364 if (msym_not_found_p (bp_objfile_data
->longjmp_msym
[i
].minsym
))
3367 func_name
= longjmp_names
[i
];
3368 if (bp_objfile_data
->longjmp_msym
[i
].minsym
== NULL
)
3370 struct bound_minimal_symbol m
;
3372 m
= lookup_minimal_symbol_text (func_name
, objfile
);
3373 if (m
.minsym
== NULL
)
3375 /* Prevent future lookups in this objfile. */
3376 bp_objfile_data
->longjmp_msym
[i
].minsym
= &msym_not_found
;
3379 bp_objfile_data
->longjmp_msym
[i
] = m
;
3382 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->longjmp_msym
[i
]);
3383 b
= create_internal_breakpoint (gdbarch
, addr
, bp_longjmp_master
,
3384 &internal_breakpoint_ops
);
3385 initialize_explicit_location (&explicit_loc
);
3386 explicit_loc
.function_name
= ASTRDUP (func_name
);
3387 b
->location
= new_explicit_location (&explicit_loc
);
3388 b
->enable_state
= bp_disabled
;
3392 return installed_bp
> 0;
3395 /* Create a master longjmp breakpoint. */
3398 create_longjmp_master_breakpoint (void)
3400 scoped_restore_current_program_space restore_pspace
;
3402 for (struct program_space
*pspace
: program_spaces
)
3404 set_current_program_space (pspace
);
3406 for (objfile
*obj
: current_program_space
->objfiles ())
3408 /* Skip separate debug object, it's handled in the loop below. */
3409 if (obj
->separate_debug_objfile_backlink
!= nullptr)
3412 /* Try a probe kind breakpoint on main objfile. */
3413 if (create_longjmp_master_breakpoint_probe (obj
))
3416 /* Try longjmp_names kind breakpoints on main and separate_debug
3418 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3419 if (create_longjmp_master_breakpoint_names (debug_objfile
))
3425 /* Create a master std::terminate breakpoint. */
3427 create_std_terminate_master_breakpoint (void)
3429 const char *const func_name
= "std::terminate()";
3431 scoped_restore_current_program_space restore_pspace
;
3433 for (struct program_space
*pspace
: program_spaces
)
3437 set_current_program_space (pspace
);
3439 for (objfile
*objfile
: current_program_space
->objfiles ())
3441 struct breakpoint
*b
;
3442 struct breakpoint_objfile_data
*bp_objfile_data
;
3443 struct explicit_location explicit_loc
;
3445 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3447 if (msym_not_found_p (bp_objfile_data
->terminate_msym
.minsym
))
3450 if (bp_objfile_data
->terminate_msym
.minsym
== NULL
)
3452 struct bound_minimal_symbol m
;
3454 m
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3455 if (m
.minsym
== NULL
|| (MSYMBOL_TYPE (m
.minsym
) != mst_text
3456 && MSYMBOL_TYPE (m
.minsym
) != mst_file_text
))
3458 /* Prevent future lookups in this objfile. */
3459 bp_objfile_data
->terminate_msym
.minsym
= &msym_not_found
;
3462 bp_objfile_data
->terminate_msym
= m
;
3465 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->terminate_msym
);
3466 b
= create_internal_breakpoint (objfile
->arch (), addr
,
3467 bp_std_terminate_master
,
3468 &internal_breakpoint_ops
);
3469 initialize_explicit_location (&explicit_loc
);
3470 explicit_loc
.function_name
= ASTRDUP (func_name
);
3471 b
->location
= new_explicit_location (&explicit_loc
);
3472 b
->enable_state
= bp_disabled
;
3477 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using a
3478 probe. Return true if a breakpoint was installed. */
3481 create_exception_master_breakpoint_probe (objfile
*objfile
)
3483 struct breakpoint
*b
;
3484 struct gdbarch
*gdbarch
;
3485 struct breakpoint_objfile_data
*bp_objfile_data
;
3487 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3489 /* We prefer the SystemTap probe point if it exists. */
3490 if (!bp_objfile_data
->exception_searched
)
3492 std::vector
<probe
*> ret
3493 = find_probes_in_objfile (objfile
, "libgcc", "unwind");
3497 /* We are only interested in checking one element. */
3500 if (!p
->can_evaluate_arguments ())
3502 /* We cannot use the probe interface here, because it does
3503 not know how to evaluate arguments. */
3507 bp_objfile_data
->exception_probes
= ret
;
3508 bp_objfile_data
->exception_searched
= 1;
3511 if (bp_objfile_data
->exception_probes
.empty ())
3514 gdbarch
= objfile
->arch ();
3516 for (probe
*p
: bp_objfile_data
->exception_probes
)
3518 b
= create_internal_breakpoint (gdbarch
,
3519 p
->get_relocated_address (objfile
),
3520 bp_exception_master
,
3521 &internal_breakpoint_ops
);
3522 b
->location
= new_probe_location ("-probe-stap libgcc:unwind");
3523 b
->enable_state
= bp_disabled
;
3529 /* Install a master breakpoint on the unwinder's debug hook for OBJFILE using
3530 _Unwind_DebugHook. Return true if a breakpoint was installed. */
3533 create_exception_master_breakpoint_hook (objfile
*objfile
)
3535 const char *const func_name
= "_Unwind_DebugHook";
3536 struct breakpoint
*b
;
3537 struct gdbarch
*gdbarch
;
3538 struct breakpoint_objfile_data
*bp_objfile_data
;
3540 struct explicit_location explicit_loc
;
3542 bp_objfile_data
= get_breakpoint_objfile_data (objfile
);
3544 if (msym_not_found_p (bp_objfile_data
->exception_msym
.minsym
))
3547 gdbarch
= objfile
->arch ();
3549 if (bp_objfile_data
->exception_msym
.minsym
== NULL
)
3551 struct bound_minimal_symbol debug_hook
;
3553 debug_hook
= lookup_minimal_symbol (func_name
, NULL
, objfile
);
3554 if (debug_hook
.minsym
== NULL
)
3556 bp_objfile_data
->exception_msym
.minsym
= &msym_not_found
;
3560 bp_objfile_data
->exception_msym
= debug_hook
;
3563 addr
= BMSYMBOL_VALUE_ADDRESS (bp_objfile_data
->exception_msym
);
3564 addr
= gdbarch_convert_from_func_ptr_addr
3565 (gdbarch
, addr
, current_inferior ()->top_target ());
3566 b
= create_internal_breakpoint (gdbarch
, addr
, bp_exception_master
,
3567 &internal_breakpoint_ops
);
3568 initialize_explicit_location (&explicit_loc
);
3569 explicit_loc
.function_name
= ASTRDUP (func_name
);
3570 b
->location
= new_explicit_location (&explicit_loc
);
3571 b
->enable_state
= bp_disabled
;
3576 /* Install a master breakpoint on the unwinder's debug hook. */
3579 create_exception_master_breakpoint (void)
3581 for (objfile
*obj
: current_program_space
->objfiles ())
3583 /* Skip separate debug object. */
3584 if (obj
->separate_debug_objfile_backlink
)
3587 /* Try a probe kind breakpoint. */
3588 if (create_exception_master_breakpoint_probe (obj
))
3591 /* Iterate over main and separate debug objects and try an
3592 _Unwind_DebugHook kind breakpoint. */
3593 for (objfile
*debug_objfile
: obj
->separate_debug_objfiles ())
3594 if (create_exception_master_breakpoint_hook (debug_objfile
))
3599 /* Does B have a location spec? */
3602 breakpoint_event_location_empty_p (const struct breakpoint
*b
)
3604 return b
->location
!= NULL
&& event_location_empty_p (b
->location
.get ());
3608 update_breakpoints_after_exec (void)
3610 /* We're about to delete breakpoints from GDB's lists. If the
3611 INSERTED flag is true, GDB will try to lift the breakpoints by
3612 writing the breakpoints' "shadow contents" back into memory. The
3613 "shadow contents" are NOT valid after an exec, so GDB should not
3614 do that. Instead, the target is responsible from marking
3615 breakpoints out as soon as it detects an exec. We don't do that
3616 here instead, because there may be other attempts to delete
3617 breakpoints after detecting an exec and before reaching here. */
3618 for (bp_location
*bploc
: all_bp_locations ())
3619 if (bploc
->pspace
== current_program_space
)
3620 gdb_assert (!bploc
->inserted
);
3622 for (breakpoint
*b
: all_breakpoints_safe ())
3624 if (b
->pspace
!= current_program_space
)
3627 /* Solib breakpoints must be explicitly reset after an exec(). */
3628 if (b
->type
== bp_shlib_event
)
3630 delete_breakpoint (b
);
3634 /* JIT breakpoints must be explicitly reset after an exec(). */
3635 if (b
->type
== bp_jit_event
)
3637 delete_breakpoint (b
);
3641 /* Thread event breakpoints must be set anew after an exec(),
3642 as must overlay event and longjmp master breakpoints. */
3643 if (b
->type
== bp_thread_event
|| b
->type
== bp_overlay_event
3644 || b
->type
== bp_longjmp_master
|| b
->type
== bp_std_terminate_master
3645 || b
->type
== bp_exception_master
)
3647 delete_breakpoint (b
);
3651 /* Step-resume breakpoints are meaningless after an exec(). */
3652 if (b
->type
== bp_step_resume
|| b
->type
== bp_hp_step_resume
)
3654 delete_breakpoint (b
);
3658 /* Just like single-step breakpoints. */
3659 if (b
->type
== bp_single_step
)
3661 delete_breakpoint (b
);
3665 /* Longjmp and longjmp-resume breakpoints are also meaningless
3667 if (b
->type
== bp_longjmp
|| b
->type
== bp_longjmp_resume
3668 || b
->type
== bp_longjmp_call_dummy
3669 || b
->type
== bp_exception
|| b
->type
== bp_exception_resume
)
3671 delete_breakpoint (b
);
3675 if (b
->type
== bp_catchpoint
)
3677 /* For now, none of the bp_catchpoint breakpoints need to
3678 do anything at this point. In the future, if some of
3679 the catchpoints need to something, we will need to add
3680 a new method, and call this method from here. */
3684 /* bp_finish is a special case. The only way we ought to be able
3685 to see one of these when an exec() has happened, is if the user
3686 caught a vfork, and then said "finish". Ordinarily a finish just
3687 carries them to the call-site of the current callee, by setting
3688 a temporary bp there and resuming. But in this case, the finish
3689 will carry them entirely through the vfork & exec.
3691 We don't want to allow a bp_finish to remain inserted now. But
3692 we can't safely delete it, 'cause finish_command has a handle to
3693 the bp on a bpstat, and will later want to delete it. There's a
3694 chance (and I've seen it happen) that if we delete the bp_finish
3695 here, that its storage will get reused by the time finish_command
3696 gets 'round to deleting the "use to be a bp_finish" breakpoint.
3697 We really must allow finish_command to delete a bp_finish.
3699 In the absence of a general solution for the "how do we know
3700 it's safe to delete something others may have handles to?"
3701 problem, what we'll do here is just uninsert the bp_finish, and
3702 let finish_command delete it.
3704 (We know the bp_finish is "doomed" in the sense that it's
3705 momentary, and will be deleted as soon as finish_command sees
3706 the inferior stopped. So it doesn't matter that the bp's
3707 address is probably bogus in the new a.out, unlike e.g., the
3708 solib breakpoints.) */
3710 if (b
->type
== bp_finish
)
3715 /* Without a symbolic address, we have little hope of the
3716 pre-exec() address meaning the same thing in the post-exec()
3718 if (breakpoint_event_location_empty_p (b
))
3720 delete_breakpoint (b
);
3727 detach_breakpoints (ptid_t ptid
)
3730 scoped_restore save_inferior_ptid
= make_scoped_restore (&inferior_ptid
);
3731 struct inferior
*inf
= current_inferior ();
3733 if (ptid
.pid () == inferior_ptid
.pid ())
3734 error (_("Cannot detach breakpoints of inferior_ptid"));
3736 /* Set inferior_ptid; remove_breakpoint_1 uses this global. */
3737 inferior_ptid
= ptid
;
3738 for (bp_location
*bl
: all_bp_locations ())
3740 if (bl
->pspace
!= inf
->pspace
)
3743 /* This function must physically remove breakpoints locations
3744 from the specified ptid, without modifying the breakpoint
3745 package's state. Locations of type bp_loc_other are only
3746 maintained at GDB side. So, there is no need to remove
3747 these bp_loc_other locations. Moreover, removing these
3748 would modify the breakpoint package's state. */
3749 if (bl
->loc_type
== bp_loc_other
)
3753 val
|= remove_breakpoint_1 (bl
, DETACH_BREAKPOINT
);
3759 /* Remove the breakpoint location BL from the current address space.
3760 Note that this is used to detach breakpoints from a child fork.
3761 When we get here, the child isn't in the inferior list, and neither
3762 do we have objects to represent its address space --- we should
3763 *not* look at bl->pspace->aspace here. */
3766 remove_breakpoint_1 (struct bp_location
*bl
, enum remove_bp_reason reason
)
3770 /* BL is never in moribund_locations by our callers. */
3771 gdb_assert (bl
->owner
!= NULL
);
3773 /* The type of none suggests that owner is actually deleted.
3774 This should not ever happen. */
3775 gdb_assert (bl
->owner
->type
!= bp_none
);
3777 if (bl
->loc_type
== bp_loc_software_breakpoint
3778 || bl
->loc_type
== bp_loc_hardware_breakpoint
)
3780 /* "Normal" instruction breakpoint: either the standard
3781 trap-instruction bp (bp_breakpoint), or a
3782 bp_hardware_breakpoint. */
3784 /* First check to see if we have to handle an overlay. */
3785 if (overlay_debugging
== ovly_off
3786 || bl
->section
== NULL
3787 || !(section_is_overlay (bl
->section
)))
3789 /* No overlay handling: just remove the breakpoint. */
3791 /* If we're trying to uninsert a memory breakpoint that we
3792 know is set in a dynamic object that is marked
3793 shlib_disabled, then either the dynamic object was
3794 removed with "remove-symbol-file" or with
3795 "nosharedlibrary". In the former case, we don't know
3796 whether another dynamic object might have loaded over the
3797 breakpoint's address -- the user might well let us know
3798 about it next with add-symbol-file (the whole point of
3799 add-symbol-file is letting the user manually maintain a
3800 list of dynamically loaded objects). If we have the
3801 breakpoint's shadow memory, that is, this is a software
3802 breakpoint managed by GDB, check whether the breakpoint
3803 is still inserted in memory, to avoid overwriting wrong
3804 code with stale saved shadow contents. Note that HW
3805 breakpoints don't have shadow memory, as they're
3806 implemented using a mechanism that is not dependent on
3807 being able to modify the target's memory, and as such
3808 they should always be removed. */
3809 if (bl
->shlib_disabled
3810 && bl
->target_info
.shadow_len
!= 0
3811 && !memory_validate_breakpoint (bl
->gdbarch
, &bl
->target_info
))
3814 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3818 /* This breakpoint is in an overlay section.
3819 Did we set a breakpoint at the LMA? */
3820 if (!overlay_events_enabled
)
3822 /* Yes -- overlay event support is not active, so we
3823 should have set a breakpoint at the LMA. Remove it.
3825 /* Ignore any failures: if the LMA is in ROM, we will
3826 have already warned when we failed to insert it. */
3827 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
3828 target_remove_hw_breakpoint (bl
->gdbarch
,
3829 &bl
->overlay_target_info
);
3831 target_remove_breakpoint (bl
->gdbarch
,
3832 &bl
->overlay_target_info
,
3835 /* Did we set a breakpoint at the VMA?
3836 If so, we will have marked the breakpoint 'inserted'. */
3839 /* Yes -- remove it. Previously we did not bother to
3840 remove the breakpoint if the section had been
3841 unmapped, but let's not rely on that being safe. We
3842 don't know what the overlay manager might do. */
3844 /* However, we should remove *software* breakpoints only
3845 if the section is still mapped, or else we overwrite
3846 wrong code with the saved shadow contents. */
3847 if (bl
->loc_type
== bp_loc_hardware_breakpoint
3848 || section_is_mapped (bl
->section
))
3849 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3855 /* No -- not inserted, so no need to remove. No error. */
3860 /* In some cases, we might not be able to remove a breakpoint in
3861 a shared library that has already been removed, but we have
3862 not yet processed the shlib unload event. Similarly for an
3863 unloaded add-symbol-file object - the user might not yet have
3864 had the chance to remove-symbol-file it. shlib_disabled will
3865 be set if the library/object has already been removed, but
3866 the breakpoint hasn't been uninserted yet, e.g., after
3867 "nosharedlibrary" or "remove-symbol-file" with breakpoints
3868 always-inserted mode. */
3870 && (bl
->loc_type
== bp_loc_software_breakpoint
3871 && (bl
->shlib_disabled
3872 || solib_name_from_address (bl
->pspace
, bl
->address
)
3873 || shared_objfile_contains_address_p (bl
->pspace
,
3879 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3881 else if (bl
->loc_type
== bp_loc_hardware_watchpoint
)
3883 gdb_assert (bl
->owner
->ops
!= NULL
3884 && bl
->owner
->ops
->remove_location
!= NULL
);
3886 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3887 bl
->owner
->ops
->remove_location (bl
, reason
);
3889 /* Failure to remove any of the hardware watchpoints comes here. */
3890 if (reason
== REMOVE_BREAKPOINT
&& bl
->inserted
)
3891 warning (_("Could not remove hardware watchpoint %d."),
3894 else if (bl
->owner
->type
== bp_catchpoint
3895 && breakpoint_enabled (bl
->owner
)
3898 gdb_assert (bl
->owner
->ops
!= NULL
3899 && bl
->owner
->ops
->remove_location
!= NULL
);
3901 val
= bl
->owner
->ops
->remove_location (bl
, reason
);
3905 bl
->inserted
= (reason
== DETACH_BREAKPOINT
);
3912 remove_breakpoint (struct bp_location
*bl
)
3914 /* BL is never in moribund_locations by our callers. */
3915 gdb_assert (bl
->owner
!= NULL
);
3917 /* The type of none suggests that owner is actually deleted.
3918 This should not ever happen. */
3919 gdb_assert (bl
->owner
->type
!= bp_none
);
3921 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
3923 switch_to_program_space_and_thread (bl
->pspace
);
3925 return remove_breakpoint_1 (bl
, REMOVE_BREAKPOINT
);
3928 /* Clear the "inserted" flag in all breakpoints. */
3931 mark_breakpoints_out (void)
3933 for (bp_location
*bl
: all_bp_locations ())
3934 if (bl
->pspace
== current_program_space
)
3938 /* Clear the "inserted" flag in all breakpoints and delete any
3939 breakpoints which should go away between runs of the program.
3941 Plus other such housekeeping that has to be done for breakpoints
3944 Note: this function gets called at the end of a run (by
3945 generic_mourn_inferior) and when a run begins (by
3946 init_wait_for_inferior). */
3951 breakpoint_init_inferior (enum inf_context context
)
3953 struct program_space
*pspace
= current_program_space
;
3955 /* If breakpoint locations are shared across processes, then there's
3957 if (gdbarch_has_global_breakpoints (target_gdbarch ()))
3960 mark_breakpoints_out ();
3962 for (breakpoint
*b
: all_breakpoints_safe ())
3964 if (b
->loc
&& b
->loc
->pspace
!= pspace
)
3970 case bp_longjmp_call_dummy
:
3972 /* If the call dummy breakpoint is at the entry point it will
3973 cause problems when the inferior is rerun, so we better get
3976 case bp_watchpoint_scope
:
3978 /* Also get rid of scope breakpoints. */
3980 case bp_shlib_event
:
3982 /* Also remove solib event breakpoints. Their addresses may
3983 have changed since the last time we ran the program.
3984 Actually we may now be debugging against different target;
3985 and so the solib backend that installed this breakpoint may
3986 not be used in by the target. E.g.,
3988 (gdb) file prog-linux
3989 (gdb) run # native linux target
3992 (gdb) file prog-win.exe
3993 (gdb) tar rem :9999 # remote Windows gdbserver.
3996 case bp_step_resume
:
3998 /* Also remove step-resume breakpoints. */
4000 case bp_single_step
:
4002 /* Also remove single-step breakpoints. */
4004 delete_breakpoint (b
);
4008 case bp_hardware_watchpoint
:
4009 case bp_read_watchpoint
:
4010 case bp_access_watchpoint
:
4012 struct watchpoint
*w
= (struct watchpoint
*) b
;
4014 /* Likewise for watchpoints on local expressions. */
4015 if (w
->exp_valid_block
!= NULL
)
4016 delete_breakpoint (b
);
4019 /* Get rid of existing locations, which are no longer
4020 valid. New ones will be created in
4021 update_watchpoint, when the inferior is restarted.
4022 The next update_global_location_list call will
4023 garbage collect them. */
4026 if (context
== inf_starting
)
4028 /* Reset val field to force reread of starting value in
4029 insert_breakpoints. */
4030 w
->val
.reset (nullptr);
4031 w
->val_valid
= false;
4041 /* Get rid of the moribund locations. */
4042 for (bp_location
*bl
: moribund_locations
)
4043 decref_bp_location (&bl
);
4044 moribund_locations
.clear ();
4047 /* These functions concern about actual breakpoints inserted in the
4048 target --- to e.g. check if we need to do decr_pc adjustment or if
4049 we need to hop over the bkpt --- so we check for address space
4050 match, not program space. */
4052 /* breakpoint_here_p (PC) returns non-zero if an enabled breakpoint
4053 exists at PC. It returns ordinary_breakpoint_here if it's an
4054 ordinary breakpoint, or permanent_breakpoint_here if it's a
4055 permanent breakpoint.
4056 - When continuing from a location with an ordinary breakpoint, we
4057 actually single step once before calling insert_breakpoints.
4058 - When continuing from a location with a permanent breakpoint, we
4059 need to use the `SKIP_PERMANENT_BREAKPOINT' macro, provided by
4060 the target, to advance the PC past the breakpoint. */
4062 enum breakpoint_here
4063 breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4065 int any_breakpoint_here
= 0;
4067 for (bp_location
*bl
: all_bp_locations ())
4069 if (bl
->loc_type
!= bp_loc_software_breakpoint
4070 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4073 /* ALL_BP_LOCATIONS bp_location has BL->OWNER always non-NULL. */
4074 if ((breakpoint_enabled (bl
->owner
)
4076 && breakpoint_location_address_match (bl
, aspace
, pc
))
4078 if (overlay_debugging
4079 && section_is_overlay (bl
->section
)
4080 && !section_is_mapped (bl
->section
))
4081 continue; /* unmapped overlay -- can't be a match */
4082 else if (bl
->permanent
)
4083 return permanent_breakpoint_here
;
4085 any_breakpoint_here
= 1;
4089 return any_breakpoint_here
? ordinary_breakpoint_here
: no_breakpoint_here
;
4092 /* See breakpoint.h. */
4095 breakpoint_in_range_p (const address_space
*aspace
,
4096 CORE_ADDR addr
, ULONGEST len
)
4098 for (bp_location
*bl
: all_bp_locations ())
4100 if (bl
->loc_type
!= bp_loc_software_breakpoint
4101 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4104 if ((breakpoint_enabled (bl
->owner
)
4106 && breakpoint_location_address_range_overlap (bl
, aspace
,
4109 if (overlay_debugging
4110 && section_is_overlay (bl
->section
)
4111 && !section_is_mapped (bl
->section
))
4113 /* Unmapped overlay -- can't be a match. */
4124 /* Return true if there's a moribund breakpoint at PC. */
4127 moribund_breakpoint_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4129 for (bp_location
*loc
: moribund_locations
)
4130 if (breakpoint_location_address_match (loc
, aspace
, pc
))
4136 /* Returns non-zero iff BL is inserted at PC, in address space
4140 bp_location_inserted_here_p (struct bp_location
*bl
,
4141 const address_space
*aspace
, CORE_ADDR pc
)
4144 && breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
4147 if (overlay_debugging
4148 && section_is_overlay (bl
->section
)
4149 && !section_is_mapped (bl
->section
))
4150 return 0; /* unmapped overlay -- can't be a match */
4157 /* Returns non-zero iff there's a breakpoint inserted at PC. */
4160 breakpoint_inserted_here_p (const address_space
*aspace
, CORE_ADDR pc
)
4162 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4164 if (bl
->loc_type
!= bp_loc_software_breakpoint
4165 && bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4168 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4174 /* This function returns non-zero iff there is a software breakpoint
4178 software_breakpoint_inserted_here_p (const address_space
*aspace
,
4181 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4183 if (bl
->loc_type
!= bp_loc_software_breakpoint
)
4186 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4193 /* See breakpoint.h. */
4196 hardware_breakpoint_inserted_here_p (const address_space
*aspace
,
4199 for (bp_location
*bl
: all_bp_locations_at_addr (pc
))
4201 if (bl
->loc_type
!= bp_loc_hardware_breakpoint
)
4204 if (bp_location_inserted_here_p (bl
, aspace
, pc
))
4212 hardware_watchpoint_inserted_in_range (const address_space
*aspace
,
4213 CORE_ADDR addr
, ULONGEST len
)
4215 for (breakpoint
*bpt
: all_breakpoints ())
4217 if (bpt
->type
!= bp_hardware_watchpoint
4218 && bpt
->type
!= bp_access_watchpoint
)
4221 if (!breakpoint_enabled (bpt
))
4224 for (bp_location
*loc
: bpt
->locations ())
4225 if (loc
->pspace
->aspace
== aspace
&& loc
->inserted
)
4229 /* Check for intersection. */
4230 l
= std::max
<CORE_ADDR
> (loc
->address
, addr
);
4231 h
= std::min
<CORE_ADDR
> (loc
->address
+ loc
->length
, addr
+ len
);
4239 /* See breakpoint.h. */
4242 is_catchpoint (struct breakpoint
*b
)
4244 return (b
->type
== bp_catchpoint
);
4247 /* Clear a bpstat so that it says we are not at any breakpoint.
4248 Also free any storage that is part of a bpstat. */
4251 bpstat_clear (bpstat
*bsp
)
4268 bpstats::bpstats (const bpstats
&other
)
4270 bp_location_at (other
.bp_location_at
),
4271 breakpoint_at (other
.breakpoint_at
),
4272 commands (other
.commands
),
4273 print (other
.print
),
4275 print_it (other
.print_it
)
4277 if (other
.old_val
!= NULL
)
4278 old_val
= release_value (value_copy (other
.old_val
.get ()));
4281 /* Return a copy of a bpstat. Like "bs1 = bs2" but all storage that
4282 is part of the bpstat is copied as well. */
4285 bpstat_copy (bpstat bs
)
4289 bpstat retval
= NULL
;
4294 for (; bs
!= NULL
; bs
= bs
->next
)
4296 tmp
= new bpstats (*bs
);
4299 /* This is the first thing in the chain. */
4309 /* Find the bpstat associated with this breakpoint. */
4312 bpstat_find_breakpoint (bpstat bsp
, struct breakpoint
*breakpoint
)
4317 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4319 if (bsp
->breakpoint_at
== breakpoint
)
4325 /* See breakpoint.h. */
4328 bpstat_explains_signal (bpstat bsp
, enum gdb_signal sig
)
4330 for (; bsp
!= NULL
; bsp
= bsp
->next
)
4332 if (bsp
->breakpoint_at
== NULL
)
4334 /* A moribund location can never explain a signal other than
4336 if (sig
== GDB_SIGNAL_TRAP
)
4341 if (bsp
->breakpoint_at
->ops
->explains_signal (bsp
->breakpoint_at
,
4350 /* Put in *NUM the breakpoint number of the first breakpoint we are
4351 stopped at. *BSP upon return is a bpstat which points to the
4352 remaining breakpoints stopped at (but which is not guaranteed to be
4353 good for anything but further calls to bpstat_num).
4355 Return 0 if passed a bpstat which does not indicate any breakpoints.
4356 Return -1 if stopped at a breakpoint that has been deleted since
4358 Return 1 otherwise. */
4361 bpstat_num (bpstat
*bsp
, int *num
)
4363 struct breakpoint
*b
;
4366 return 0; /* No more breakpoint values */
4368 /* We assume we'll never have several bpstats that correspond to a
4369 single breakpoint -- otherwise, this function might return the
4370 same number more than once and this will look ugly. */
4371 b
= (*bsp
)->breakpoint_at
;
4372 *bsp
= (*bsp
)->next
;
4374 return -1; /* breakpoint that's been deleted since */
4376 *num
= b
->number
; /* We have its number */
4380 /* See breakpoint.h. */
4383 bpstat_clear_actions (void)
4387 if (inferior_ptid
== null_ptid
)
4390 thread_info
*tp
= inferior_thread ();
4391 for (bs
= tp
->control
.stop_bpstat
; bs
!= NULL
; bs
= bs
->next
)
4393 bs
->commands
= NULL
;
4394 bs
->old_val
.reset (nullptr);
4398 /* Called when a command is about to proceed the inferior. */
4401 breakpoint_about_to_proceed (void)
4403 if (inferior_ptid
!= null_ptid
)
4405 struct thread_info
*tp
= inferior_thread ();
4407 /* Allow inferior function calls in breakpoint commands to not
4408 interrupt the command list. When the call finishes
4409 successfully, the inferior will be standing at the same
4410 breakpoint as if nothing happened. */
4411 if (tp
->control
.in_infcall
)
4415 breakpoint_proceeded
= 1;
4418 /* Return non-zero iff CMD as the first line of a command sequence is `silent'
4419 or its equivalent. */
4422 command_line_is_silent (struct command_line
*cmd
)
4424 return cmd
&& (strcmp ("silent", cmd
->line
) == 0);
4427 /* Execute all the commands associated with all the breakpoints at
4428 this location. Any of these commands could cause the process to
4429 proceed beyond this point, etc. We look out for such changes by
4430 checking the global "breakpoint_proceeded" after each command.
4432 Returns true if a breakpoint command resumed the inferior. In that
4433 case, it is the caller's responsibility to recall it again with the
4434 bpstat of the current thread. */
4437 bpstat_do_actions_1 (bpstat
*bsp
)
4442 /* Avoid endless recursion if a `source' command is contained
4444 if (executing_breakpoint_commands
)
4447 scoped_restore save_executing
4448 = make_scoped_restore (&executing_breakpoint_commands
, 1);
4450 scoped_restore preventer
= prevent_dont_repeat ();
4452 /* This pointer will iterate over the list of bpstat's. */
4455 breakpoint_proceeded
= 0;
4456 for (; bs
!= NULL
; bs
= bs
->next
)
4458 struct command_line
*cmd
= NULL
;
4460 /* Take ownership of the BSP's command tree, if it has one.
4462 The command tree could legitimately contain commands like
4463 'step' and 'next', which call clear_proceed_status, which
4464 frees stop_bpstat's command tree. To make sure this doesn't
4465 free the tree we're executing out from under us, we need to
4466 take ownership of the tree ourselves. Since a given bpstat's
4467 commands are only executed once, we don't need to copy it; we
4468 can clear the pointer in the bpstat, and make sure we free
4469 the tree when we're done. */
4470 counted_command_line ccmd
= bs
->commands
;
4471 bs
->commands
= NULL
;
4474 if (command_line_is_silent (cmd
))
4476 /* The action has been already done by bpstat_stop_status. */
4482 execute_control_command (cmd
);
4484 if (breakpoint_proceeded
)
4490 if (breakpoint_proceeded
)
4492 if (current_ui
->async
)
4493 /* If we are in async mode, then the target might be still
4494 running, not stopped at any breakpoint, so nothing for
4495 us to do here -- just return to the event loop. */
4498 /* In sync mode, when execute_control_command returns
4499 we're already standing on the next breakpoint.
4500 Breakpoint commands for that stop were not run, since
4501 execute_command does not run breakpoint commands --
4502 only command_line_handler does, but that one is not
4503 involved in execution of breakpoint commands. So, we
4504 can now execute breakpoint commands. It should be
4505 noted that making execute_command do bpstat actions is
4506 not an option -- in this case we'll have recursive
4507 invocation of bpstat for each breakpoint with a
4508 command, and can easily blow up GDB stack. Instead, we
4509 return true, which will trigger the caller to recall us
4510 with the new stop_bpstat. */
4518 /* Helper for bpstat_do_actions. Get the current thread, if there's
4519 one, is alive and has execution. Return NULL otherwise. */
4521 static thread_info
*
4522 get_bpstat_thread ()
4524 if (inferior_ptid
== null_ptid
|| !target_has_execution ())
4527 thread_info
*tp
= inferior_thread ();
4528 if (tp
->state
== THREAD_EXITED
|| tp
->executing
)
4534 bpstat_do_actions (void)
4536 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
4539 /* Do any commands attached to breakpoint we are stopped at. */
4540 while ((tp
= get_bpstat_thread ()) != NULL
)
4542 /* Since in sync mode, bpstat_do_actions may resume the
4543 inferior, and only return when it is stopped at the next
4544 breakpoint, we keep doing breakpoint actions until it returns
4545 false to indicate the inferior was not resumed. */
4546 if (!bpstat_do_actions_1 (&tp
->control
.stop_bpstat
))
4550 cleanup_if_error
.release ();
4553 /* Print out the (old or new) value associated with a watchpoint. */
4556 watchpoint_value_print (struct value
*val
, struct ui_file
*stream
)
4559 fprintf_styled (stream
, metadata_style
.style (), _("<unreadable>"));
4562 struct value_print_options opts
;
4563 get_user_print_options (&opts
);
4564 value_print (val
, stream
, &opts
);
4568 /* Print the "Thread ID hit" part of "Thread ID hit Breakpoint N" if
4569 debugging multiple threads. */
4572 maybe_print_thread_hit_breakpoint (struct ui_out
*uiout
)
4574 if (uiout
->is_mi_like_p ())
4579 if (show_thread_that_caused_stop ())
4582 struct thread_info
*thr
= inferior_thread ();
4584 uiout
->text ("Thread ");
4585 uiout
->field_string ("thread-id", print_thread_id (thr
));
4587 name
= thr
->name
!= NULL
? thr
->name
: target_thread_name (thr
);
4590 uiout
->text (" \"");
4591 uiout
->field_string ("name", name
);
4595 uiout
->text (" hit ");
4599 /* Generic routine for printing messages indicating why we
4600 stopped. The behavior of this function depends on the value
4601 'print_it' in the bpstat structure. Under some circumstances we
4602 may decide not to print anything here and delegate the task to
4605 static enum print_stop_action
4606 print_bp_stop_message (bpstat bs
)
4608 switch (bs
->print_it
)
4611 /* Nothing should be printed for this bpstat entry. */
4612 return PRINT_UNKNOWN
;
4616 /* We still want to print the frame, but we already printed the
4617 relevant messages. */
4618 return PRINT_SRC_AND_LOC
;
4621 case print_it_normal
:
4623 struct breakpoint
*b
= bs
->breakpoint_at
;
4625 /* bs->breakpoint_at can be NULL if it was a momentary breakpoint
4626 which has since been deleted. */
4628 return PRINT_UNKNOWN
;
4630 /* Normal case. Call the breakpoint's print_it method. */
4631 return b
->ops
->print_it (bs
);
4636 internal_error (__FILE__
, __LINE__
,
4637 _("print_bp_stop_message: unrecognized enum value"));
4642 /* A helper function that prints a shared library stopped event. */
4645 print_solib_event (int is_catchpoint
)
4647 bool any_deleted
= !current_program_space
->deleted_solibs
.empty ();
4648 bool any_added
= !current_program_space
->added_solibs
.empty ();
4652 if (any_added
|| any_deleted
)
4653 current_uiout
->text (_("Stopped due to shared library event:\n"));
4655 current_uiout
->text (_("Stopped due to shared library event (no "
4656 "libraries added or removed)\n"));
4659 if (current_uiout
->is_mi_like_p ())
4660 current_uiout
->field_string ("reason",
4661 async_reason_lookup (EXEC_ASYNC_SOLIB_EVENT
));
4665 current_uiout
->text (_(" Inferior unloaded "));
4666 ui_out_emit_list
list_emitter (current_uiout
, "removed");
4667 for (int ix
= 0; ix
< current_program_space
->deleted_solibs
.size (); ix
++)
4669 const std::string
&name
= current_program_space
->deleted_solibs
[ix
];
4672 current_uiout
->text (" ");
4673 current_uiout
->field_string ("library", name
);
4674 current_uiout
->text ("\n");
4680 current_uiout
->text (_(" Inferior loaded "));
4681 ui_out_emit_list
list_emitter (current_uiout
, "added");
4683 for (so_list
*iter
: current_program_space
->added_solibs
)
4686 current_uiout
->text (" ");
4688 current_uiout
->field_string ("library", iter
->so_name
);
4689 current_uiout
->text ("\n");
4694 /* Print a message indicating what happened. This is called from
4695 normal_stop(). The input to this routine is the head of the bpstat
4696 list - a list of the eventpoints that caused this stop. KIND is
4697 the target_waitkind for the stopping event. This
4698 routine calls the generic print routine for printing a message
4699 about reasons for stopping. This will print (for example) the
4700 "Breakpoint n," part of the output. The return value of this
4703 PRINT_UNKNOWN: Means we printed nothing.
4704 PRINT_SRC_AND_LOC: Means we printed something, and expect subsequent
4705 code to print the location. An example is
4706 "Breakpoint 1, " which should be followed by
4708 PRINT_SRC_ONLY: Means we printed something, but there is no need
4709 to also print the location part of the message.
4710 An example is the catch/throw messages, which
4711 don't require a location appended to the end.
4712 PRINT_NOTHING: We have done some printing and we don't need any
4713 further info to be printed. */
4715 enum print_stop_action
4716 bpstat_print (bpstat bs
, int kind
)
4718 enum print_stop_action val
;
4720 /* Maybe another breakpoint in the chain caused us to stop.
4721 (Currently all watchpoints go on the bpstat whether hit or not.
4722 That probably could (should) be changed, provided care is taken
4723 with respect to bpstat_explains_signal). */
4724 for (; bs
; bs
= bs
->next
)
4726 val
= print_bp_stop_message (bs
);
4727 if (val
== PRINT_SRC_ONLY
4728 || val
== PRINT_SRC_AND_LOC
4729 || val
== PRINT_NOTHING
)
4733 /* If we had hit a shared library event breakpoint,
4734 print_bp_stop_message would print out this message. If we hit an
4735 OS-level shared library event, do the same thing. */
4736 if (kind
== TARGET_WAITKIND_LOADED
)
4738 print_solib_event (0);
4739 return PRINT_NOTHING
;
4742 /* We reached the end of the chain, or we got a null BS to start
4743 with and nothing was printed. */
4744 return PRINT_UNKNOWN
;
4747 /* Evaluate the boolean expression EXP and return the result. */
4750 breakpoint_cond_eval (expression
*exp
)
4752 struct value
*mark
= value_mark ();
4753 bool res
= value_true (evaluate_expression (exp
));
4755 value_free_to_mark (mark
);
4759 /* Allocate a new bpstat. Link it to the FIFO list by BS_LINK_POINTER. */
4761 bpstats::bpstats (struct bp_location
*bl
, bpstat
**bs_link_pointer
)
4763 bp_location_at (bp_location_ref_ptr::new_reference (bl
)),
4764 breakpoint_at (bl
->owner
),
4768 print_it (print_it_normal
)
4770 **bs_link_pointer
= this;
4771 *bs_link_pointer
= &next
;
4776 breakpoint_at (NULL
),
4780 print_it (print_it_normal
)
4784 /* The target has stopped with waitstatus WS. Check if any hardware
4785 watchpoints have triggered, according to the target. */
4788 watchpoints_triggered (struct target_waitstatus
*ws
)
4790 bool stopped_by_watchpoint
= target_stopped_by_watchpoint ();
4793 if (!stopped_by_watchpoint
)
4795 /* We were not stopped by a watchpoint. Mark all watchpoints
4796 as not triggered. */
4797 for (breakpoint
*b
: all_breakpoints ())
4798 if (is_hardware_watchpoint (b
))
4800 struct watchpoint
*w
= (struct watchpoint
*) b
;
4802 w
->watchpoint_triggered
= watch_triggered_no
;
4808 if (!target_stopped_data_address (current_inferior ()->top_target (), &addr
))
4810 /* We were stopped by a watchpoint, but we don't know where.
4811 Mark all watchpoints as unknown. */
4812 for (breakpoint
*b
: all_breakpoints ())
4813 if (is_hardware_watchpoint (b
))
4815 struct watchpoint
*w
= (struct watchpoint
*) b
;
4817 w
->watchpoint_triggered
= watch_triggered_unknown
;
4823 /* The target could report the data address. Mark watchpoints
4824 affected by this data address as triggered, and all others as not
4827 for (breakpoint
*b
: all_breakpoints ())
4828 if (is_hardware_watchpoint (b
))
4830 struct watchpoint
*w
= (struct watchpoint
*) b
;
4832 w
->watchpoint_triggered
= watch_triggered_no
;
4833 for (bp_location
*loc
: b
->locations ())
4835 if (is_masked_watchpoint (b
))
4837 CORE_ADDR newaddr
= addr
& w
->hw_wp_mask
;
4838 CORE_ADDR start
= loc
->address
& w
->hw_wp_mask
;
4840 if (newaddr
== start
)
4842 w
->watchpoint_triggered
= watch_triggered_yes
;
4846 /* Exact match not required. Within range is sufficient. */
4847 else if (target_watchpoint_addr_within_range
4848 (current_inferior ()->top_target (), addr
, loc
->address
,
4851 w
->watchpoint_triggered
= watch_triggered_yes
;
4860 /* Possible return values for watchpoint_check. */
4861 enum wp_check_result
4863 /* The watchpoint has been deleted. */
4866 /* The value has changed. */
4867 WP_VALUE_CHANGED
= 2,
4869 /* The value has not changed. */
4870 WP_VALUE_NOT_CHANGED
= 3,
4872 /* Ignore this watchpoint, no matter if the value changed or not. */
4876 #define BP_TEMPFLAG 1
4877 #define BP_HARDWAREFLAG 2
4879 /* Evaluate watchpoint condition expression and check if its value
4882 static wp_check_result
4883 watchpoint_check (bpstat bs
)
4885 struct watchpoint
*b
;
4886 struct frame_info
*fr
;
4887 int within_current_scope
;
4889 /* BS is built from an existing struct breakpoint. */
4890 gdb_assert (bs
->breakpoint_at
!= NULL
);
4891 b
= (struct watchpoint
*) bs
->breakpoint_at
;
4893 /* If this is a local watchpoint, we only want to check if the
4894 watchpoint frame is in scope if the current thread is the thread
4895 that was used to create the watchpoint. */
4896 if (!watchpoint_in_thread_scope (b
))
4899 if (b
->exp_valid_block
== NULL
)
4900 within_current_scope
= 1;
4903 struct frame_info
*frame
= get_current_frame ();
4904 struct gdbarch
*frame_arch
= get_frame_arch (frame
);
4905 CORE_ADDR frame_pc
= get_frame_pc (frame
);
4907 /* stack_frame_destroyed_p() returns a non-zero value if we're
4908 still in the function but the stack frame has already been
4909 invalidated. Since we can't rely on the values of local
4910 variables after the stack has been destroyed, we are treating
4911 the watchpoint in that state as `not changed' without further
4912 checking. Don't mark watchpoints as changed if the current
4913 frame is in an epilogue - even if they are in some other
4914 frame, our view of the stack is likely to be wrong and
4915 frame_find_by_id could error out. */
4916 if (gdbarch_stack_frame_destroyed_p (frame_arch
, frame_pc
))
4919 fr
= frame_find_by_id (b
->watchpoint_frame
);
4920 within_current_scope
= (fr
!= NULL
);
4922 /* If we've gotten confused in the unwinder, we might have
4923 returned a frame that can't describe this variable. */
4924 if (within_current_scope
)
4926 struct symbol
*function
;
4928 function
= get_frame_function (fr
);
4929 if (function
== NULL
4930 || !contained_in (b
->exp_valid_block
,
4931 SYMBOL_BLOCK_VALUE (function
)))
4932 within_current_scope
= 0;
4935 if (within_current_scope
)
4936 /* If we end up stopping, the current frame will get selected
4937 in normal_stop. So this call to select_frame won't affect
4942 if (within_current_scope
)
4944 /* We use value_{,free_to_}mark because it could be a *long*
4945 time before we return to the command level and call
4946 free_all_values. We can't call free_all_values because we
4947 might be in the middle of evaluating a function call. */
4950 struct value
*new_val
;
4952 if (is_masked_watchpoint (b
))
4953 /* Since we don't know the exact trigger address (from
4954 stopped_data_address), just tell the user we've triggered
4955 a mask watchpoint. */
4956 return WP_VALUE_CHANGED
;
4958 mark
= value_mark ();
4959 fetch_subexp_value (b
->exp
.get (), b
->exp
->op
.get (), &new_val
,
4962 if (b
->val_bitsize
!= 0)
4963 new_val
= extract_bitfield_from_watchpoint_value (b
, new_val
);
4965 /* We use value_equal_contents instead of value_equal because
4966 the latter coerces an array to a pointer, thus comparing just
4967 the address of the array instead of its contents. This is
4968 not what we want. */
4969 if ((b
->val
!= NULL
) != (new_val
!= NULL
)
4970 || (b
->val
!= NULL
&& !value_equal_contents (b
->val
.get (),
4973 bs
->old_val
= b
->val
;
4974 b
->val
= release_value (new_val
);
4975 b
->val_valid
= true;
4976 if (new_val
!= NULL
)
4977 value_free_to_mark (mark
);
4978 return WP_VALUE_CHANGED
;
4982 /* Nothing changed. */
4983 value_free_to_mark (mark
);
4984 return WP_VALUE_NOT_CHANGED
;
4989 /* This seems like the only logical thing to do because
4990 if we temporarily ignored the watchpoint, then when
4991 we reenter the block in which it is valid it contains
4992 garbage (in the case of a function, it may have two
4993 garbage values, one before and one after the prologue).
4994 So we can't even detect the first assignment to it and
4995 watch after that (since the garbage may or may not equal
4996 the first value assigned). */
4997 /* We print all the stop information in
4998 breakpoint_ops->print_it, but in this case, by the time we
4999 call breakpoint_ops->print_it this bp will be deleted
5000 already. So we have no choice but print the information
5003 SWITCH_THRU_ALL_UIS ()
5005 struct ui_out
*uiout
= current_uiout
;
5007 if (uiout
->is_mi_like_p ())
5009 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_SCOPE
));
5010 uiout
->message ("\nWatchpoint %pF deleted because the program has "
5011 "left the block in\n"
5012 "which its expression is valid.\n",
5013 signed_field ("wpnum", b
->number
));
5016 /* Make sure the watchpoint's commands aren't executed. */
5018 watchpoint_del_at_next_stop (b
);
5024 /* Return true if it looks like target has stopped due to hitting
5025 breakpoint location BL. This function does not check if we should
5026 stop, only if BL explains the stop. */
5029 bpstat_check_location (const struct bp_location
*bl
,
5030 const address_space
*aspace
, CORE_ADDR bp_addr
,
5031 const struct target_waitstatus
*ws
)
5033 struct breakpoint
*b
= bl
->owner
;
5035 /* BL is from an existing breakpoint. */
5036 gdb_assert (b
!= NULL
);
5038 return b
->ops
->breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
5041 /* Determine if the watched values have actually changed, and we
5042 should stop. If not, set BS->stop to 0. */
5045 bpstat_check_watchpoint (bpstat bs
)
5047 const struct bp_location
*bl
;
5048 struct watchpoint
*b
;
5050 /* BS is built for existing struct breakpoint. */
5051 bl
= bs
->bp_location_at
.get ();
5052 gdb_assert (bl
!= NULL
);
5053 b
= (struct watchpoint
*) bs
->breakpoint_at
;
5054 gdb_assert (b
!= NULL
);
5057 int must_check_value
= 0;
5059 if (b
->type
== bp_watchpoint
)
5060 /* For a software watchpoint, we must always check the
5062 must_check_value
= 1;
5063 else if (b
->watchpoint_triggered
== watch_triggered_yes
)
5064 /* We have a hardware watchpoint (read, write, or access)
5065 and the target earlier reported an address watched by
5067 must_check_value
= 1;
5068 else if (b
->watchpoint_triggered
== watch_triggered_unknown
5069 && b
->type
== bp_hardware_watchpoint
)
5070 /* We were stopped by a hardware watchpoint, but the target could
5071 not report the data address. We must check the watchpoint's
5072 value. Access and read watchpoints are out of luck; without
5073 a data address, we can't figure it out. */
5074 must_check_value
= 1;
5076 if (must_check_value
)
5082 e
= watchpoint_check (bs
);
5084 catch (const gdb_exception
&ex
)
5086 exception_fprintf (gdb_stderr
, ex
,
5087 "Error evaluating expression "
5088 "for watchpoint %d\n",
5091 SWITCH_THRU_ALL_UIS ()
5093 printf_filtered (_("Watchpoint %d deleted.\n"),
5096 watchpoint_del_at_next_stop (b
);
5103 /* We've already printed what needs to be printed. */
5104 bs
->print_it
= print_it_done
;
5108 bs
->print_it
= print_it_noop
;
5111 case WP_VALUE_CHANGED
:
5112 if (b
->type
== bp_read_watchpoint
)
5114 /* There are two cases to consider here:
5116 1. We're watching the triggered memory for reads.
5117 In that case, trust the target, and always report
5118 the watchpoint hit to the user. Even though
5119 reads don't cause value changes, the value may
5120 have changed since the last time it was read, and
5121 since we're not trapping writes, we will not see
5122 those, and as such we should ignore our notion of
5125 2. We're watching the triggered memory for both
5126 reads and writes. There are two ways this may
5129 2.1. This is a target that can't break on data
5130 reads only, but can break on accesses (reads or
5131 writes), such as e.g., x86. We detect this case
5132 at the time we try to insert read watchpoints.
5134 2.2. Otherwise, the target supports read
5135 watchpoints, but, the user set an access or write
5136 watchpoint watching the same memory as this read
5139 If we're watching memory writes as well as reads,
5140 ignore watchpoint hits when we find that the
5141 value hasn't changed, as reads don't cause
5142 changes. This still gives false positives when
5143 the program writes the same value to memory as
5144 what there was already in memory (we will confuse
5145 it for a read), but it's much better than
5148 int other_write_watchpoint
= 0;
5150 if (bl
->watchpoint_type
== hw_read
)
5152 for (breakpoint
*other_b
: all_breakpoints ())
5153 if (other_b
->type
== bp_hardware_watchpoint
5154 || other_b
->type
== bp_access_watchpoint
)
5156 struct watchpoint
*other_w
=
5157 (struct watchpoint
*) other_b
;
5159 if (other_w
->watchpoint_triggered
5160 == watch_triggered_yes
)
5162 other_write_watchpoint
= 1;
5168 if (other_write_watchpoint
5169 || bl
->watchpoint_type
== hw_access
)
5171 /* We're watching the same memory for writes,
5172 and the value changed since the last time we
5173 updated it, so this trap must be for a write.
5175 bs
->print_it
= print_it_noop
;
5180 case WP_VALUE_NOT_CHANGED
:
5181 if (b
->type
== bp_hardware_watchpoint
5182 || b
->type
== bp_watchpoint
)
5184 /* Don't stop: write watchpoints shouldn't fire if
5185 the value hasn't changed. */
5186 bs
->print_it
= print_it_noop
;
5196 else /* must_check_value == 0 */
5198 /* This is a case where some watchpoint(s) triggered, but
5199 not at the address of this watchpoint, or else no
5200 watchpoint triggered after all. So don't print
5201 anything for this watchpoint. */
5202 bs
->print_it
= print_it_noop
;
5208 /* For breakpoints that are currently marked as telling gdb to stop,
5209 check conditions (condition proper, frame, thread and ignore count)
5210 of breakpoint referred to by BS. If we should not stop for this
5211 breakpoint, set BS->stop to 0. */
5214 bpstat_check_breakpoint_conditions (bpstat bs
, thread_info
*thread
)
5216 const struct bp_location
*bl
;
5217 struct breakpoint
*b
;
5219 bool condition_result
= true;
5220 struct expression
*cond
;
5222 gdb_assert (bs
->stop
);
5224 /* BS is built for existing struct breakpoint. */
5225 bl
= bs
->bp_location_at
.get ();
5226 gdb_assert (bl
!= NULL
);
5227 b
= bs
->breakpoint_at
;
5228 gdb_assert (b
!= NULL
);
5230 /* Even if the target evaluated the condition on its end and notified GDB, we
5231 need to do so again since GDB does not know if we stopped due to a
5232 breakpoint or a single step breakpoint. */
5234 if (frame_id_p (b
->frame_id
)
5235 && !frame_id_eq (b
->frame_id
, get_stack_frame_id (get_current_frame ())))
5241 /* If this is a thread/task-specific breakpoint, don't waste cpu
5242 evaluating the condition if this isn't the specified
5244 if ((b
->thread
!= -1 && b
->thread
!= thread
->global_num
)
5245 || (b
->task
!= 0 && b
->task
!= ada_get_task_number (thread
)))
5251 /* Evaluate extension language breakpoints that have a "stop" method
5253 bs
->stop
= breakpoint_ext_lang_cond_says_stop (b
);
5255 if (is_watchpoint (b
))
5257 struct watchpoint
*w
= (struct watchpoint
*) b
;
5259 cond
= w
->cond_exp
.get ();
5262 cond
= bl
->cond
.get ();
5264 if (cond
&& b
->disposition
!= disp_del_at_next_stop
)
5266 int within_current_scope
= 1;
5267 struct watchpoint
* w
;
5269 /* We use value_mark and value_free_to_mark because it could
5270 be a long time before we return to the command level and
5271 call free_all_values. We can't call free_all_values
5272 because we might be in the middle of evaluating a
5274 struct value
*mark
= value_mark ();
5276 if (is_watchpoint (b
))
5277 w
= (struct watchpoint
*) b
;
5281 /* Need to select the frame, with all that implies so that
5282 the conditions will have the right context. Because we
5283 use the frame, we will not see an inlined function's
5284 variables when we arrive at a breakpoint at the start
5285 of the inlined function; the current frame will be the
5287 if (w
== NULL
|| w
->cond_exp_valid_block
== NULL
)
5288 select_frame (get_current_frame ());
5291 struct frame_info
*frame
;
5293 /* For local watchpoint expressions, which particular
5294 instance of a local is being watched matters, so we
5295 keep track of the frame to evaluate the expression
5296 in. To evaluate the condition however, it doesn't
5297 really matter which instantiation of the function
5298 where the condition makes sense triggers the
5299 watchpoint. This allows an expression like "watch
5300 global if q > 10" set in `func', catch writes to
5301 global on all threads that call `func', or catch
5302 writes on all recursive calls of `func' by a single
5303 thread. We simply always evaluate the condition in
5304 the innermost frame that's executing where it makes
5305 sense to evaluate the condition. It seems
5307 frame
= block_innermost_frame (w
->cond_exp_valid_block
);
5309 select_frame (frame
);
5311 within_current_scope
= 0;
5313 if (within_current_scope
)
5317 condition_result
= breakpoint_cond_eval (cond
);
5319 catch (const gdb_exception
&ex
)
5321 exception_fprintf (gdb_stderr
, ex
,
5322 "Error in testing breakpoint condition:\n");
5327 warning (_("Watchpoint condition cannot be tested "
5328 "in the current scope"));
5329 /* If we failed to set the right context for this
5330 watchpoint, unconditionally report it. */
5332 /* FIXME-someday, should give breakpoint #. */
5333 value_free_to_mark (mark
);
5336 if (cond
&& !condition_result
)
5340 else if (b
->ignore_count
> 0)
5344 /* Increase the hit count even though we don't stop. */
5346 gdb::observers::breakpoint_modified
.notify (b
);
5350 /* Returns true if we need to track moribund locations of LOC's type
5351 on the current target. */
5354 need_moribund_for_location_type (struct bp_location
*loc
)
5356 return ((loc
->loc_type
== bp_loc_software_breakpoint
5357 && !target_supports_stopped_by_sw_breakpoint ())
5358 || (loc
->loc_type
== bp_loc_hardware_breakpoint
5359 && !target_supports_stopped_by_hw_breakpoint ()));
5362 /* See breakpoint.h. */
5365 build_bpstat_chain (const address_space
*aspace
, CORE_ADDR bp_addr
,
5366 const struct target_waitstatus
*ws
)
5368 bpstat bs_head
= NULL
, *bs_link
= &bs_head
;
5370 for (breakpoint
*b
: all_breakpoints ())
5372 if (!breakpoint_enabled (b
))
5375 for (bp_location
*bl
: b
->locations ())
5377 /* For hardware watchpoints, we look only at the first
5378 location. The watchpoint_check function will work on the
5379 entire expression, not the individual locations. For
5380 read watchpoints, the watchpoints_triggered function has
5381 checked all locations already. */
5382 if (b
->type
== bp_hardware_watchpoint
&& bl
!= b
->loc
)
5385 if (!bl
->enabled
|| bl
->disabled_by_cond
|| bl
->shlib_disabled
)
5388 if (!bpstat_check_location (bl
, aspace
, bp_addr
, ws
))
5391 /* Come here if it's a watchpoint, or if the break address
5394 bpstat bs
= new bpstats (bl
, &bs_link
); /* Alloc a bpstat to
5397 /* Assume we stop. Should we find a watchpoint that is not
5398 actually triggered, or if the condition of the breakpoint
5399 evaluates as false, we'll reset 'stop' to 0. */
5403 /* If this is a scope breakpoint, mark the associated
5404 watchpoint as triggered so that we will handle the
5405 out-of-scope event. We'll get to the watchpoint next
5407 if (b
->type
== bp_watchpoint_scope
&& b
->related_breakpoint
!= b
)
5409 struct watchpoint
*w
= (struct watchpoint
*) b
->related_breakpoint
;
5411 w
->watchpoint_triggered
= watch_triggered_yes
;
5416 /* Check if a moribund breakpoint explains the stop. */
5417 if (!target_supports_stopped_by_sw_breakpoint ()
5418 || !target_supports_stopped_by_hw_breakpoint ())
5420 for (bp_location
*loc
: moribund_locations
)
5422 if (breakpoint_location_address_match (loc
, aspace
, bp_addr
)
5423 && need_moribund_for_location_type (loc
))
5425 bpstat bs
= new bpstats (loc
, &bs_link
);
5426 /* For hits of moribund locations, we should just proceed. */
5429 bs
->print_it
= print_it_noop
;
5437 /* See breakpoint.h. */
5440 bpstat_stop_status (const address_space
*aspace
,
5441 CORE_ADDR bp_addr
, thread_info
*thread
,
5442 const struct target_waitstatus
*ws
,
5445 struct breakpoint
*b
= NULL
;
5446 /* First item of allocated bpstat's. */
5447 bpstat bs_head
= stop_chain
;
5449 int need_remove_insert
;
5452 /* First, build the bpstat chain with locations that explain a
5453 target stop, while being careful to not set the target running,
5454 as that may invalidate locations (in particular watchpoint
5455 locations are recreated). Resuming will happen here with
5456 breakpoint conditions or watchpoint expressions that include
5457 inferior function calls. */
5458 if (bs_head
== NULL
)
5459 bs_head
= build_bpstat_chain (aspace
, bp_addr
, ws
);
5461 /* A bit of special processing for shlib breakpoints. We need to
5462 process solib loading here, so that the lists of loaded and
5463 unloaded libraries are correct before we handle "catch load" and
5465 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5467 if (bs
->breakpoint_at
&& bs
->breakpoint_at
->type
== bp_shlib_event
)
5469 handle_solib_event ();
5474 /* Now go through the locations that caused the target to stop, and
5475 check whether we're interested in reporting this stop to higher
5476 layers, or whether we should resume the target transparently. */
5480 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5485 b
= bs
->breakpoint_at
;
5486 b
->ops
->check_status (bs
);
5489 bpstat_check_breakpoint_conditions (bs
, thread
);
5494 gdb::observers::breakpoint_modified
.notify (b
);
5496 /* We will stop here. */
5497 if (b
->disposition
== disp_disable
)
5499 --(b
->enable_count
);
5500 if (b
->enable_count
<= 0)
5501 b
->enable_state
= bp_disabled
;
5506 bs
->commands
= b
->commands
;
5507 if (command_line_is_silent (bs
->commands
5508 ? bs
->commands
.get () : NULL
))
5511 b
->ops
->after_condition_true (bs
);
5516 /* Print nothing for this entry if we don't stop or don't
5518 if (!bs
->stop
|| !bs
->print
)
5519 bs
->print_it
= print_it_noop
;
5522 /* If we aren't stopping, the value of some hardware watchpoint may
5523 not have changed, but the intermediate memory locations we are
5524 watching may have. Don't bother if we're stopping; this will get
5526 need_remove_insert
= 0;
5527 if (! bpstat_causes_stop (bs_head
))
5528 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5530 && bs
->breakpoint_at
5531 && is_hardware_watchpoint (bs
->breakpoint_at
))
5533 struct watchpoint
*w
= (struct watchpoint
*) bs
->breakpoint_at
;
5535 update_watchpoint (w
, 0 /* don't reparse. */);
5536 need_remove_insert
= 1;
5539 if (need_remove_insert
)
5540 update_global_location_list (UGLL_MAY_INSERT
);
5541 else if (removed_any
)
5542 update_global_location_list (UGLL_DONT_INSERT
);
5548 handle_jit_event (CORE_ADDR address
)
5550 struct gdbarch
*gdbarch
;
5552 infrun_debug_printf ("handling bp_jit_event");
5554 /* Switch terminal for any messages produced by
5555 breakpoint_re_set. */
5556 target_terminal::ours_for_output ();
5558 gdbarch
= get_frame_arch (get_current_frame ());
5559 /* This event is caused by a breakpoint set in `jit_breakpoint_re_set`,
5560 thus it is expected that its objectfile can be found through
5561 minimal symbol lookup. If it doesn't work (and assert fails), it
5562 most likely means that `jit_breakpoint_re_set` was changes and this
5563 function needs to be updated too. */
5564 bound_minimal_symbol jit_bp_sym
= lookup_minimal_symbol_by_pc (address
);
5565 gdb_assert (jit_bp_sym
.objfile
!= nullptr);
5566 jit_event_handler (gdbarch
, jit_bp_sym
.objfile
);
5568 target_terminal::inferior ();
5571 /* Prepare WHAT final decision for infrun. */
5573 /* Decide what infrun needs to do with this bpstat. */
5576 bpstat_what (bpstat bs_head
)
5578 struct bpstat_what retval
;
5581 retval
.main_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5582 retval
.call_dummy
= STOP_NONE
;
5583 retval
.is_longjmp
= false;
5585 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5587 /* Extract this BS's action. After processing each BS, we check
5588 if its action overrides all we've seem so far. */
5589 enum bpstat_what_main_action this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5592 if (bs
->breakpoint_at
== NULL
)
5594 /* I suspect this can happen if it was a momentary
5595 breakpoint which has since been deleted. */
5599 bptype
= bs
->breakpoint_at
->type
;
5606 case bp_hardware_breakpoint
:
5607 case bp_single_step
:
5610 case bp_shlib_event
:
5614 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5616 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5619 this_action
= BPSTAT_WHAT_SINGLE
;
5622 case bp_hardware_watchpoint
:
5623 case bp_read_watchpoint
:
5624 case bp_access_watchpoint
:
5628 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5630 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5634 /* There was a watchpoint, but we're not stopping.
5635 This requires no further action. */
5639 case bp_longjmp_call_dummy
:
5643 this_action
= BPSTAT_WHAT_SET_LONGJMP_RESUME
;
5644 retval
.is_longjmp
= bptype
!= bp_exception
;
5647 this_action
= BPSTAT_WHAT_SINGLE
;
5649 case bp_longjmp_resume
:
5650 case bp_exception_resume
:
5653 this_action
= BPSTAT_WHAT_CLEAR_LONGJMP_RESUME
;
5654 retval
.is_longjmp
= bptype
== bp_longjmp_resume
;
5657 this_action
= BPSTAT_WHAT_SINGLE
;
5659 case bp_step_resume
:
5661 this_action
= BPSTAT_WHAT_STEP_RESUME
;
5664 /* It is for the wrong frame. */
5665 this_action
= BPSTAT_WHAT_SINGLE
;
5668 case bp_hp_step_resume
:
5670 this_action
= BPSTAT_WHAT_HP_STEP_RESUME
;
5673 /* It is for the wrong frame. */
5674 this_action
= BPSTAT_WHAT_SINGLE
;
5677 case bp_watchpoint_scope
:
5678 case bp_thread_event
:
5679 case bp_overlay_event
:
5680 case bp_longjmp_master
:
5681 case bp_std_terminate_master
:
5682 case bp_exception_master
:
5683 this_action
= BPSTAT_WHAT_SINGLE
;
5689 this_action
= BPSTAT_WHAT_STOP_NOISY
;
5691 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5695 /* Some catchpoints are implemented with breakpoints.
5696 For those, we need to step over the breakpoint. */
5697 if (bs
->bp_location_at
->loc_type
!= bp_loc_other
)
5698 this_action
= BPSTAT_WHAT_SINGLE
;
5702 this_action
= BPSTAT_WHAT_SINGLE
;
5705 /* Make sure the action is stop (silent or noisy),
5706 so infrun.c pops the dummy frame. */
5707 retval
.call_dummy
= STOP_STACK_DUMMY
;
5708 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5710 case bp_std_terminate
:
5711 /* Make sure the action is stop (silent or noisy),
5712 so infrun.c pops the dummy frame. */
5713 retval
.call_dummy
= STOP_STD_TERMINATE
;
5714 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5717 case bp_fast_tracepoint
:
5718 case bp_static_tracepoint
:
5719 /* Tracepoint hits should not be reported back to GDB, and
5720 if one got through somehow, it should have been filtered
5722 internal_error (__FILE__
, __LINE__
,
5723 _("bpstat_what: tracepoint encountered"));
5725 case bp_gnu_ifunc_resolver
:
5726 /* Step over it (and insert bp_gnu_ifunc_resolver_return). */
5727 this_action
= BPSTAT_WHAT_SINGLE
;
5729 case bp_gnu_ifunc_resolver_return
:
5730 /* The breakpoint will be removed, execution will restart from the
5731 PC of the former breakpoint. */
5732 this_action
= BPSTAT_WHAT_KEEP_CHECKING
;
5737 this_action
= BPSTAT_WHAT_STOP_SILENT
;
5739 this_action
= BPSTAT_WHAT_SINGLE
;
5743 internal_error (__FILE__
, __LINE__
,
5744 _("bpstat_what: unhandled bptype %d"), (int) bptype
);
5747 retval
.main_action
= std::max (retval
.main_action
, this_action
);
5754 bpstat_run_callbacks (bpstat bs_head
)
5758 for (bs
= bs_head
; bs
!= NULL
; bs
= bs
->next
)
5760 struct breakpoint
*b
= bs
->breakpoint_at
;
5767 handle_jit_event (bs
->bp_location_at
->address
);
5769 case bp_gnu_ifunc_resolver
:
5770 gnu_ifunc_resolver_stop (b
);
5772 case bp_gnu_ifunc_resolver_return
:
5773 gnu_ifunc_resolver_return_stop (b
);
5779 /* See breakpoint.h. */
5782 bpstat_should_step ()
5784 for (breakpoint
*b
: all_breakpoints ())
5785 if (breakpoint_enabled (b
) && b
->type
== bp_watchpoint
&& b
->loc
!= NULL
)
5791 /* See breakpoint.h. */
5794 bpstat_causes_stop (bpstat bs
)
5796 for (; bs
!= NULL
; bs
= bs
->next
)
5805 /* Compute a string of spaces suitable to indent the next line
5806 so it starts at the position corresponding to the table column
5807 named COL_NAME in the currently active table of UIOUT. */
5810 wrap_indent_at_field (struct ui_out
*uiout
, const char *col_name
)
5812 static char wrap_indent
[80];
5813 int i
, total_width
, width
, align
;
5817 for (i
= 1; uiout
->query_table_field (i
, &width
, &align
, &text
); i
++)
5819 if (strcmp (text
, col_name
) == 0)
5821 gdb_assert (total_width
< sizeof wrap_indent
);
5822 memset (wrap_indent
, ' ', total_width
);
5823 wrap_indent
[total_width
] = 0;
5828 total_width
+= width
+ 1;
5834 /* Determine if the locations of this breakpoint will have their conditions
5835 evaluated by the target, host or a mix of both. Returns the following:
5837 "host": Host evals condition.
5838 "host or target": Host or Target evals condition.
5839 "target": Target evals condition.
5843 bp_condition_evaluator (struct breakpoint
*b
)
5845 char host_evals
= 0;
5846 char target_evals
= 0;
5851 if (!is_breakpoint (b
))
5854 if (gdb_evaluates_breakpoint_condition_p ()
5855 || !target_supports_evaluation_of_breakpoint_conditions ())
5856 return condition_evaluation_host
;
5858 for (bp_location
*bl
: b
->locations ())
5860 if (bl
->cond_bytecode
)
5866 if (host_evals
&& target_evals
)
5867 return condition_evaluation_both
;
5868 else if (target_evals
)
5869 return condition_evaluation_target
;
5871 return condition_evaluation_host
;
5874 /* Determine the breakpoint location's condition evaluator. This is
5875 similar to bp_condition_evaluator, but for locations. */
5878 bp_location_condition_evaluator (struct bp_location
*bl
)
5880 if (bl
&& !is_breakpoint (bl
->owner
))
5883 if (gdb_evaluates_breakpoint_condition_p ()
5884 || !target_supports_evaluation_of_breakpoint_conditions ())
5885 return condition_evaluation_host
;
5887 if (bl
&& bl
->cond_bytecode
)
5888 return condition_evaluation_target
;
5890 return condition_evaluation_host
;
5893 /* Print the LOC location out of the list of B->LOC locations. */
5896 print_breakpoint_location (struct breakpoint
*b
,
5897 struct bp_location
*loc
)
5899 struct ui_out
*uiout
= current_uiout
;
5901 scoped_restore_current_program_space restore_pspace
;
5903 if (loc
!= NULL
&& loc
->shlib_disabled
)
5907 set_current_program_space (loc
->pspace
);
5909 if (b
->display_canonical
)
5910 uiout
->field_string ("what", event_location_to_string (b
->location
.get ()));
5911 else if (loc
&& loc
->symtab
)
5913 const struct symbol
*sym
= loc
->symbol
;
5917 uiout
->text ("in ");
5918 uiout
->field_string ("func", sym
->print_name (),
5919 function_name_style
.style ());
5921 uiout
->wrap_hint (wrap_indent_at_field (uiout
, "what"));
5922 uiout
->text ("at ");
5924 uiout
->field_string ("file",
5925 symtab_to_filename_for_display (loc
->symtab
),
5926 file_name_style
.style ());
5929 if (uiout
->is_mi_like_p ())
5930 uiout
->field_string ("fullname", symtab_to_fullname (loc
->symtab
));
5932 uiout
->field_signed ("line", loc
->line_number
);
5938 print_address_symbolic (loc
->gdbarch
, loc
->address
, &stb
,
5940 uiout
->field_stream ("at", stb
);
5944 uiout
->field_string ("pending",
5945 event_location_to_string (b
->location
.get ()));
5946 /* If extra_string is available, it could be holding a condition
5947 or dprintf arguments. In either case, make sure it is printed,
5948 too, but only for non-MI streams. */
5949 if (!uiout
->is_mi_like_p () && b
->extra_string
!= NULL
)
5951 if (b
->type
== bp_dprintf
)
5955 uiout
->text (b
->extra_string
);
5959 if (loc
&& is_breakpoint (b
)
5960 && breakpoint_condition_evaluation_mode () == condition_evaluation_target
5961 && bp_condition_evaluator (b
) == condition_evaluation_both
)
5964 uiout
->field_string ("evaluated-by",
5965 bp_location_condition_evaluator (loc
));
5971 bptype_string (enum bptype type
)
5973 struct ep_type_description
5976 const char *description
;
5978 static struct ep_type_description bptypes
[] =
5980 {bp_none
, "?deleted?"},
5981 {bp_breakpoint
, "breakpoint"},
5982 {bp_hardware_breakpoint
, "hw breakpoint"},
5983 {bp_single_step
, "sw single-step"},
5984 {bp_until
, "until"},
5985 {bp_finish
, "finish"},
5986 {bp_watchpoint
, "watchpoint"},
5987 {bp_hardware_watchpoint
, "hw watchpoint"},
5988 {bp_read_watchpoint
, "read watchpoint"},
5989 {bp_access_watchpoint
, "acc watchpoint"},
5990 {bp_longjmp
, "longjmp"},
5991 {bp_longjmp_resume
, "longjmp resume"},
5992 {bp_longjmp_call_dummy
, "longjmp for call dummy"},
5993 {bp_exception
, "exception"},
5994 {bp_exception_resume
, "exception resume"},
5995 {bp_step_resume
, "step resume"},
5996 {bp_hp_step_resume
, "high-priority step resume"},
5997 {bp_watchpoint_scope
, "watchpoint scope"},
5998 {bp_call_dummy
, "call dummy"},
5999 {bp_std_terminate
, "std::terminate"},
6000 {bp_shlib_event
, "shlib events"},
6001 {bp_thread_event
, "thread events"},
6002 {bp_overlay_event
, "overlay events"},
6003 {bp_longjmp_master
, "longjmp master"},
6004 {bp_std_terminate_master
, "std::terminate master"},
6005 {bp_exception_master
, "exception master"},
6006 {bp_catchpoint
, "catchpoint"},
6007 {bp_tracepoint
, "tracepoint"},
6008 {bp_fast_tracepoint
, "fast tracepoint"},
6009 {bp_static_tracepoint
, "static tracepoint"},
6010 {bp_dprintf
, "dprintf"},
6011 {bp_jit_event
, "jit events"},
6012 {bp_gnu_ifunc_resolver
, "STT_GNU_IFUNC resolver"},
6013 {bp_gnu_ifunc_resolver_return
, "STT_GNU_IFUNC resolver return"},
6016 if (((int) type
>= (sizeof (bptypes
) / sizeof (bptypes
[0])))
6017 || ((int) type
!= bptypes
[(int) type
].type
))
6018 internal_error (__FILE__
, __LINE__
,
6019 _("bptypes table does not describe type #%d."),
6022 return bptypes
[(int) type
].description
;
6025 /* For MI, output a field named 'thread-groups' with a list as the value.
6026 For CLI, prefix the list with the string 'inf'. */
6029 output_thread_groups (struct ui_out
*uiout
,
6030 const char *field_name
,
6031 const std::vector
<int> &inf_nums
,
6034 int is_mi
= uiout
->is_mi_like_p ();
6036 /* For backward compatibility, don't display inferiors in CLI unless
6037 there are several. Always display them for MI. */
6038 if (!is_mi
&& mi_only
)
6041 ui_out_emit_list
list_emitter (uiout
, field_name
);
6043 for (size_t i
= 0; i
< inf_nums
.size (); i
++)
6049 xsnprintf (mi_group
, sizeof (mi_group
), "i%d", inf_nums
[i
]);
6050 uiout
->field_string (NULL
, mi_group
);
6055 uiout
->text (" inf ");
6059 uiout
->text (plongest (inf_nums
[i
]));
6064 /* Print B to gdb_stdout. If RAW_LOC, print raw breakpoint locations
6065 instead of going via breakpoint_ops::print_one. This makes "maint
6066 info breakpoints" show the software breakpoint locations of
6067 catchpoints, which are considered internal implementation
6071 print_one_breakpoint_location (struct breakpoint
*b
,
6072 struct bp_location
*loc
,
6074 struct bp_location
**last_loc
,
6075 int allflag
, bool raw_loc
)
6077 struct command_line
*l
;
6078 static char bpenables
[] = "nynny";
6080 struct ui_out
*uiout
= current_uiout
;
6081 int header_of_multiple
= 0;
6082 int part_of_multiple
= (loc
!= NULL
);
6083 struct value_print_options opts
;
6085 get_user_print_options (&opts
);
6087 gdb_assert (!loc
|| loc_number
!= 0);
6088 /* See comment in print_one_breakpoint concerning treatment of
6089 breakpoints with single disabled location. */
6092 && (b
->loc
->next
!= NULL
6093 || !b
->loc
->enabled
|| b
->loc
->disabled_by_cond
)))
6094 header_of_multiple
= 1;
6102 if (part_of_multiple
)
6103 uiout
->field_fmt ("number", "%d.%d", b
->number
, loc_number
);
6105 uiout
->field_signed ("number", b
->number
);
6109 if (part_of_multiple
)
6110 uiout
->field_skip ("type");
6112 uiout
->field_string ("type", bptype_string (b
->type
));
6116 if (part_of_multiple
)
6117 uiout
->field_skip ("disp");
6119 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
6123 /* For locations that are disabled because of an invalid condition,
6124 display "N*" on CLI, where "*" refers to a footnote below the
6125 table. For MI, simply display a "N" without a footnote. */
6126 const char *N
= (uiout
->is_mi_like_p ()) ? "N" : "N*";
6127 if (part_of_multiple
)
6128 uiout
->field_string ("enabled", (loc
->disabled_by_cond
? N
6129 : (loc
->enabled
? "y" : "n")));
6131 uiout
->field_fmt ("enabled", "%c", bpenables
[(int) b
->enable_state
]);
6134 if (!raw_loc
&& b
->ops
!= NULL
&& b
->ops
->print_one
!= NULL
)
6135 b
->ops
->print_one (b
, last_loc
);
6138 if (is_watchpoint (b
))
6140 struct watchpoint
*w
= (struct watchpoint
*) b
;
6142 /* Field 4, the address, is omitted (which makes the columns
6143 not line up too nicely with the headers, but the effect
6144 is relatively readable). */
6145 if (opts
.addressprint
)
6146 uiout
->field_skip ("addr");
6148 uiout
->field_string ("what", w
->exp_string
);
6150 else if (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6151 || is_ada_exception_catchpoint (b
))
6153 if (opts
.addressprint
)
6156 if (header_of_multiple
)
6157 uiout
->field_string ("addr", "<MULTIPLE>",
6158 metadata_style
.style ());
6159 else if (b
->loc
== NULL
|| loc
->shlib_disabled
)
6160 uiout
->field_string ("addr", "<PENDING>",
6161 metadata_style
.style ());
6163 uiout
->field_core_addr ("addr",
6164 loc
->gdbarch
, loc
->address
);
6167 if (!header_of_multiple
)
6168 print_breakpoint_location (b
, loc
);
6174 if (loc
!= NULL
&& !header_of_multiple
)
6176 std::vector
<int> inf_nums
;
6179 for (inferior
*inf
: all_inferiors ())
6181 if (inf
->pspace
== loc
->pspace
)
6182 inf_nums
.push_back (inf
->num
);
6185 /* For backward compatibility, don't display inferiors in CLI unless
6186 there are several. Always display for MI. */
6188 || (!gdbarch_has_global_breakpoints (target_gdbarch ())
6189 && (program_spaces
.size () > 1
6190 || number_of_inferiors () > 1)
6191 /* LOC is for existing B, it cannot be in
6192 moribund_locations and thus having NULL OWNER. */
6193 && loc
->owner
->type
!= bp_catchpoint
))
6195 output_thread_groups (uiout
, "thread-groups", inf_nums
, mi_only
);
6198 if (!part_of_multiple
)
6200 if (b
->thread
!= -1)
6202 /* FIXME: This seems to be redundant and lost here; see the
6203 "stop only in" line a little further down. */
6204 uiout
->text (" thread ");
6205 uiout
->field_signed ("thread", b
->thread
);
6207 else if (b
->task
!= 0)
6209 uiout
->text (" task ");
6210 uiout
->field_signed ("task", b
->task
);
6216 if (!part_of_multiple
)
6217 b
->ops
->print_one_detail (b
, uiout
);
6219 if (part_of_multiple
&& frame_id_p (b
->frame_id
))
6222 uiout
->text ("\tstop only in stack frame at ");
6223 /* FIXME: cagney/2002-12-01: Shouldn't be poking around inside
6225 uiout
->field_core_addr ("frame",
6226 b
->gdbarch
, b
->frame_id
.stack_addr
);
6230 if (!part_of_multiple
&& b
->cond_string
)
6233 if (is_tracepoint (b
))
6234 uiout
->text ("\ttrace only if ");
6236 uiout
->text ("\tstop only if ");
6237 uiout
->field_string ("cond", b
->cond_string
);
6239 /* Print whether the target is doing the breakpoint's condition
6240 evaluation. If GDB is doing the evaluation, don't print anything. */
6241 if (is_breakpoint (b
)
6242 && breakpoint_condition_evaluation_mode ()
6243 == condition_evaluation_target
)
6245 uiout
->message (" (%pF evals)",
6246 string_field ("evaluated-by",
6247 bp_condition_evaluator (b
)));
6252 if (!part_of_multiple
&& b
->thread
!= -1)
6254 /* FIXME should make an annotation for this. */
6255 uiout
->text ("\tstop only in thread ");
6256 if (uiout
->is_mi_like_p ())
6257 uiout
->field_signed ("thread", b
->thread
);
6260 struct thread_info
*thr
= find_thread_global_id (b
->thread
);
6262 uiout
->field_string ("thread", print_thread_id (thr
));
6267 if (!part_of_multiple
)
6271 /* FIXME should make an annotation for this. */
6272 if (is_catchpoint (b
))
6273 uiout
->text ("\tcatchpoint");
6274 else if (is_tracepoint (b
))
6275 uiout
->text ("\ttracepoint");
6277 uiout
->text ("\tbreakpoint");
6278 uiout
->text (" already hit ");
6279 uiout
->field_signed ("times", b
->hit_count
);
6280 if (b
->hit_count
== 1)
6281 uiout
->text (" time\n");
6283 uiout
->text (" times\n");
6287 /* Output the count also if it is zero, but only if this is mi. */
6288 if (uiout
->is_mi_like_p ())
6289 uiout
->field_signed ("times", b
->hit_count
);
6293 if (!part_of_multiple
&& b
->ignore_count
)
6296 uiout
->message ("\tignore next %pF hits\n",
6297 signed_field ("ignore", b
->ignore_count
));
6300 /* Note that an enable count of 1 corresponds to "enable once"
6301 behavior, which is reported by the combination of enablement and
6302 disposition, so we don't need to mention it here. */
6303 if (!part_of_multiple
&& b
->enable_count
> 1)
6306 uiout
->text ("\tdisable after ");
6307 /* Tweak the wording to clarify that ignore and enable counts
6308 are distinct, and have additive effect. */
6309 if (b
->ignore_count
)
6310 uiout
->text ("additional ");
6312 uiout
->text ("next ");
6313 uiout
->field_signed ("enable", b
->enable_count
);
6314 uiout
->text (" hits\n");
6317 if (!part_of_multiple
&& is_tracepoint (b
))
6319 struct tracepoint
*tp
= (struct tracepoint
*) b
;
6321 if (tp
->traceframe_usage
)
6323 uiout
->text ("\ttrace buffer usage ");
6324 uiout
->field_signed ("traceframe-usage", tp
->traceframe_usage
);
6325 uiout
->text (" bytes\n");
6329 l
= b
->commands
? b
->commands
.get () : NULL
;
6330 if (!part_of_multiple
&& l
)
6333 ui_out_emit_tuple
tuple_emitter (uiout
, "script");
6334 print_command_lines (uiout
, l
, 4);
6337 if (is_tracepoint (b
))
6339 struct tracepoint
*t
= (struct tracepoint
*) b
;
6341 if (!part_of_multiple
&& t
->pass_count
)
6343 annotate_field (10);
6344 uiout
->text ("\tpass count ");
6345 uiout
->field_signed ("pass", t
->pass_count
);
6346 uiout
->text (" \n");
6349 /* Don't display it when tracepoint or tracepoint location is
6351 if (!header_of_multiple
&& loc
!= NULL
&& !loc
->shlib_disabled
)
6353 annotate_field (11);
6355 if (uiout
->is_mi_like_p ())
6356 uiout
->field_string ("installed",
6357 loc
->inserted
? "y" : "n");
6363 uiout
->text ("\tnot ");
6364 uiout
->text ("installed on target\n");
6369 if (uiout
->is_mi_like_p () && !part_of_multiple
)
6371 if (is_watchpoint (b
))
6373 struct watchpoint
*w
= (struct watchpoint
*) b
;
6375 uiout
->field_string ("original-location", w
->exp_string
);
6377 else if (b
->location
!= NULL
6378 && event_location_to_string (b
->location
.get ()) != NULL
)
6379 uiout
->field_string ("original-location",
6380 event_location_to_string (b
->location
.get ()));
6384 /* See breakpoint.h. */
6386 bool fix_multi_location_breakpoint_output_globally
= false;
6389 print_one_breakpoint (struct breakpoint
*b
,
6390 struct bp_location
**last_loc
,
6393 struct ui_out
*uiout
= current_uiout
;
6394 bool use_fixed_output
6395 = (uiout
->test_flags (fix_multi_location_breakpoint_output
)
6396 || fix_multi_location_breakpoint_output_globally
);
6398 gdb::optional
<ui_out_emit_tuple
> bkpt_tuple_emitter (gdb::in_place
, uiout
, "bkpt");
6399 print_one_breakpoint_location (b
, NULL
, 0, last_loc
, allflag
, false);
6401 /* The mi2 broken format: the main breakpoint tuple ends here, the locations
6403 if (!use_fixed_output
)
6404 bkpt_tuple_emitter
.reset ();
6406 /* If this breakpoint has custom print function,
6407 it's already printed. Otherwise, print individual
6408 locations, if any. */
6410 || b
->ops
->print_one
== NULL
6413 /* If breakpoint has a single location that is disabled, we
6414 print it as if it had several locations, since otherwise it's
6415 hard to represent "breakpoint enabled, location disabled"
6418 Note that while hardware watchpoints have several locations
6419 internally, that's not a property exposed to users.
6421 Likewise, while catchpoints may be implemented with
6422 breakpoints (e.g., catch throw), that's not a property
6423 exposed to users. We do however display the internal
6424 breakpoint locations with "maint info breakpoints". */
6425 if (!is_hardware_watchpoint (b
)
6426 && (!is_catchpoint (b
) || is_exception_catchpoint (b
)
6427 || is_ada_exception_catchpoint (b
))
6429 || (b
->loc
&& (b
->loc
->next
6431 || b
->loc
->disabled_by_cond
))))
6433 gdb::optional
<ui_out_emit_list
> locations_list
;
6435 /* For MI version <= 2, keep the behavior where GDB outputs an invalid
6436 MI record. For later versions, place breakpoint locations in a
6438 if (uiout
->is_mi_like_p () && use_fixed_output
)
6439 locations_list
.emplace (uiout
, "locations");
6442 for (bp_location
*loc
: b
->locations ())
6444 ui_out_emit_tuple
loc_tuple_emitter (uiout
, NULL
);
6445 print_one_breakpoint_location (b
, loc
, n
, last_loc
,
6454 breakpoint_address_bits (struct breakpoint
*b
)
6456 int print_address_bits
= 0;
6458 /* Software watchpoints that aren't watching memory don't have an
6459 address to print. */
6460 if (is_no_memory_software_watchpoint (b
))
6463 for (bp_location
*loc
: b
->locations ())
6467 addr_bit
= gdbarch_addr_bit (loc
->gdbarch
);
6468 if (addr_bit
> print_address_bits
)
6469 print_address_bits
= addr_bit
;
6472 return print_address_bits
;
6475 /* See breakpoint.h. */
6478 print_breakpoint (breakpoint
*b
)
6480 struct bp_location
*dummy_loc
= NULL
;
6481 print_one_breakpoint (b
, &dummy_loc
, 0);
6484 /* Return true if this breakpoint was set by the user, false if it is
6485 internal or momentary. */
6488 user_breakpoint_p (struct breakpoint
*b
)
6490 return b
->number
> 0;
6493 /* See breakpoint.h. */
6496 pending_breakpoint_p (struct breakpoint
*b
)
6498 return b
->loc
== NULL
;
6501 /* Print information on breakpoints (including watchpoints and tracepoints).
6503 If non-NULL, BP_NUM_LIST is a list of numbers and number ranges as
6504 understood by number_or_range_parser. Only breakpoints included in this
6505 list are then printed.
6507 If SHOW_INTERNAL is true, print internal breakpoints.
6509 If FILTER is non-NULL, call it on each breakpoint and only include the
6510 ones for which it returns true.
6512 Return the total number of breakpoints listed. */
6515 breakpoint_1 (const char *bp_num_list
, bool show_internal
,
6516 bool (*filter
) (const struct breakpoint
*))
6518 struct bp_location
*last_loc
= NULL
;
6519 int nr_printable_breakpoints
;
6520 struct value_print_options opts
;
6521 int print_address_bits
= 0;
6522 int print_type_col_width
= 14;
6523 struct ui_out
*uiout
= current_uiout
;
6524 bool has_disabled_by_cond_location
= false;
6526 get_user_print_options (&opts
);
6528 /* Compute the number of rows in the table, as well as the size
6529 required for address fields. */
6530 nr_printable_breakpoints
= 0;
6531 for (breakpoint
*b
: all_breakpoints ())
6533 /* If we have a filter, only list the breakpoints it accepts. */
6534 if (filter
&& !filter (b
))
6537 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6538 accept. Skip the others. */
6539 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6541 if (show_internal
&& parse_and_eval_long (bp_num_list
) != b
->number
)
6543 if (!show_internal
&& !number_is_in_list (bp_num_list
, b
->number
))
6547 if (show_internal
|| user_breakpoint_p (b
))
6549 int addr_bit
, type_len
;
6551 addr_bit
= breakpoint_address_bits (b
);
6552 if (addr_bit
> print_address_bits
)
6553 print_address_bits
= addr_bit
;
6555 type_len
= strlen (bptype_string (b
->type
));
6556 if (type_len
> print_type_col_width
)
6557 print_type_col_width
= type_len
;
6559 nr_printable_breakpoints
++;
6564 ui_out_emit_table
table_emitter (uiout
,
6565 opts
.addressprint
? 6 : 5,
6566 nr_printable_breakpoints
,
6569 if (nr_printable_breakpoints
> 0)
6570 annotate_breakpoints_headers ();
6571 if (nr_printable_breakpoints
> 0)
6573 uiout
->table_header (7, ui_left
, "number", "Num"); /* 1 */
6574 if (nr_printable_breakpoints
> 0)
6576 uiout
->table_header (print_type_col_width
, ui_left
, "type", "Type"); /* 2 */
6577 if (nr_printable_breakpoints
> 0)
6579 uiout
->table_header (4, ui_left
, "disp", "Disp"); /* 3 */
6580 if (nr_printable_breakpoints
> 0)
6582 uiout
->table_header (3, ui_left
, "enabled", "Enb"); /* 4 */
6583 if (opts
.addressprint
)
6585 if (nr_printable_breakpoints
> 0)
6587 if (print_address_bits
<= 32)
6588 uiout
->table_header (10, ui_left
, "addr", "Address"); /* 5 */
6590 uiout
->table_header (18, ui_left
, "addr", "Address"); /* 5 */
6592 if (nr_printable_breakpoints
> 0)
6594 uiout
->table_header (40, ui_noalign
, "what", "What"); /* 6 */
6595 uiout
->table_body ();
6596 if (nr_printable_breakpoints
> 0)
6597 annotate_breakpoints_table ();
6599 for (breakpoint
*b
: all_breakpoints ())
6602 /* If we have a filter, only list the breakpoints it accepts. */
6603 if (filter
&& !filter (b
))
6606 /* If we have a BP_NUM_LIST string, it is a list of breakpoints to
6607 accept. Skip the others. */
6609 if (bp_num_list
!= NULL
&& *bp_num_list
!= '\0')
6611 if (show_internal
) /* maintenance info breakpoint */
6613 if (parse_and_eval_long (bp_num_list
) != b
->number
)
6616 else /* all others */
6618 if (!number_is_in_list (bp_num_list
, b
->number
))
6622 /* We only print out user settable breakpoints unless the
6623 show_internal is set. */
6624 if (show_internal
|| user_breakpoint_p (b
))
6626 print_one_breakpoint (b
, &last_loc
, show_internal
);
6627 for (bp_location
*loc
: b
->locations ())
6628 if (loc
->disabled_by_cond
)
6629 has_disabled_by_cond_location
= true;
6634 if (nr_printable_breakpoints
== 0)
6636 /* If there's a filter, let the caller decide how to report
6640 if (bp_num_list
== NULL
|| *bp_num_list
== '\0')
6641 uiout
->message ("No breakpoints or watchpoints.\n");
6643 uiout
->message ("No breakpoint or watchpoint matching '%s'.\n",
6649 if (last_loc
&& !server_command
)
6650 set_next_address (last_loc
->gdbarch
, last_loc
->address
);
6652 if (has_disabled_by_cond_location
&& !uiout
->is_mi_like_p ())
6653 uiout
->message (_("(*): Breakpoint condition is invalid at this "
6657 /* FIXME? Should this be moved up so that it is only called when
6658 there have been breakpoints? */
6659 annotate_breakpoints_table_end ();
6661 return nr_printable_breakpoints
;
6664 /* Display the value of default-collect in a way that is generally
6665 compatible with the breakpoint list. */
6668 default_collect_info (void)
6670 struct ui_out
*uiout
= current_uiout
;
6672 /* If it has no value (which is frequently the case), say nothing; a
6673 message like "No default-collect." gets in user's face when it's
6675 if (!*default_collect
)
6678 /* The following phrase lines up nicely with per-tracepoint collect
6680 uiout
->text ("default collect ");
6681 uiout
->field_string ("default-collect", default_collect
);
6682 uiout
->text (" \n");
6686 info_breakpoints_command (const char *args
, int from_tty
)
6688 breakpoint_1 (args
, false, NULL
);
6690 default_collect_info ();
6694 info_watchpoints_command (const char *args
, int from_tty
)
6696 int num_printed
= breakpoint_1 (args
, false, is_watchpoint
);
6697 struct ui_out
*uiout
= current_uiout
;
6699 if (num_printed
== 0)
6701 if (args
== NULL
|| *args
== '\0')
6702 uiout
->message ("No watchpoints.\n");
6704 uiout
->message ("No watchpoint matching '%s'.\n", args
);
6709 maintenance_info_breakpoints (const char *args
, int from_tty
)
6711 breakpoint_1 (args
, true, NULL
);
6713 default_collect_info ();
6717 breakpoint_has_pc (struct breakpoint
*b
,
6718 struct program_space
*pspace
,
6719 CORE_ADDR pc
, struct obj_section
*section
)
6721 for (bp_location
*bl
: b
->locations ())
6723 if (bl
->pspace
== pspace
6724 && bl
->address
== pc
6725 && (!overlay_debugging
|| bl
->section
== section
))
6731 /* Print a message describing any user-breakpoints set at PC. This
6732 concerns with logical breakpoints, so we match program spaces, not
6736 describe_other_breakpoints (struct gdbarch
*gdbarch
,
6737 struct program_space
*pspace
, CORE_ADDR pc
,
6738 struct obj_section
*section
, int thread
)
6742 for (breakpoint
*b
: all_breakpoints ())
6743 others
+= (user_breakpoint_p (b
)
6744 && breakpoint_has_pc (b
, pspace
, pc
, section
));
6749 printf_filtered (_("Note: breakpoint "));
6750 else /* if (others == ???) */
6751 printf_filtered (_("Note: breakpoints "));
6752 for (breakpoint
*b
: all_breakpoints ())
6753 if (user_breakpoint_p (b
) && breakpoint_has_pc (b
, pspace
, pc
, section
))
6756 printf_filtered ("%d", b
->number
);
6757 if (b
->thread
== -1 && thread
!= -1)
6758 printf_filtered (" (all threads)");
6759 else if (b
->thread
!= -1)
6760 printf_filtered (" (thread %d)", b
->thread
);
6761 printf_filtered ("%s%s ",
6762 ((b
->enable_state
== bp_disabled
6763 || b
->enable_state
== bp_call_disabled
)
6767 : ((others
== 1) ? " and" : ""));
6769 current_uiout
->message (_("also set at pc %ps.\n"),
6770 styled_string (address_style
.style (),
6771 paddress (gdbarch
, pc
)));
6776 /* Return true iff it is meaningful to use the address member of LOC.
6777 For some breakpoint types, the locations' address members are
6778 irrelevant and it makes no sense to attempt to compare them to
6779 other addresses (or use them for any other purpose either).
6781 More specifically, software watchpoints and catchpoints that are
6782 not backed by breakpoints always have a zero valued location
6783 address and we don't want to mark breakpoints of any of these types
6784 to be a duplicate of an actual breakpoint location at address
6788 bl_address_is_meaningful (bp_location
*loc
)
6790 return loc
->loc_type
!= bp_loc_other
;
6793 /* Assuming LOC1 and LOC2's owners are hardware watchpoints, returns
6794 true if LOC1 and LOC2 represent the same watchpoint location. */
6797 watchpoint_locations_match (struct bp_location
*loc1
,
6798 struct bp_location
*loc2
)
6800 struct watchpoint
*w1
= (struct watchpoint
*) loc1
->owner
;
6801 struct watchpoint
*w2
= (struct watchpoint
*) loc2
->owner
;
6803 /* Both of them must exist. */
6804 gdb_assert (w1
!= NULL
);
6805 gdb_assert (w2
!= NULL
);
6807 /* If the target can evaluate the condition expression in hardware,
6808 then we we need to insert both watchpoints even if they are at
6809 the same place. Otherwise the watchpoint will only trigger when
6810 the condition of whichever watchpoint was inserted evaluates to
6811 true, not giving a chance for GDB to check the condition of the
6812 other watchpoint. */
6814 && target_can_accel_watchpoint_condition (loc1
->address
,
6816 loc1
->watchpoint_type
,
6817 w1
->cond_exp
.get ()))
6819 && target_can_accel_watchpoint_condition (loc2
->address
,
6821 loc2
->watchpoint_type
,
6822 w2
->cond_exp
.get ())))
6825 /* Note that this checks the owner's type, not the location's. In
6826 case the target does not support read watchpoints, but does
6827 support access watchpoints, we'll have bp_read_watchpoint
6828 watchpoints with hw_access locations. Those should be considered
6829 duplicates of hw_read locations. The hw_read locations will
6830 become hw_access locations later. */
6831 return (loc1
->owner
->type
== loc2
->owner
->type
6832 && loc1
->pspace
->aspace
== loc2
->pspace
->aspace
6833 && loc1
->address
== loc2
->address
6834 && loc1
->length
== loc2
->length
);
6837 /* See breakpoint.h. */
6840 breakpoint_address_match (const address_space
*aspace1
, CORE_ADDR addr1
,
6841 const address_space
*aspace2
, CORE_ADDR addr2
)
6843 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6844 || aspace1
== aspace2
)
6848 /* Returns true if {ASPACE2,ADDR2} falls within the range determined by
6849 {ASPACE1,ADDR1,LEN1}. In most targets, this can only be true if ASPACE1
6850 matches ASPACE2. On targets that have global breakpoints, the address
6851 space doesn't really matter. */
6854 breakpoint_address_match_range (const address_space
*aspace1
,
6856 int len1
, const address_space
*aspace2
,
6859 return ((gdbarch_has_global_breakpoints (target_gdbarch ())
6860 || aspace1
== aspace2
)
6861 && addr2
>= addr1
&& addr2
< addr1
+ len1
);
6864 /* Returns true if {ASPACE,ADDR} matches the breakpoint BL. BL may be
6865 a ranged breakpoint. In most targets, a match happens only if ASPACE
6866 matches the breakpoint's address space. On targets that have global
6867 breakpoints, the address space doesn't really matter. */
6870 breakpoint_location_address_match (struct bp_location
*bl
,
6871 const address_space
*aspace
,
6874 return (breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
6877 && breakpoint_address_match_range (bl
->pspace
->aspace
,
6878 bl
->address
, bl
->length
,
6882 /* Returns true if the [ADDR,ADDR+LEN) range in ASPACE overlaps
6883 breakpoint BL. BL may be a ranged breakpoint. In most targets, a
6884 match happens only if ASPACE matches the breakpoint's address
6885 space. On targets that have global breakpoints, the address space
6886 doesn't really matter. */
6889 breakpoint_location_address_range_overlap (struct bp_location
*bl
,
6890 const address_space
*aspace
,
6891 CORE_ADDR addr
, int len
)
6893 if (gdbarch_has_global_breakpoints (target_gdbarch ())
6894 || bl
->pspace
->aspace
== aspace
)
6896 int bl_len
= bl
->length
!= 0 ? bl
->length
: 1;
6898 if (mem_ranges_overlap (addr
, len
, bl
->address
, bl_len
))
6904 /* If LOC1 and LOC2's owners are not tracepoints, returns false directly.
6905 Then, if LOC1 and LOC2 represent the same tracepoint location, returns
6906 true, otherwise returns false. */
6909 tracepoint_locations_match (struct bp_location
*loc1
,
6910 struct bp_location
*loc2
)
6912 if (is_tracepoint (loc1
->owner
) && is_tracepoint (loc2
->owner
))
6913 /* Since tracepoint locations are never duplicated with others', tracepoint
6914 locations at the same address of different tracepoints are regarded as
6915 different locations. */
6916 return (loc1
->address
== loc2
->address
&& loc1
->owner
== loc2
->owner
);
6921 /* Assuming LOC1 and LOC2's types' have meaningful target addresses
6922 (bl_address_is_meaningful), returns true if LOC1 and LOC2 represent
6923 the same location. If SW_HW_BPS_MATCH is true, then software
6924 breakpoint locations and hardware breakpoint locations match,
6925 otherwise they don't. */
6928 breakpoint_locations_match (struct bp_location
*loc1
,
6929 struct bp_location
*loc2
,
6930 bool sw_hw_bps_match
)
6932 int hw_point1
, hw_point2
;
6934 /* Both of them must not be in moribund_locations. */
6935 gdb_assert (loc1
->owner
!= NULL
);
6936 gdb_assert (loc2
->owner
!= NULL
);
6938 hw_point1
= is_hardware_watchpoint (loc1
->owner
);
6939 hw_point2
= is_hardware_watchpoint (loc2
->owner
);
6941 if (hw_point1
!= hw_point2
)
6944 return watchpoint_locations_match (loc1
, loc2
);
6945 else if (is_tracepoint (loc1
->owner
) || is_tracepoint (loc2
->owner
))
6946 return tracepoint_locations_match (loc1
, loc2
);
6948 /* We compare bp_location.length in order to cover ranged
6949 breakpoints. Keep this in sync with
6950 bp_location_is_less_than. */
6951 return (breakpoint_address_match (loc1
->pspace
->aspace
, loc1
->address
,
6952 loc2
->pspace
->aspace
, loc2
->address
)
6953 && (loc1
->loc_type
== loc2
->loc_type
|| sw_hw_bps_match
)
6954 && loc1
->length
== loc2
->length
);
6958 breakpoint_adjustment_warning (CORE_ADDR from_addr
, CORE_ADDR to_addr
,
6959 int bnum
, int have_bnum
)
6961 /* The longest string possibly returned by hex_string_custom
6962 is 50 chars. These must be at least that big for safety. */
6966 strcpy (astr1
, hex_string_custom ((unsigned long) from_addr
, 8));
6967 strcpy (astr2
, hex_string_custom ((unsigned long) to_addr
, 8));
6969 warning (_("Breakpoint %d address previously adjusted from %s to %s."),
6970 bnum
, astr1
, astr2
);
6972 warning (_("Breakpoint address adjusted from %s to %s."), astr1
, astr2
);
6975 /* Adjust a breakpoint's address to account for architectural
6976 constraints on breakpoint placement. Return the adjusted address.
6977 Note: Very few targets require this kind of adjustment. For most
6978 targets, this function is simply the identity function. */
6981 adjust_breakpoint_address (struct gdbarch
*gdbarch
,
6982 CORE_ADDR bpaddr
, enum bptype bptype
)
6984 if (bptype
== bp_watchpoint
6985 || bptype
== bp_hardware_watchpoint
6986 || bptype
== bp_read_watchpoint
6987 || bptype
== bp_access_watchpoint
6988 || bptype
== bp_catchpoint
)
6990 /* Watchpoints and the various bp_catch_* eventpoints should not
6991 have their addresses modified. */
6994 else if (bptype
== bp_single_step
)
6996 /* Single-step breakpoints should not have their addresses
6997 modified. If there's any architectural constrain that
6998 applies to this address, then it should have already been
6999 taken into account when the breakpoint was created in the
7000 first place. If we didn't do this, stepping through e.g.,
7001 Thumb-2 IT blocks would break. */
7006 CORE_ADDR adjusted_bpaddr
= bpaddr
;
7008 if (gdbarch_adjust_breakpoint_address_p (gdbarch
))
7010 /* Some targets have architectural constraints on the placement
7011 of breakpoint instructions. Obtain the adjusted address. */
7012 adjusted_bpaddr
= gdbarch_adjust_breakpoint_address (gdbarch
, bpaddr
);
7015 adjusted_bpaddr
= address_significant (gdbarch
, adjusted_bpaddr
);
7017 /* An adjusted breakpoint address can significantly alter
7018 a user's expectations. Print a warning if an adjustment
7020 if (adjusted_bpaddr
!= bpaddr
)
7021 breakpoint_adjustment_warning (bpaddr
, adjusted_bpaddr
, 0, 0);
7023 return adjusted_bpaddr
;
7028 bp_location_from_bp_type (bptype type
)
7033 case bp_single_step
:
7037 case bp_longjmp_resume
:
7038 case bp_longjmp_call_dummy
:
7040 case bp_exception_resume
:
7041 case bp_step_resume
:
7042 case bp_hp_step_resume
:
7043 case bp_watchpoint_scope
:
7045 case bp_std_terminate
:
7046 case bp_shlib_event
:
7047 case bp_thread_event
:
7048 case bp_overlay_event
:
7050 case bp_longjmp_master
:
7051 case bp_std_terminate_master
:
7052 case bp_exception_master
:
7053 case bp_gnu_ifunc_resolver
:
7054 case bp_gnu_ifunc_resolver_return
:
7056 return bp_loc_software_breakpoint
;
7057 case bp_hardware_breakpoint
:
7058 return bp_loc_hardware_breakpoint
;
7059 case bp_hardware_watchpoint
:
7060 case bp_read_watchpoint
:
7061 case bp_access_watchpoint
:
7062 return bp_loc_hardware_watchpoint
;
7066 case bp_fast_tracepoint
:
7067 case bp_static_tracepoint
:
7068 return bp_loc_other
;
7070 internal_error (__FILE__
, __LINE__
, _("unknown breakpoint type"));
7074 bp_location::bp_location (breakpoint
*owner
, bp_loc_type type
)
7076 this->owner
= owner
;
7077 this->cond_bytecode
= NULL
;
7078 this->shlib_disabled
= 0;
7080 this->disabled_by_cond
= false;
7082 this->loc_type
= type
;
7084 if (this->loc_type
== bp_loc_software_breakpoint
7085 || this->loc_type
== bp_loc_hardware_breakpoint
)
7086 mark_breakpoint_location_modified (this);
7091 bp_location::bp_location (breakpoint
*owner
)
7092 : bp_location::bp_location (owner
,
7093 bp_location_from_bp_type (owner
->type
))
7097 /* Allocate a struct bp_location. */
7099 static struct bp_location
*
7100 allocate_bp_location (struct breakpoint
*bpt
)
7102 return bpt
->ops
->allocate_location (bpt
);
7105 /* Decrement reference count. If the reference count reaches 0,
7106 destroy the bp_location. Sets *BLP to NULL. */
7109 decref_bp_location (struct bp_location
**blp
)
7111 bp_location_ref_policy::decref (*blp
);
7115 /* Add breakpoint B at the end of the global breakpoint chain. */
7118 add_to_breakpoint_chain (std::unique_ptr
<breakpoint
> &&b
)
7120 struct breakpoint
*b1
;
7121 struct breakpoint
*result
= b
.get ();
7123 /* Add this breakpoint to the end of the chain so that a list of
7124 breakpoints will come out in order of increasing numbers. */
7126 b1
= breakpoint_chain
;
7128 breakpoint_chain
= b
.release ();
7133 b1
->next
= b
.release ();
7139 /* Initializes breakpoint B with type BPTYPE and no locations yet. */
7142 init_raw_breakpoint_without_location (struct breakpoint
*b
,
7143 struct gdbarch
*gdbarch
,
7145 const struct breakpoint_ops
*ops
)
7147 gdb_assert (ops
!= NULL
);
7151 b
->gdbarch
= gdbarch
;
7152 b
->language
= current_language
->la_language
;
7153 b
->input_radix
= input_radix
;
7154 b
->related_breakpoint
= b
;
7157 /* Helper to set_raw_breakpoint below. Creates a breakpoint
7158 that has type BPTYPE and has no locations as yet. */
7160 static struct breakpoint
*
7161 set_raw_breakpoint_without_location (struct gdbarch
*gdbarch
,
7163 const struct breakpoint_ops
*ops
)
7165 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7167 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bptype
, ops
);
7168 return add_to_breakpoint_chain (std::move (b
));
7171 /* Initialize loc->function_name. */
7174 set_breakpoint_location_function (struct bp_location
*loc
)
7176 gdb_assert (loc
->owner
!= NULL
);
7178 if (loc
->owner
->type
== bp_breakpoint
7179 || loc
->owner
->type
== bp_hardware_breakpoint
7180 || is_tracepoint (loc
->owner
))
7182 const char *function_name
;
7184 if (loc
->msymbol
!= NULL
7185 && (MSYMBOL_TYPE (loc
->msymbol
) == mst_text_gnu_ifunc
7186 || MSYMBOL_TYPE (loc
->msymbol
) == mst_data_gnu_ifunc
))
7188 struct breakpoint
*b
= loc
->owner
;
7190 function_name
= loc
->msymbol
->linkage_name ();
7192 if (b
->type
== bp_breakpoint
&& b
->loc
== loc
7193 && loc
->next
== NULL
&& b
->related_breakpoint
== b
)
7195 /* Create only the whole new breakpoint of this type but do not
7196 mess more complicated breakpoints with multiple locations. */
7197 b
->type
= bp_gnu_ifunc_resolver
;
7198 /* Remember the resolver's address for use by the return
7200 loc
->related_address
= loc
->address
;
7204 find_pc_partial_function (loc
->address
, &function_name
, NULL
, NULL
);
7207 loc
->function_name
= xstrdup (function_name
);
7211 /* Attempt to determine architecture of location identified by SAL. */
7213 get_sal_arch (struct symtab_and_line sal
)
7216 return sal
.section
->objfile
->arch ();
7218 return SYMTAB_OBJFILE (sal
.symtab
)->arch ();
7223 /* Low level routine for partially initializing a breakpoint of type
7224 BPTYPE. The newly created breakpoint's address, section, source
7225 file name, and line number are provided by SAL.
7227 It is expected that the caller will complete the initialization of
7228 the newly created breakpoint struct as well as output any status
7229 information regarding the creation of a new breakpoint. */
7232 init_raw_breakpoint (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
7233 struct symtab_and_line sal
, enum bptype bptype
,
7234 const struct breakpoint_ops
*ops
)
7236 init_raw_breakpoint_without_location (b
, gdbarch
, bptype
, ops
);
7238 add_location_to_breakpoint (b
, &sal
);
7240 if (bptype
!= bp_catchpoint
)
7241 gdb_assert (sal
.pspace
!= NULL
);
7243 /* Store the program space that was used to set the breakpoint,
7244 except for ordinary breakpoints, which are independent of the
7246 if (bptype
!= bp_breakpoint
&& bptype
!= bp_hardware_breakpoint
)
7247 b
->pspace
= sal
.pspace
;
7250 /* set_raw_breakpoint is a low level routine for allocating and
7251 partially initializing a breakpoint of type BPTYPE. The newly
7252 created breakpoint's address, section, source file name, and line
7253 number are provided by SAL. The newly created and partially
7254 initialized breakpoint is added to the breakpoint chain and
7255 is also returned as the value of this function.
7257 It is expected that the caller will complete the initialization of
7258 the newly created breakpoint struct as well as output any status
7259 information regarding the creation of a new breakpoint. In
7260 particular, set_raw_breakpoint does NOT set the breakpoint
7261 number! Care should be taken to not allow an error to occur
7262 prior to completing the initialization of the breakpoint. If this
7263 should happen, a bogus breakpoint will be left on the chain. */
7266 set_raw_breakpoint (struct gdbarch
*gdbarch
,
7267 struct symtab_and_line sal
, enum bptype bptype
,
7268 const struct breakpoint_ops
*ops
)
7270 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (bptype
);
7272 init_raw_breakpoint (b
.get (), gdbarch
, sal
, bptype
, ops
);
7273 return add_to_breakpoint_chain (std::move (b
));
7276 /* Call this routine when stepping and nexting to enable a breakpoint
7277 if we do a longjmp() or 'throw' in TP. FRAME is the frame which
7278 initiated the operation. */
7281 set_longjmp_breakpoint (struct thread_info
*tp
, struct frame_id frame
)
7283 int thread
= tp
->global_num
;
7285 /* To avoid having to rescan all objfile symbols at every step,
7286 we maintain a list of continually-inserted but always disabled
7287 longjmp "master" breakpoints. Here, we simply create momentary
7288 clones of those and enable them for the requested thread. */
7289 for (breakpoint
*b
: all_breakpoints_safe ())
7290 if (b
->pspace
== current_program_space
7291 && (b
->type
== bp_longjmp_master
7292 || b
->type
== bp_exception_master
))
7294 enum bptype type
= b
->type
== bp_longjmp_master
? bp_longjmp
: bp_exception
;
7295 struct breakpoint
*clone
;
7297 /* longjmp_breakpoint_ops ensures INITIATING_FRAME is cleared again
7298 after their removal. */
7299 clone
= momentary_breakpoint_from_master (b
, type
,
7300 &momentary_breakpoint_ops
, 1);
7301 clone
->thread
= thread
;
7304 tp
->initiating_frame
= frame
;
7307 /* Delete all longjmp breakpoints from THREAD. */
7309 delete_longjmp_breakpoint (int thread
)
7311 for (breakpoint
*b
: all_breakpoints_safe ())
7312 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7314 if (b
->thread
== thread
)
7315 delete_breakpoint (b
);
7320 delete_longjmp_breakpoint_at_next_stop (int thread
)
7322 for (breakpoint
*b
: all_breakpoints_safe ())
7323 if (b
->type
== bp_longjmp
|| b
->type
== bp_exception
)
7325 if (b
->thread
== thread
)
7326 b
->disposition
= disp_del_at_next_stop
;
7330 /* Place breakpoints of type bp_longjmp_call_dummy to catch longjmp for
7331 INFERIOR_PTID thread. Chain them all by RELATED_BREAKPOINT and return
7332 pointer to any of them. Return NULL if this system cannot place longjmp
7336 set_longjmp_breakpoint_for_call_dummy (void)
7338 breakpoint
*retval
= nullptr;
7340 for (breakpoint
*b
: all_breakpoints ())
7341 if (b
->pspace
== current_program_space
&& b
->type
== bp_longjmp_master
)
7343 struct breakpoint
*new_b
;
7345 new_b
= momentary_breakpoint_from_master (b
, bp_longjmp_call_dummy
,
7346 &momentary_breakpoint_ops
,
7348 new_b
->thread
= inferior_thread ()->global_num
;
7350 /* Link NEW_B into the chain of RETVAL breakpoints. */
7352 gdb_assert (new_b
->related_breakpoint
== new_b
);
7355 new_b
->related_breakpoint
= retval
;
7356 while (retval
->related_breakpoint
!= new_b
->related_breakpoint
)
7357 retval
= retval
->related_breakpoint
;
7358 retval
->related_breakpoint
= new_b
;
7364 /* Verify all existing dummy frames and their associated breakpoints for
7365 TP. Remove those which can no longer be found in the current frame
7368 If the unwind fails then there is not sufficient information to discard
7369 dummy frames. In this case, elide the clean up and the dummy frames will
7370 be cleaned up next time this function is called from a location where
7371 unwinding is possible. */
7374 check_longjmp_breakpoint_for_call_dummy (struct thread_info
*tp
)
7376 struct breakpoint
*b
, *b_tmp
;
7378 ALL_BREAKPOINTS_SAFE (b
, b_tmp
)
7379 if (b
->type
== bp_longjmp_call_dummy
&& b
->thread
== tp
->global_num
)
7381 struct breakpoint
*dummy_b
= b
->related_breakpoint
;
7383 /* Find the bp_call_dummy breakpoint in the list of breakpoints
7384 chained off b->related_breakpoint. */
7385 while (dummy_b
!= b
&& dummy_b
->type
!= bp_call_dummy
)
7386 dummy_b
= dummy_b
->related_breakpoint
;
7388 /* If there was no bp_call_dummy breakpoint then there's nothing
7389 more to do. Or, if the dummy frame associated with the
7390 bp_call_dummy is still on the stack then we need to leave this
7391 bp_call_dummy in place. */
7392 if (dummy_b
->type
!= bp_call_dummy
7393 || frame_find_by_id (dummy_b
->frame_id
) != NULL
)
7396 /* We didn't find the dummy frame on the stack, this could be
7397 because we have longjmp'd to a stack frame that is previous to
7398 the dummy frame, or it could be because the stack unwind is
7399 broken at some point between the longjmp frame and the dummy
7402 Next we figure out why the stack unwind stopped. If it looks
7403 like the unwind is complete then we assume the dummy frame has
7404 been jumped over, however, if the unwind stopped for an
7405 unexpected reason then we assume the stack unwind is currently
7406 broken, and that we will (eventually) return to the dummy
7409 It might be tempting to consider using frame_id_inner here, but
7410 that is not safe. There is no guarantee that the stack frames
7411 we are looking at here are even on the same stack as the
7412 original dummy frame, hence frame_id_inner can't be used. See
7413 the comments on frame_id_inner for more details. */
7414 bool unwind_finished_unexpectedly
= false;
7415 for (struct frame_info
*fi
= get_current_frame (); fi
!= nullptr; )
7417 struct frame_info
*prev
= get_prev_frame (fi
);
7418 if (prev
== nullptr)
7420 /* FI is the last stack frame. Why did this frame not
7422 auto stop_reason
= get_frame_unwind_stop_reason (fi
);
7423 if (stop_reason
!= UNWIND_NO_REASON
7424 && stop_reason
!= UNWIND_OUTERMOST
)
7425 unwind_finished_unexpectedly
= true;
7429 if (unwind_finished_unexpectedly
)
7432 dummy_frame_discard (dummy_b
->frame_id
, tp
);
7434 while (b
->related_breakpoint
!= b
)
7436 if (b_tmp
== b
->related_breakpoint
)
7437 b_tmp
= b
->related_breakpoint
->next
;
7438 delete_breakpoint (b
->related_breakpoint
);
7440 delete_breakpoint (b
);
7445 enable_overlay_breakpoints (void)
7447 for (breakpoint
*b
: all_breakpoints ())
7448 if (b
->type
== bp_overlay_event
)
7450 b
->enable_state
= bp_enabled
;
7451 update_global_location_list (UGLL_MAY_INSERT
);
7452 overlay_events_enabled
= 1;
7457 disable_overlay_breakpoints (void)
7459 for (breakpoint
*b
: all_breakpoints ())
7460 if (b
->type
== bp_overlay_event
)
7462 b
->enable_state
= bp_disabled
;
7463 update_global_location_list (UGLL_DONT_INSERT
);
7464 overlay_events_enabled
= 0;
7468 /* Set an active std::terminate breakpoint for each std::terminate
7469 master breakpoint. */
7471 set_std_terminate_breakpoint (void)
7473 for (breakpoint
*b
: all_breakpoints_safe ())
7474 if (b
->pspace
== current_program_space
7475 && b
->type
== bp_std_terminate_master
)
7477 momentary_breakpoint_from_master (b
, bp_std_terminate
,
7478 &momentary_breakpoint_ops
, 1);
7482 /* Delete all the std::terminate breakpoints. */
7484 delete_std_terminate_breakpoint (void)
7486 for (breakpoint
*b
: all_breakpoints_safe ())
7487 if (b
->type
== bp_std_terminate
)
7488 delete_breakpoint (b
);
7492 create_thread_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7494 struct breakpoint
*b
;
7496 b
= create_internal_breakpoint (gdbarch
, address
, bp_thread_event
,
7497 &internal_breakpoint_ops
);
7499 b
->enable_state
= bp_enabled
;
7500 /* location has to be used or breakpoint_re_set will delete me. */
7501 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
7503 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
7508 struct lang_and_radix
7514 /* Create a breakpoint for JIT code registration and unregistration. */
7517 create_jit_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7519 return create_internal_breakpoint (gdbarch
, address
, bp_jit_event
,
7520 &internal_breakpoint_ops
);
7523 /* Remove JIT code registration and unregistration breakpoint(s). */
7526 remove_jit_event_breakpoints (void)
7528 for (breakpoint
*b
: all_breakpoints_safe ())
7529 if (b
->type
== bp_jit_event
7530 && b
->loc
->pspace
== current_program_space
)
7531 delete_breakpoint (b
);
7535 remove_solib_event_breakpoints (void)
7537 for (breakpoint
*b
: all_breakpoints_safe ())
7538 if (b
->type
== bp_shlib_event
7539 && b
->loc
->pspace
== current_program_space
)
7540 delete_breakpoint (b
);
7543 /* See breakpoint.h. */
7546 remove_solib_event_breakpoints_at_next_stop (void)
7548 for (breakpoint
*b
: all_breakpoints_safe ())
7549 if (b
->type
== bp_shlib_event
7550 && b
->loc
->pspace
== current_program_space
)
7551 b
->disposition
= disp_del_at_next_stop
;
7554 /* Helper for create_solib_event_breakpoint /
7555 create_and_insert_solib_event_breakpoint. Allows specifying which
7556 INSERT_MODE to pass through to update_global_location_list. */
7558 static struct breakpoint
*
7559 create_solib_event_breakpoint_1 (struct gdbarch
*gdbarch
, CORE_ADDR address
,
7560 enum ugll_insert_mode insert_mode
)
7562 struct breakpoint
*b
;
7564 b
= create_internal_breakpoint (gdbarch
, address
, bp_shlib_event
,
7565 &internal_breakpoint_ops
);
7566 update_global_location_list_nothrow (insert_mode
);
7571 create_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7573 return create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_MAY_INSERT
);
7576 /* See breakpoint.h. */
7579 create_and_insert_solib_event_breakpoint (struct gdbarch
*gdbarch
, CORE_ADDR address
)
7581 struct breakpoint
*b
;
7583 /* Explicitly tell update_global_location_list to insert
7585 b
= create_solib_event_breakpoint_1 (gdbarch
, address
, UGLL_INSERT
);
7586 if (!b
->loc
->inserted
)
7588 delete_breakpoint (b
);
7594 /* Disable any breakpoints that are on code in shared libraries. Only
7595 apply to enabled breakpoints, disabled ones can just stay disabled. */
7598 disable_breakpoints_in_shlibs (void)
7600 for (bp_location
*loc
: all_bp_locations ())
7602 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7603 struct breakpoint
*b
= loc
->owner
;
7605 /* We apply the check to all breakpoints, including disabled for
7606 those with loc->duplicate set. This is so that when breakpoint
7607 becomes enabled, or the duplicate is removed, gdb will try to
7608 insert all breakpoints. If we don't set shlib_disabled here,
7609 we'll try to insert those breakpoints and fail. */
7610 if (((b
->type
== bp_breakpoint
)
7611 || (b
->type
== bp_jit_event
)
7612 || (b
->type
== bp_hardware_breakpoint
)
7613 || (is_tracepoint (b
)))
7614 && loc
->pspace
== current_program_space
7615 && !loc
->shlib_disabled
7616 && solib_name_from_address (loc
->pspace
, loc
->address
)
7619 loc
->shlib_disabled
= 1;
7624 /* Disable any breakpoints and tracepoints that are in SOLIB upon
7625 notification of unloaded_shlib. Only apply to enabled breakpoints,
7626 disabled ones can just stay disabled. */
7629 disable_breakpoints_in_unloaded_shlib (struct so_list
*solib
)
7631 int disabled_shlib_breaks
= 0;
7633 for (bp_location
*loc
: all_bp_locations ())
7635 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always non-NULL. */
7636 struct breakpoint
*b
= loc
->owner
;
7638 if (solib
->pspace
== loc
->pspace
7639 && !loc
->shlib_disabled
7640 && (((b
->type
== bp_breakpoint
7641 || b
->type
== bp_jit_event
7642 || b
->type
== bp_hardware_breakpoint
)
7643 && (loc
->loc_type
== bp_loc_hardware_breakpoint
7644 || loc
->loc_type
== bp_loc_software_breakpoint
))
7645 || is_tracepoint (b
))
7646 && solib_contains_address_p (solib
, loc
->address
))
7648 loc
->shlib_disabled
= 1;
7649 /* At this point, we cannot rely on remove_breakpoint
7650 succeeding so we must mark the breakpoint as not inserted
7651 to prevent future errors occurring in remove_breakpoints. */
7654 /* This may cause duplicate notifications for the same breakpoint. */
7655 gdb::observers::breakpoint_modified
.notify (b
);
7657 if (!disabled_shlib_breaks
)
7659 target_terminal::ours_for_output ();
7660 warning (_("Temporarily disabling breakpoints "
7661 "for unloaded shared library \"%s\""),
7664 disabled_shlib_breaks
= 1;
7669 /* Disable any breakpoints and tracepoints in OBJFILE upon
7670 notification of free_objfile. Only apply to enabled breakpoints,
7671 disabled ones can just stay disabled. */
7674 disable_breakpoints_in_freed_objfile (struct objfile
*objfile
)
7676 if (objfile
== NULL
)
7679 /* OBJF_SHARED|OBJF_USERLOADED objfiles are dynamic modules manually
7680 managed by the user with add-symbol-file/remove-symbol-file.
7681 Similarly to how breakpoints in shared libraries are handled in
7682 response to "nosharedlibrary", mark breakpoints in such modules
7683 shlib_disabled so they end up uninserted on the next global
7684 location list update. Shared libraries not loaded by the user
7685 aren't handled here -- they're already handled in
7686 disable_breakpoints_in_unloaded_shlib, called by solib.c's
7687 solib_unloaded observer. We skip objfiles that are not
7688 OBJF_SHARED as those aren't considered dynamic objects (e.g. the
7690 if ((objfile
->flags
& OBJF_SHARED
) == 0
7691 || (objfile
->flags
& OBJF_USERLOADED
) == 0)
7694 for (breakpoint
*b
: all_breakpoints ())
7696 int bp_modified
= 0;
7698 if (!is_breakpoint (b
) && !is_tracepoint (b
))
7701 for (bp_location
*loc
: b
->locations ())
7703 CORE_ADDR loc_addr
= loc
->address
;
7705 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7706 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7709 if (loc
->shlib_disabled
!= 0)
7712 if (objfile
->pspace
!= loc
->pspace
)
7715 if (loc
->loc_type
!= bp_loc_hardware_breakpoint
7716 && loc
->loc_type
!= bp_loc_software_breakpoint
)
7719 if (is_addr_in_objfile (loc_addr
, objfile
))
7721 loc
->shlib_disabled
= 1;
7722 /* At this point, we don't know whether the object was
7723 unmapped from the inferior or not, so leave the
7724 inserted flag alone. We'll handle failure to
7725 uninsert quietly, in case the object was indeed
7728 mark_breakpoint_location_modified (loc
);
7735 gdb::observers::breakpoint_modified
.notify (b
);
7739 /* FORK & VFORK catchpoints. */
7741 /* An instance of this type is used to represent a fork or vfork
7742 catchpoint. A breakpoint is really of this type iff its ops pointer points
7743 to CATCH_FORK_BREAKPOINT_OPS. */
7745 struct fork_catchpoint
: public breakpoint
7747 /* Process id of a child process whose forking triggered this
7748 catchpoint. This field is only valid immediately after this
7749 catchpoint has triggered. */
7750 ptid_t forked_inferior_pid
;
7753 /* Implement the "insert" breakpoint_ops method for fork
7757 insert_catch_fork (struct bp_location
*bl
)
7759 return target_insert_fork_catchpoint (inferior_ptid
.pid ());
7762 /* Implement the "remove" breakpoint_ops method for fork
7766 remove_catch_fork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7768 return target_remove_fork_catchpoint (inferior_ptid
.pid ());
7771 /* Implement the "breakpoint_hit" breakpoint_ops method for fork
7775 breakpoint_hit_catch_fork (const struct bp_location
*bl
,
7776 const address_space
*aspace
, CORE_ADDR bp_addr
,
7777 const struct target_waitstatus
*ws
)
7779 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7781 if (ws
->kind
!= TARGET_WAITKIND_FORKED
)
7784 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7788 /* Implement the "print_it" breakpoint_ops method for fork
7791 static enum print_stop_action
7792 print_it_catch_fork (bpstat bs
)
7794 struct ui_out
*uiout
= current_uiout
;
7795 struct breakpoint
*b
= bs
->breakpoint_at
;
7796 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bs
->breakpoint_at
;
7798 annotate_catchpoint (b
->number
);
7799 maybe_print_thread_hit_breakpoint (uiout
);
7800 if (b
->disposition
== disp_del
)
7801 uiout
->text ("Temporary catchpoint ");
7803 uiout
->text ("Catchpoint ");
7804 if (uiout
->is_mi_like_p ())
7806 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_FORK
));
7807 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7809 uiout
->field_signed ("bkptno", b
->number
);
7810 uiout
->text (" (forked process ");
7811 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7812 uiout
->text ("), ");
7813 return PRINT_SRC_AND_LOC
;
7816 /* Implement the "print_one" breakpoint_ops method for fork
7820 print_one_catch_fork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7822 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7823 struct value_print_options opts
;
7824 struct ui_out
*uiout
= current_uiout
;
7826 get_user_print_options (&opts
);
7828 /* Field 4, the address, is omitted (which makes the columns not
7829 line up too nicely with the headers, but the effect is relatively
7831 if (opts
.addressprint
)
7832 uiout
->field_skip ("addr");
7834 uiout
->text ("fork");
7835 if (c
->forked_inferior_pid
!= null_ptid
)
7837 uiout
->text (", process ");
7838 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7842 if (uiout
->is_mi_like_p ())
7843 uiout
->field_string ("catch-type", "fork");
7846 /* Implement the "print_mention" breakpoint_ops method for fork
7850 print_mention_catch_fork (struct breakpoint
*b
)
7852 printf_filtered (_("Catchpoint %d (fork)"), b
->number
);
7855 /* Implement the "print_recreate" breakpoint_ops method for fork
7859 print_recreate_catch_fork (struct breakpoint
*b
, struct ui_file
*fp
)
7861 fprintf_unfiltered (fp
, "catch fork");
7862 print_recreate_thread (b
, fp
);
7865 /* The breakpoint_ops structure to be used in fork catchpoints. */
7867 static struct breakpoint_ops catch_fork_breakpoint_ops
;
7869 /* Implement the "insert" breakpoint_ops method for vfork
7873 insert_catch_vfork (struct bp_location
*bl
)
7875 return target_insert_vfork_catchpoint (inferior_ptid
.pid ());
7878 /* Implement the "remove" breakpoint_ops method for vfork
7882 remove_catch_vfork (struct bp_location
*bl
, enum remove_bp_reason reason
)
7884 return target_remove_vfork_catchpoint (inferior_ptid
.pid ());
7887 /* Implement the "breakpoint_hit" breakpoint_ops method for vfork
7891 breakpoint_hit_catch_vfork (const struct bp_location
*bl
,
7892 const address_space
*aspace
, CORE_ADDR bp_addr
,
7893 const struct target_waitstatus
*ws
)
7895 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) bl
->owner
;
7897 if (ws
->kind
!= TARGET_WAITKIND_VFORKED
)
7900 c
->forked_inferior_pid
= ws
->value
.related_pid
;
7904 /* Implement the "print_it" breakpoint_ops method for vfork
7907 static enum print_stop_action
7908 print_it_catch_vfork (bpstat bs
)
7910 struct ui_out
*uiout
= current_uiout
;
7911 struct breakpoint
*b
= bs
->breakpoint_at
;
7912 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7914 annotate_catchpoint (b
->number
);
7915 maybe_print_thread_hit_breakpoint (uiout
);
7916 if (b
->disposition
== disp_del
)
7917 uiout
->text ("Temporary catchpoint ");
7919 uiout
->text ("Catchpoint ");
7920 if (uiout
->is_mi_like_p ())
7922 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_VFORK
));
7923 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
7925 uiout
->field_signed ("bkptno", b
->number
);
7926 uiout
->text (" (vforked process ");
7927 uiout
->field_signed ("newpid", c
->forked_inferior_pid
.pid ());
7928 uiout
->text ("), ");
7929 return PRINT_SRC_AND_LOC
;
7932 /* Implement the "print_one" breakpoint_ops method for vfork
7936 print_one_catch_vfork (struct breakpoint
*b
, struct bp_location
**last_loc
)
7938 struct fork_catchpoint
*c
= (struct fork_catchpoint
*) b
;
7939 struct value_print_options opts
;
7940 struct ui_out
*uiout
= current_uiout
;
7942 get_user_print_options (&opts
);
7943 /* Field 4, the address, is omitted (which makes the columns not
7944 line up too nicely with the headers, but the effect is relatively
7946 if (opts
.addressprint
)
7947 uiout
->field_skip ("addr");
7949 uiout
->text ("vfork");
7950 if (c
->forked_inferior_pid
!= null_ptid
)
7952 uiout
->text (", process ");
7953 uiout
->field_signed ("what", c
->forked_inferior_pid
.pid ());
7957 if (uiout
->is_mi_like_p ())
7958 uiout
->field_string ("catch-type", "vfork");
7961 /* Implement the "print_mention" breakpoint_ops method for vfork
7965 print_mention_catch_vfork (struct breakpoint
*b
)
7967 printf_filtered (_("Catchpoint %d (vfork)"), b
->number
);
7970 /* Implement the "print_recreate" breakpoint_ops method for vfork
7974 print_recreate_catch_vfork (struct breakpoint
*b
, struct ui_file
*fp
)
7976 fprintf_unfiltered (fp
, "catch vfork");
7977 print_recreate_thread (b
, fp
);
7980 /* The breakpoint_ops structure to be used in vfork catchpoints. */
7982 static struct breakpoint_ops catch_vfork_breakpoint_ops
;
7984 /* An instance of this type is used to represent an solib catchpoint.
7985 A breakpoint is really of this type iff its ops pointer points to
7986 CATCH_SOLIB_BREAKPOINT_OPS. */
7988 struct solib_catchpoint
: public breakpoint
7990 ~solib_catchpoint () override
;
7992 /* True for "catch load", false for "catch unload". */
7995 /* Regular expression to match, if any. COMPILED is only valid when
7996 REGEX is non-NULL. */
7998 std::unique_ptr
<compiled_regex
> compiled
;
8001 solib_catchpoint::~solib_catchpoint ()
8003 xfree (this->regex
);
8007 insert_catch_solib (struct bp_location
*ignore
)
8013 remove_catch_solib (struct bp_location
*ignore
, enum remove_bp_reason reason
)
8019 breakpoint_hit_catch_solib (const struct bp_location
*bl
,
8020 const address_space
*aspace
,
8022 const struct target_waitstatus
*ws
)
8024 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) bl
->owner
;
8026 if (ws
->kind
== TARGET_WAITKIND_LOADED
)
8029 for (breakpoint
*other
: all_breakpoints ())
8031 if (other
== bl
->owner
)
8034 if (other
->type
!= bp_shlib_event
)
8037 if (self
->pspace
!= NULL
&& other
->pspace
!= self
->pspace
)
8040 for (bp_location
*other_bl
: other
->locations ())
8042 if (other
->ops
->breakpoint_hit (other_bl
, aspace
, bp_addr
, ws
))
8051 check_status_catch_solib (struct bpstats
*bs
)
8053 struct solib_catchpoint
*self
8054 = (struct solib_catchpoint
*) bs
->breakpoint_at
;
8058 for (so_list
*iter
: current_program_space
->added_solibs
)
8061 || self
->compiled
->exec (iter
->so_name
, 0, NULL
, 0) == 0)
8067 for (const std::string
&iter
: current_program_space
->deleted_solibs
)
8070 || self
->compiled
->exec (iter
.c_str (), 0, NULL
, 0) == 0)
8076 bs
->print_it
= print_it_noop
;
8079 static enum print_stop_action
8080 print_it_catch_solib (bpstat bs
)
8082 struct breakpoint
*b
= bs
->breakpoint_at
;
8083 struct ui_out
*uiout
= current_uiout
;
8085 annotate_catchpoint (b
->number
);
8086 maybe_print_thread_hit_breakpoint (uiout
);
8087 if (b
->disposition
== disp_del
)
8088 uiout
->text ("Temporary catchpoint ");
8090 uiout
->text ("Catchpoint ");
8091 uiout
->field_signed ("bkptno", b
->number
);
8093 if (uiout
->is_mi_like_p ())
8094 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8095 print_solib_event (1);
8096 return PRINT_SRC_AND_LOC
;
8100 print_one_catch_solib (struct breakpoint
*b
, struct bp_location
**locs
)
8102 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8103 struct value_print_options opts
;
8104 struct ui_out
*uiout
= current_uiout
;
8106 get_user_print_options (&opts
);
8107 /* Field 4, the address, is omitted (which makes the columns not
8108 line up too nicely with the headers, but the effect is relatively
8110 if (opts
.addressprint
)
8113 uiout
->field_skip ("addr");
8121 msg
= string_printf (_("load of library matching %s"), self
->regex
);
8123 msg
= _("load of library");
8128 msg
= string_printf (_("unload of library matching %s"), self
->regex
);
8130 msg
= _("unload of library");
8132 uiout
->field_string ("what", msg
);
8134 if (uiout
->is_mi_like_p ())
8135 uiout
->field_string ("catch-type", self
->is_load
? "load" : "unload");
8139 print_mention_catch_solib (struct breakpoint
*b
)
8141 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8143 printf_filtered (_("Catchpoint %d (%s)"), b
->number
,
8144 self
->is_load
? "load" : "unload");
8148 print_recreate_catch_solib (struct breakpoint
*b
, struct ui_file
*fp
)
8150 struct solib_catchpoint
*self
= (struct solib_catchpoint
*) b
;
8152 fprintf_unfiltered (fp
, "%s %s",
8153 b
->disposition
== disp_del
? "tcatch" : "catch",
8154 self
->is_load
? "load" : "unload");
8156 fprintf_unfiltered (fp
, " %s", self
->regex
);
8157 fprintf_unfiltered (fp
, "\n");
8160 static struct breakpoint_ops catch_solib_breakpoint_ops
;
8162 /* See breakpoint.h. */
8165 add_solib_catchpoint (const char *arg
, bool is_load
, bool is_temp
, bool enabled
)
8167 struct gdbarch
*gdbarch
= get_current_arch ();
8171 arg
= skip_spaces (arg
);
8173 std::unique_ptr
<solib_catchpoint
> c (new solib_catchpoint ());
8177 c
->compiled
.reset (new compiled_regex (arg
, REG_NOSUB
,
8178 _("Invalid regexp")));
8179 c
->regex
= xstrdup (arg
);
8182 c
->is_load
= is_load
;
8183 init_catchpoint (c
.get (), gdbarch
, is_temp
, NULL
,
8184 &catch_solib_breakpoint_ops
);
8186 c
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8188 install_breakpoint (0, std::move (c
), 1);
8191 /* A helper function that does all the work for "catch load" and
8195 catch_load_or_unload (const char *arg
, int from_tty
, int is_load
,
8196 struct cmd_list_element
*command
)
8198 const int enabled
= 1;
8199 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
8201 add_solib_catchpoint (arg
, is_load
, temp
, enabled
);
8205 catch_load_command_1 (const char *arg
, int from_tty
,
8206 struct cmd_list_element
*command
)
8208 catch_load_or_unload (arg
, from_tty
, 1, command
);
8212 catch_unload_command_1 (const char *arg
, int from_tty
,
8213 struct cmd_list_element
*command
)
8215 catch_load_or_unload (arg
, from_tty
, 0, command
);
8218 /* See breakpoint.h. */
8221 init_catchpoint (struct breakpoint
*b
,
8222 struct gdbarch
*gdbarch
, bool temp
,
8223 const char *cond_string
,
8224 const struct breakpoint_ops
*ops
)
8226 symtab_and_line sal
;
8227 sal
.pspace
= current_program_space
;
8229 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
8231 b
->cond_string
= (cond_string
== NULL
) ? NULL
: xstrdup (cond_string
);
8232 b
->disposition
= temp
? disp_del
: disp_donttouch
;
8236 install_breakpoint (int internal
, std::unique_ptr
<breakpoint
> &&arg
, int update_gll
)
8238 breakpoint
*b
= add_to_breakpoint_chain (std::move (arg
));
8239 set_breakpoint_number (internal
, b
);
8240 if (is_tracepoint (b
))
8241 set_tracepoint_count (breakpoint_count
);
8244 gdb::observers::breakpoint_created
.notify (b
);
8247 update_global_location_list (UGLL_MAY_INSERT
);
8251 create_fork_vfork_event_catchpoint (struct gdbarch
*gdbarch
,
8252 bool temp
, const char *cond_string
,
8253 const struct breakpoint_ops
*ops
)
8255 std::unique_ptr
<fork_catchpoint
> c (new fork_catchpoint ());
8257 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
, ops
);
8259 c
->forked_inferior_pid
= null_ptid
;
8261 install_breakpoint (0, std::move (c
), 1);
8264 /* Exec catchpoints. */
8266 /* An instance of this type is used to represent an exec catchpoint.
8267 A breakpoint is really of this type iff its ops pointer points to
8268 CATCH_EXEC_BREAKPOINT_OPS. */
8270 struct exec_catchpoint
: public breakpoint
8272 ~exec_catchpoint () override
;
8274 /* Filename of a program whose exec triggered this catchpoint.
8275 This field is only valid immediately after this catchpoint has
8277 char *exec_pathname
;
8280 /* Exec catchpoint destructor. */
8282 exec_catchpoint::~exec_catchpoint ()
8284 xfree (this->exec_pathname
);
8288 insert_catch_exec (struct bp_location
*bl
)
8290 return target_insert_exec_catchpoint (inferior_ptid
.pid ());
8294 remove_catch_exec (struct bp_location
*bl
, enum remove_bp_reason reason
)
8296 return target_remove_exec_catchpoint (inferior_ptid
.pid ());
8300 breakpoint_hit_catch_exec (const struct bp_location
*bl
,
8301 const address_space
*aspace
, CORE_ADDR bp_addr
,
8302 const struct target_waitstatus
*ws
)
8304 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) bl
->owner
;
8306 if (ws
->kind
!= TARGET_WAITKIND_EXECD
)
8309 c
->exec_pathname
= xstrdup (ws
->value
.execd_pathname
);
8313 static enum print_stop_action
8314 print_it_catch_exec (bpstat bs
)
8316 struct ui_out
*uiout
= current_uiout
;
8317 struct breakpoint
*b
= bs
->breakpoint_at
;
8318 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8320 annotate_catchpoint (b
->number
);
8321 maybe_print_thread_hit_breakpoint (uiout
);
8322 if (b
->disposition
== disp_del
)
8323 uiout
->text ("Temporary catchpoint ");
8325 uiout
->text ("Catchpoint ");
8326 if (uiout
->is_mi_like_p ())
8328 uiout
->field_string ("reason", async_reason_lookup (EXEC_ASYNC_EXEC
));
8329 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
8331 uiout
->field_signed ("bkptno", b
->number
);
8332 uiout
->text (" (exec'd ");
8333 uiout
->field_string ("new-exec", c
->exec_pathname
);
8334 uiout
->text ("), ");
8336 return PRINT_SRC_AND_LOC
;
8340 print_one_catch_exec (struct breakpoint
*b
, struct bp_location
**last_loc
)
8342 struct exec_catchpoint
*c
= (struct exec_catchpoint
*) b
;
8343 struct value_print_options opts
;
8344 struct ui_out
*uiout
= current_uiout
;
8346 get_user_print_options (&opts
);
8348 /* Field 4, the address, is omitted (which makes the columns
8349 not line up too nicely with the headers, but the effect
8350 is relatively readable). */
8351 if (opts
.addressprint
)
8352 uiout
->field_skip ("addr");
8354 uiout
->text ("exec");
8355 if (c
->exec_pathname
!= NULL
)
8357 uiout
->text (", program \"");
8358 uiout
->field_string ("what", c
->exec_pathname
);
8359 uiout
->text ("\" ");
8362 if (uiout
->is_mi_like_p ())
8363 uiout
->field_string ("catch-type", "exec");
8367 print_mention_catch_exec (struct breakpoint
*b
)
8369 printf_filtered (_("Catchpoint %d (exec)"), b
->number
);
8372 /* Implement the "print_recreate" breakpoint_ops method for exec
8376 print_recreate_catch_exec (struct breakpoint
*b
, struct ui_file
*fp
)
8378 fprintf_unfiltered (fp
, "catch exec");
8379 print_recreate_thread (b
, fp
);
8382 static struct breakpoint_ops catch_exec_breakpoint_ops
;
8385 hw_breakpoint_used_count (void)
8389 for (breakpoint
*b
: all_breakpoints ())
8390 if (b
->type
== bp_hardware_breakpoint
&& breakpoint_enabled (b
))
8391 for (bp_location
*bl
: b
->locations ())
8393 /* Special types of hardware breakpoints may use more than
8395 i
+= b
->ops
->resources_needed (bl
);
8401 /* Returns the resources B would use if it were a hardware
8405 hw_watchpoint_use_count (struct breakpoint
*b
)
8409 if (!breakpoint_enabled (b
))
8412 for (bp_location
*bl
: b
->locations ())
8414 /* Special types of hardware watchpoints may use more than
8416 i
+= b
->ops
->resources_needed (bl
);
8422 /* Returns the sum the used resources of all hardware watchpoints of
8423 type TYPE in the breakpoints list. Also returns in OTHER_TYPE_USED
8424 the sum of the used resources of all hardware watchpoints of other
8425 types _not_ TYPE. */
8428 hw_watchpoint_used_count_others (struct breakpoint
*except
,
8429 enum bptype type
, int *other_type_used
)
8433 *other_type_used
= 0;
8434 for (breakpoint
*b
: all_breakpoints ())
8438 if (!breakpoint_enabled (b
))
8441 if (b
->type
== type
)
8442 i
+= hw_watchpoint_use_count (b
);
8443 else if (is_hardware_watchpoint (b
))
8444 *other_type_used
= 1;
8451 disable_watchpoints_before_interactive_call_start (void)
8453 for (breakpoint
*b
: all_breakpoints ())
8454 if (is_watchpoint (b
) && breakpoint_enabled (b
))
8456 b
->enable_state
= bp_call_disabled
;
8457 update_global_location_list (UGLL_DONT_INSERT
);
8462 enable_watchpoints_after_interactive_call_stop (void)
8464 for (breakpoint
*b
: all_breakpoints ())
8465 if (is_watchpoint (b
) && b
->enable_state
== bp_call_disabled
)
8467 b
->enable_state
= bp_enabled
;
8468 update_global_location_list (UGLL_MAY_INSERT
);
8473 disable_breakpoints_before_startup (void)
8475 current_program_space
->executing_startup
= 1;
8476 update_global_location_list (UGLL_DONT_INSERT
);
8480 enable_breakpoints_after_startup (void)
8482 current_program_space
->executing_startup
= 0;
8483 breakpoint_re_set ();
8486 /* Create a new single-step breakpoint for thread THREAD, with no
8489 static struct breakpoint
*
8490 new_single_step_breakpoint (int thread
, struct gdbarch
*gdbarch
)
8492 std::unique_ptr
<breakpoint
> b (new breakpoint ());
8494 init_raw_breakpoint_without_location (b
.get (), gdbarch
, bp_single_step
,
8495 &momentary_breakpoint_ops
);
8497 b
->disposition
= disp_donttouch
;
8498 b
->frame_id
= null_frame_id
;
8501 gdb_assert (b
->thread
!= 0);
8503 return add_to_breakpoint_chain (std::move (b
));
8506 /* Set a momentary breakpoint of type TYPE at address specified by
8507 SAL. If FRAME_ID is valid, the breakpoint is restricted to that
8511 set_momentary_breakpoint (struct gdbarch
*gdbarch
, struct symtab_and_line sal
,
8512 struct frame_id frame_id
, enum bptype type
)
8514 struct breakpoint
*b
;
8516 /* If FRAME_ID is valid, it should be a real frame, not an inlined or
8518 gdb_assert (!frame_id_artificial_p (frame_id
));
8520 b
= set_raw_breakpoint (gdbarch
, sal
, type
, &momentary_breakpoint_ops
);
8521 b
->enable_state
= bp_enabled
;
8522 b
->disposition
= disp_donttouch
;
8523 b
->frame_id
= frame_id
;
8525 b
->thread
= inferior_thread ()->global_num
;
8527 update_global_location_list_nothrow (UGLL_MAY_INSERT
);
8529 return breakpoint_up (b
);
8532 /* Make a momentary breakpoint based on the master breakpoint ORIG.
8533 The new breakpoint will have type TYPE, use OPS as its
8534 breakpoint_ops, and will set enabled to LOC_ENABLED. */
8536 static struct breakpoint
*
8537 momentary_breakpoint_from_master (struct breakpoint
*orig
,
8539 const struct breakpoint_ops
*ops
,
8542 struct breakpoint
*copy
;
8544 copy
= set_raw_breakpoint_without_location (orig
->gdbarch
, type
, ops
);
8545 copy
->loc
= allocate_bp_location (copy
);
8546 set_breakpoint_location_function (copy
->loc
);
8548 copy
->loc
->gdbarch
= orig
->loc
->gdbarch
;
8549 copy
->loc
->requested_address
= orig
->loc
->requested_address
;
8550 copy
->loc
->address
= orig
->loc
->address
;
8551 copy
->loc
->section
= orig
->loc
->section
;
8552 copy
->loc
->pspace
= orig
->loc
->pspace
;
8553 copy
->loc
->probe
= orig
->loc
->probe
;
8554 copy
->loc
->line_number
= orig
->loc
->line_number
;
8555 copy
->loc
->symtab
= orig
->loc
->symtab
;
8556 copy
->loc
->enabled
= loc_enabled
;
8557 copy
->frame_id
= orig
->frame_id
;
8558 copy
->thread
= orig
->thread
;
8559 copy
->pspace
= orig
->pspace
;
8561 copy
->enable_state
= bp_enabled
;
8562 copy
->disposition
= disp_donttouch
;
8563 copy
->number
= internal_breakpoint_number
--;
8565 update_global_location_list_nothrow (UGLL_DONT_INSERT
);
8569 /* Make a deep copy of momentary breakpoint ORIG. Returns NULL if
8573 clone_momentary_breakpoint (struct breakpoint
*orig
)
8575 /* If there's nothing to clone, then return nothing. */
8579 return momentary_breakpoint_from_master (orig
, orig
->type
, orig
->ops
, 0);
8583 set_momentary_breakpoint_at_pc (struct gdbarch
*gdbarch
, CORE_ADDR pc
,
8586 struct symtab_and_line sal
;
8588 sal
= find_pc_line (pc
, 0);
8590 sal
.section
= find_pc_overlay (pc
);
8591 sal
.explicit_pc
= 1;
8593 return set_momentary_breakpoint (gdbarch
, sal
, null_frame_id
, type
);
8597 /* Tell the user we have just set a breakpoint B. */
8600 mention (struct breakpoint
*b
)
8602 b
->ops
->print_mention (b
);
8603 current_uiout
->text ("\n");
8607 static bool bp_loc_is_permanent (struct bp_location
*loc
);
8609 /* Handle "set breakpoint auto-hw on".
8611 If the explicitly specified breakpoint type is not hardware
8612 breakpoint, check the memory map to see whether the breakpoint
8613 address is in read-only memory.
8615 - location type is not hardware breakpoint, memory is read-only.
8616 We change the type of the location to hardware breakpoint.
8618 - location type is hardware breakpoint, memory is read-write. This
8619 means we've previously made the location hardware one, but then the
8620 memory map changed, so we undo.
8624 handle_automatic_hardware_breakpoints (bp_location
*bl
)
8626 if (automatic_hardware_breakpoints
8627 && bl
->owner
->type
!= bp_hardware_breakpoint
8628 && (bl
->loc_type
== bp_loc_software_breakpoint
8629 || bl
->loc_type
== bp_loc_hardware_breakpoint
))
8631 /* When breakpoints are removed, remove_breakpoints will use
8632 location types we've just set here, the only possible problem
8633 is that memory map has changed during running program, but
8634 it's not going to work anyway with current gdb. */
8635 mem_region
*mr
= lookup_mem_region (bl
->address
);
8639 enum bp_loc_type new_type
;
8641 if (mr
->attrib
.mode
!= MEM_RW
)
8642 new_type
= bp_loc_hardware_breakpoint
;
8644 new_type
= bp_loc_software_breakpoint
;
8646 if (new_type
!= bl
->loc_type
)
8648 static bool said
= false;
8650 bl
->loc_type
= new_type
;
8653 fprintf_filtered (gdb_stdout
,
8654 _("Note: automatically using "
8655 "hardware breakpoints for "
8656 "read-only addresses.\n"));
8664 static struct bp_location
*
8665 add_location_to_breakpoint (struct breakpoint
*b
,
8666 const struct symtab_and_line
*sal
)
8668 struct bp_location
*loc
, **tmp
;
8669 CORE_ADDR adjusted_address
;
8670 struct gdbarch
*loc_gdbarch
= get_sal_arch (*sal
);
8672 if (loc_gdbarch
== NULL
)
8673 loc_gdbarch
= b
->gdbarch
;
8675 /* Adjust the breakpoint's address prior to allocating a location.
8676 Once we call allocate_bp_location(), that mostly uninitialized
8677 location will be placed on the location chain. Adjustment of the
8678 breakpoint may cause target_read_memory() to be called and we do
8679 not want its scan of the location chain to find a breakpoint and
8680 location that's only been partially initialized. */
8681 adjusted_address
= adjust_breakpoint_address (loc_gdbarch
,
8684 /* Sort the locations by their ADDRESS. */
8685 loc
= allocate_bp_location (b
);
8686 for (tmp
= &(b
->loc
); *tmp
!= NULL
&& (*tmp
)->address
<= adjusted_address
;
8687 tmp
= &((*tmp
)->next
))
8692 loc
->requested_address
= sal
->pc
;
8693 loc
->address
= adjusted_address
;
8694 loc
->pspace
= sal
->pspace
;
8695 loc
->probe
.prob
= sal
->prob
;
8696 loc
->probe
.objfile
= sal
->objfile
;
8697 gdb_assert (loc
->pspace
!= NULL
);
8698 loc
->section
= sal
->section
;
8699 loc
->gdbarch
= loc_gdbarch
;
8700 loc
->line_number
= sal
->line
;
8701 loc
->symtab
= sal
->symtab
;
8702 loc
->symbol
= sal
->symbol
;
8703 loc
->msymbol
= sal
->msymbol
;
8704 loc
->objfile
= sal
->objfile
;
8706 set_breakpoint_location_function (loc
);
8708 /* While by definition, permanent breakpoints are already present in the
8709 code, we don't mark the location as inserted. Normally one would expect
8710 that GDB could rely on that breakpoint instruction to stop the program,
8711 thus removing the need to insert its own breakpoint, except that executing
8712 the breakpoint instruction can kill the target instead of reporting a
8713 SIGTRAP. E.g., on SPARC, when interrupts are disabled, executing the
8714 instruction resets the CPU, so QEMU 2.0.0 for SPARC correspondingly dies
8715 with "Trap 0x02 while interrupts disabled, Error state". Letting the
8716 breakpoint be inserted normally results in QEMU knowing about the GDB
8717 breakpoint, and thus trap before the breakpoint instruction is executed.
8718 (If GDB later needs to continue execution past the permanent breakpoint,
8719 it manually increments the PC, thus avoiding executing the breakpoint
8721 if (bp_loc_is_permanent (loc
))
8728 /* Return true if LOC is pointing to a permanent breakpoint,
8729 return false otherwise. */
8732 bp_loc_is_permanent (struct bp_location
*loc
)
8734 gdb_assert (loc
!= NULL
);
8736 /* If we have a non-breakpoint-backed catchpoint or a software
8737 watchpoint, just return 0. We should not attempt to read from
8738 the addresses the locations of these breakpoint types point to.
8739 gdbarch_program_breakpoint_here_p, below, will attempt to read
8741 if (!bl_address_is_meaningful (loc
))
8744 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
8745 switch_to_program_space_and_thread (loc
->pspace
);
8746 return gdbarch_program_breakpoint_here_p (loc
->gdbarch
, loc
->address
);
8749 /* Build a command list for the dprintf corresponding to the current
8750 settings of the dprintf style options. */
8753 update_dprintf_command_list (struct breakpoint
*b
)
8755 char *dprintf_args
= b
->extra_string
;
8756 char *printf_line
= NULL
;
8761 dprintf_args
= skip_spaces (dprintf_args
);
8763 /* Allow a comma, as it may have terminated a location, but don't
8765 if (*dprintf_args
== ',')
8767 dprintf_args
= skip_spaces (dprintf_args
);
8769 if (*dprintf_args
!= '"')
8770 error (_("Bad format string, missing '\"'."));
8772 if (strcmp (dprintf_style
, dprintf_style_gdb
) == 0)
8773 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8774 else if (strcmp (dprintf_style
, dprintf_style_call
) == 0)
8776 if (!dprintf_function
)
8777 error (_("No function supplied for dprintf call"));
8779 if (dprintf_channel
&& strlen (dprintf_channel
) > 0)
8780 printf_line
= xstrprintf ("call (void) %s (%s,%s)",
8785 printf_line
= xstrprintf ("call (void) %s (%s)",
8789 else if (strcmp (dprintf_style
, dprintf_style_agent
) == 0)
8791 if (target_can_run_breakpoint_commands ())
8792 printf_line
= xstrprintf ("agent-printf %s", dprintf_args
);
8795 warning (_("Target cannot run dprintf commands, falling back to GDB printf"));
8796 printf_line
= xstrprintf ("printf %s", dprintf_args
);
8800 internal_error (__FILE__
, __LINE__
,
8801 _("Invalid dprintf style."));
8803 gdb_assert (printf_line
!= NULL
);
8805 /* Manufacture a printf sequence. */
8806 struct command_line
*printf_cmd_line
8807 = new struct command_line (simple_control
, printf_line
);
8808 breakpoint_set_commands (b
, counted_command_line (printf_cmd_line
,
8809 command_lines_deleter ()));
8812 /* Update all dprintf commands, making their command lists reflect
8813 current style settings. */
8816 update_dprintf_commands (const char *args
, int from_tty
,
8817 struct cmd_list_element
*c
)
8819 for (breakpoint
*b
: all_breakpoints ())
8820 if (b
->type
== bp_dprintf
)
8821 update_dprintf_command_list (b
);
8824 /* Create a breakpoint with SAL as location. Use LOCATION
8825 as a description of the location, and COND_STRING
8826 as condition expression. If LOCATION is NULL then create an
8827 "address location" from the address in the SAL. */
8830 init_breakpoint_sal (struct breakpoint
*b
, struct gdbarch
*gdbarch
,
8831 gdb::array_view
<const symtab_and_line
> sals
,
8832 event_location_up
&&location
,
8833 gdb::unique_xmalloc_ptr
<char> filter
,
8834 gdb::unique_xmalloc_ptr
<char> cond_string
,
8835 gdb::unique_xmalloc_ptr
<char> extra_string
,
8836 enum bptype type
, enum bpdisp disposition
,
8837 int thread
, int task
, int ignore_count
,
8838 const struct breakpoint_ops
*ops
, int from_tty
,
8839 int enabled
, int internal
, unsigned flags
,
8840 int display_canonical
)
8844 if (type
== bp_hardware_breakpoint
)
8846 int target_resources_ok
;
8848 i
= hw_breakpoint_used_count ();
8849 target_resources_ok
=
8850 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
8852 if (target_resources_ok
== 0)
8853 error (_("No hardware breakpoint support in the target."));
8854 else if (target_resources_ok
< 0)
8855 error (_("Hardware breakpoints used exceeds limit."));
8858 gdb_assert (!sals
.empty ());
8860 for (const auto &sal
: sals
)
8862 struct bp_location
*loc
;
8866 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
8868 loc_gdbarch
= gdbarch
;
8870 describe_other_breakpoints (loc_gdbarch
,
8871 sal
.pspace
, sal
.pc
, sal
.section
, thread
);
8874 if (&sal
== &sals
[0])
8876 init_raw_breakpoint (b
, gdbarch
, sal
, type
, ops
);
8880 b
->cond_string
= cond_string
.release ();
8881 b
->extra_string
= extra_string
.release ();
8882 b
->ignore_count
= ignore_count
;
8883 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
8884 b
->disposition
= disposition
;
8886 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8887 b
->loc
->inserted
= 1;
8889 if (type
== bp_static_tracepoint
)
8891 struct tracepoint
*t
= (struct tracepoint
*) b
;
8892 struct static_tracepoint_marker marker
;
8894 if (strace_marker_p (b
))
8896 /* We already know the marker exists, otherwise, we
8897 wouldn't see a sal for it. */
8899 = &event_location_to_string (b
->location
.get ())[3];
8902 p
= skip_spaces (p
);
8904 endp
= skip_to_space (p
);
8906 t
->static_trace_marker_id
.assign (p
, endp
- p
);
8908 printf_filtered (_("Probed static tracepoint "
8910 t
->static_trace_marker_id
.c_str ());
8912 else if (target_static_tracepoint_marker_at (sal
.pc
, &marker
))
8914 t
->static_trace_marker_id
= std::move (marker
.str_id
);
8916 printf_filtered (_("Probed static tracepoint "
8918 t
->static_trace_marker_id
.c_str ());
8921 warning (_("Couldn't determine the static "
8922 "tracepoint marker to probe"));
8929 loc
= add_location_to_breakpoint (b
, &sal
);
8930 if ((flags
& CREATE_BREAKPOINT_FLAGS_INSERTED
) != 0)
8934 /* Do not set breakpoint locations conditions yet. As locations
8935 are inserted, they get sorted based on their addresses. Let
8936 the list stabilize to have reliable location numbers. */
8938 /* Dynamic printf requires and uses additional arguments on the
8939 command line, otherwise it's an error. */
8940 if (type
== bp_dprintf
)
8942 if (b
->extra_string
)
8943 update_dprintf_command_list (b
);
8945 error (_("Format string required"));
8947 else if (b
->extra_string
)
8948 error (_("Garbage '%s' at end of command"), b
->extra_string
);
8952 /* The order of the locations is now stable. Set the location
8953 condition using the location's number. */
8955 for (bp_location
*loc
: b
->locations ())
8957 if (b
->cond_string
!= nullptr)
8958 set_breakpoint_location_condition (b
->cond_string
, loc
, b
->number
,
8964 b
->display_canonical
= display_canonical
;
8965 if (location
!= NULL
)
8966 b
->location
= std::move (location
);
8968 b
->location
= new_address_location (b
->loc
->address
, NULL
, 0);
8969 b
->filter
= std::move (filter
);
8973 create_breakpoint_sal (struct gdbarch
*gdbarch
,
8974 gdb::array_view
<const symtab_and_line
> sals
,
8975 event_location_up
&&location
,
8976 gdb::unique_xmalloc_ptr
<char> filter
,
8977 gdb::unique_xmalloc_ptr
<char> cond_string
,
8978 gdb::unique_xmalloc_ptr
<char> extra_string
,
8979 enum bptype type
, enum bpdisp disposition
,
8980 int thread
, int task
, int ignore_count
,
8981 const struct breakpoint_ops
*ops
, int from_tty
,
8982 int enabled
, int internal
, unsigned flags
,
8983 int display_canonical
)
8985 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type
);
8987 init_breakpoint_sal (b
.get (), gdbarch
,
8988 sals
, std::move (location
),
8990 std::move (cond_string
),
8991 std::move (extra_string
),
8993 thread
, task
, ignore_count
,
8995 enabled
, internal
, flags
,
8998 install_breakpoint (internal
, std::move (b
), 0);
9001 /* Add SALS.nelts breakpoints to the breakpoint table. For each
9002 SALS.sal[i] breakpoint, include the corresponding ADDR_STRING[i]
9003 value. COND_STRING, if not NULL, specified the condition to be
9004 used for all breakpoints. Essentially the only case where
9005 SALS.nelts is not 1 is when we set a breakpoint on an overloaded
9006 function. In that case, it's still not possible to specify
9007 separate conditions for different overloaded functions, so
9008 we take just a single condition string.
9010 NOTE: If the function succeeds, the caller is expected to cleanup
9011 the arrays ADDR_STRING, COND_STRING, and SALS (but not the
9012 array contents). If the function fails (error() is called), the
9013 caller is expected to cleanups both the ADDR_STRING, COND_STRING,
9014 COND and SALS arrays and each of those arrays contents. */
9017 create_breakpoints_sal (struct gdbarch
*gdbarch
,
9018 struct linespec_result
*canonical
,
9019 gdb::unique_xmalloc_ptr
<char> cond_string
,
9020 gdb::unique_xmalloc_ptr
<char> extra_string
,
9021 enum bptype type
, enum bpdisp disposition
,
9022 int thread
, int task
, int ignore_count
,
9023 const struct breakpoint_ops
*ops
, int from_tty
,
9024 int enabled
, int internal
, unsigned flags
)
9026 if (canonical
->pre_expanded
)
9027 gdb_assert (canonical
->lsals
.size () == 1);
9029 for (const auto &lsal
: canonical
->lsals
)
9031 /* Note that 'location' can be NULL in the case of a plain
9032 'break', without arguments. */
9033 event_location_up location
9034 = (canonical
->location
!= NULL
9035 ? copy_event_location (canonical
->location
.get ()) : NULL
);
9036 gdb::unique_xmalloc_ptr
<char> filter_string
9037 (lsal
.canonical
!= NULL
? xstrdup (lsal
.canonical
) : NULL
);
9039 create_breakpoint_sal (gdbarch
, lsal
.sals
,
9040 std::move (location
),
9041 std::move (filter_string
),
9042 std::move (cond_string
),
9043 std::move (extra_string
),
9045 thread
, task
, ignore_count
, ops
,
9046 from_tty
, enabled
, internal
, flags
,
9047 canonical
->special_display
);
9051 /* Parse LOCATION which is assumed to be a SAL specification possibly
9052 followed by conditionals. On return, SALS contains an array of SAL
9053 addresses found. LOCATION points to the end of the SAL (for
9054 linespec locations).
9056 The array and the line spec strings are allocated on the heap, it is
9057 the caller's responsibility to free them. */
9060 parse_breakpoint_sals (struct event_location
*location
,
9061 struct linespec_result
*canonical
)
9063 struct symtab_and_line cursal
;
9065 if (event_location_type (location
) == LINESPEC_LOCATION
)
9067 const char *spec
= get_linespec_location (location
)->spec_string
;
9071 /* The last displayed codepoint, if it's valid, is our default
9072 breakpoint address. */
9073 if (last_displayed_sal_is_valid ())
9075 /* Set sal's pspace, pc, symtab, and line to the values
9076 corresponding to the last call to print_frame_info.
9077 Be sure to reinitialize LINE with NOTCURRENT == 0
9078 as the breakpoint line number is inappropriate otherwise.
9079 find_pc_line would adjust PC, re-set it back. */
9080 symtab_and_line sal
= get_last_displayed_sal ();
9081 CORE_ADDR pc
= sal
.pc
;
9083 sal
= find_pc_line (pc
, 0);
9085 /* "break" without arguments is equivalent to "break *PC"
9086 where PC is the last displayed codepoint's address. So
9087 make sure to set sal.explicit_pc to prevent GDB from
9088 trying to expand the list of sals to include all other
9089 instances with the same symtab and line. */
9091 sal
.explicit_pc
= 1;
9093 struct linespec_sals lsal
;
9095 lsal
.canonical
= NULL
;
9097 canonical
->lsals
.push_back (std::move (lsal
));
9101 error (_("No default breakpoint address now."));
9105 /* Force almost all breakpoints to be in terms of the
9106 current_source_symtab (which is decode_line_1's default).
9107 This should produce the results we want almost all of the
9108 time while leaving default_breakpoint_* alone.
9110 ObjC: However, don't match an Objective-C method name which
9111 may have a '+' or '-' succeeded by a '['. */
9112 cursal
= get_current_source_symtab_and_line ();
9113 if (last_displayed_sal_is_valid ())
9115 const char *spec
= NULL
;
9117 if (event_location_type (location
) == LINESPEC_LOCATION
)
9118 spec
= get_linespec_location (location
)->spec_string
;
9122 && strchr ("+-", spec
[0]) != NULL
9125 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9126 get_last_displayed_symtab (),
9127 get_last_displayed_line (),
9128 canonical
, NULL
, NULL
);
9133 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, NULL
,
9134 cursal
.symtab
, cursal
.line
, canonical
, NULL
, NULL
);
9138 /* Convert each SAL into a real PC. Verify that the PC can be
9139 inserted as a breakpoint. If it can't throw an error. */
9142 breakpoint_sals_to_pc (std::vector
<symtab_and_line
> &sals
)
9144 for (auto &sal
: sals
)
9145 resolve_sal_pc (&sal
);
9148 /* Fast tracepoints may have restrictions on valid locations. For
9149 instance, a fast tracepoint using a jump instead of a trap will
9150 likely have to overwrite more bytes than a trap would, and so can
9151 only be placed where the instruction is longer than the jump, or a
9152 multi-instruction sequence does not have a jump into the middle of
9156 check_fast_tracepoint_sals (struct gdbarch
*gdbarch
,
9157 gdb::array_view
<const symtab_and_line
> sals
)
9159 for (const auto &sal
: sals
)
9161 struct gdbarch
*sarch
;
9163 sarch
= get_sal_arch (sal
);
9164 /* We fall back to GDBARCH if there is no architecture
9165 associated with SAL. */
9169 if (!gdbarch_fast_tracepoint_valid_at (sarch
, sal
.pc
, &msg
))
9170 error (_("May not have a fast tracepoint at %s%s"),
9171 paddress (sarch
, sal
.pc
), msg
.c_str ());
9175 /* Given TOK, a string specification of condition and thread, as
9176 accepted by the 'break' command, extract the condition
9177 string and thread number and set *COND_STRING and *THREAD.
9178 PC identifies the context at which the condition should be parsed.
9179 If no condition is found, *COND_STRING is set to NULL.
9180 If no thread is found, *THREAD is set to -1. */
9183 find_condition_and_thread (const char *tok
, CORE_ADDR pc
,
9184 char **cond_string
, int *thread
, int *task
,
9187 *cond_string
= NULL
;
9195 const char *end_tok
;
9197 const char *cond_start
= NULL
;
9198 const char *cond_end
= NULL
;
9200 tok
= skip_spaces (tok
);
9202 if ((*tok
== '"' || *tok
== ',') && rest
)
9204 *rest
= savestring (tok
, strlen (tok
));
9208 end_tok
= skip_to_space (tok
);
9210 toklen
= end_tok
- tok
;
9212 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
9214 tok
= cond_start
= end_tok
+ 1;
9217 parse_exp_1 (&tok
, pc
, block_for_pc (pc
), 0);
9219 catch (const gdb_exception_error
&)
9224 tok
= tok
+ strlen (tok
);
9227 *cond_string
= savestring (cond_start
, cond_end
- cond_start
);
9229 else if (toklen
>= 1 && strncmp (tok
, "-force-condition", toklen
) == 0)
9234 else if (toklen
>= 1 && strncmp (tok
, "thread", toklen
) == 0)
9237 struct thread_info
*thr
;
9240 thr
= parse_thread_id (tok
, &tmptok
);
9242 error (_("Junk after thread keyword."));
9243 *thread
= thr
->global_num
;
9246 else if (toklen
>= 1 && strncmp (tok
, "task", toklen
) == 0)
9251 *task
= strtol (tok
, &tmptok
, 0);
9253 error (_("Junk after task keyword."));
9254 if (!valid_task_id (*task
))
9255 error (_("Unknown task %d."), *task
);
9260 *rest
= savestring (tok
, strlen (tok
));
9264 error (_("Junk at end of arguments."));
9268 /* Call 'find_condition_and_thread' for each sal in SALS until a parse
9269 succeeds. The parsed values are written to COND_STRING, THREAD,
9270 TASK, and REST. See the comment of 'find_condition_and_thread'
9271 for the description of these parameters and INPUT. */
9274 find_condition_and_thread_for_sals (const std::vector
<symtab_and_line
> &sals
,
9275 const char *input
, char **cond_string
,
9276 int *thread
, int *task
, char **rest
)
9278 int num_failures
= 0;
9279 for (auto &sal
: sals
)
9281 char *cond
= nullptr;
9284 char *remaining
= nullptr;
9286 /* Here we want to parse 'arg' to separate condition from thread
9287 number. But because parsing happens in a context and the
9288 contexts of sals might be different, try each until there is
9289 success. Finding one successful parse is sufficient for our
9290 goal. When setting the breakpoint we'll re-parse the
9291 condition in the context of each sal. */
9294 find_condition_and_thread (input
, sal
.pc
, &cond
, &thread_id
,
9295 &task_id
, &remaining
);
9296 *cond_string
= cond
;
9297 *thread
= thread_id
;
9302 catch (const gdb_exception_error
&e
)
9305 /* If no sal remains, do not continue. */
9306 if (num_failures
== sals
.size ())
9312 /* Decode a static tracepoint marker spec. */
9314 static std::vector
<symtab_and_line
>
9315 decode_static_tracepoint_spec (const char **arg_p
)
9317 const char *p
= &(*arg_p
)[3];
9320 p
= skip_spaces (p
);
9322 endp
= skip_to_space (p
);
9324 std::string
marker_str (p
, endp
- p
);
9326 std::vector
<static_tracepoint_marker
> markers
9327 = target_static_tracepoint_markers_by_strid (marker_str
.c_str ());
9328 if (markers
.empty ())
9329 error (_("No known static tracepoint marker named %s"),
9330 marker_str
.c_str ());
9332 std::vector
<symtab_and_line
> sals
;
9333 sals
.reserve (markers
.size ());
9335 for (const static_tracepoint_marker
&marker
: markers
)
9337 symtab_and_line sal
= find_pc_line (marker
.address
, 0);
9338 sal
.pc
= marker
.address
;
9339 sals
.push_back (sal
);
9346 /* Returns the breakpoint ops appropriate for use with with LOCATION_TYPE and
9347 according to IS_TRACEPOINT. */
9349 static const struct breakpoint_ops
*
9350 breakpoint_ops_for_event_location_type (enum event_location_type location_type
,
9355 if (location_type
== PROBE_LOCATION
)
9356 return &tracepoint_probe_breakpoint_ops
;
9358 return &tracepoint_breakpoint_ops
;
9362 if (location_type
== PROBE_LOCATION
)
9363 return &bkpt_probe_breakpoint_ops
;
9365 return &bkpt_breakpoint_ops
;
9369 /* See breakpoint.h. */
9371 const struct breakpoint_ops
*
9372 breakpoint_ops_for_event_location (const struct event_location
*location
,
9375 if (location
!= nullptr)
9376 return breakpoint_ops_for_event_location_type
9377 (event_location_type (location
), is_tracepoint
);
9378 return is_tracepoint
? &tracepoint_breakpoint_ops
: &bkpt_breakpoint_ops
;
9381 /* See breakpoint.h. */
9384 create_breakpoint (struct gdbarch
*gdbarch
,
9385 struct event_location
*location
,
9386 const char *cond_string
,
9387 int thread
, const char *extra_string
,
9388 bool force_condition
, int parse_extra
,
9389 int tempflag
, enum bptype type_wanted
,
9391 enum auto_boolean pending_break_support
,
9392 const struct breakpoint_ops
*ops
,
9393 int from_tty
, int enabled
, int internal
,
9396 struct linespec_result canonical
;
9399 int prev_bkpt_count
= breakpoint_count
;
9401 gdb_assert (ops
!= NULL
);
9403 /* If extra_string isn't useful, set it to NULL. */
9404 if (extra_string
!= NULL
&& *extra_string
== '\0')
9405 extra_string
= NULL
;
9409 ops
->create_sals_from_location (location
, &canonical
, type_wanted
);
9411 catch (const gdb_exception_error
&e
)
9413 /* If caller is interested in rc value from parse, set
9415 if (e
.error
== NOT_FOUND_ERROR
)
9417 /* If pending breakpoint support is turned off, throw
9420 if (pending_break_support
== AUTO_BOOLEAN_FALSE
)
9423 exception_print (gdb_stderr
, e
);
9425 /* If pending breakpoint support is auto query and the user
9426 selects no, then simply return the error code. */
9427 if (pending_break_support
== AUTO_BOOLEAN_AUTO
9428 && !nquery (_("Make %s pending on future shared library load? "),
9429 bptype_string (type_wanted
)))
9432 /* At this point, either the user was queried about setting
9433 a pending breakpoint and selected yes, or pending
9434 breakpoint behavior is on and thus a pending breakpoint
9435 is defaulted on behalf of the user. */
9442 if (!pending
&& canonical
.lsals
.empty ())
9445 /* Resolve all line numbers to PC's and verify that the addresses
9446 are ok for the target. */
9449 for (auto &lsal
: canonical
.lsals
)
9450 breakpoint_sals_to_pc (lsal
.sals
);
9453 /* Fast tracepoints may have additional restrictions on location. */
9454 if (!pending
&& type_wanted
== bp_fast_tracepoint
)
9456 for (const auto &lsal
: canonical
.lsals
)
9457 check_fast_tracepoint_sals (gdbarch
, lsal
.sals
);
9460 /* Verify that condition can be parsed, before setting any
9461 breakpoints. Allocate a separate condition expression for each
9465 gdb::unique_xmalloc_ptr
<char> cond_string_copy
;
9466 gdb::unique_xmalloc_ptr
<char> extra_string_copy
;
9473 const linespec_sals
&lsal
= canonical
.lsals
[0];
9475 find_condition_and_thread_for_sals (lsal
.sals
, extra_string
,
9476 &cond
, &thread
, &task
, &rest
);
9477 cond_string_copy
.reset (cond
);
9478 extra_string_copy
.reset (rest
);
9482 if (type_wanted
!= bp_dprintf
9483 && extra_string
!= NULL
&& *extra_string
!= '\0')
9484 error (_("Garbage '%s' at end of location"), extra_string
);
9486 /* Check the validity of the condition. We should error out
9487 if the condition is invalid at all of the locations and
9488 if it is not forced. In the PARSE_EXTRA case above, this
9489 check is done when parsing the EXTRA_STRING. */
9490 if (cond_string
!= nullptr && !force_condition
)
9492 int num_failures
= 0;
9493 const linespec_sals
&lsal
= canonical
.lsals
[0];
9494 for (const auto &sal
: lsal
.sals
)
9496 const char *cond
= cond_string
;
9499 parse_exp_1 (&cond
, sal
.pc
, block_for_pc (sal
.pc
), 0);
9500 /* One success is sufficient to keep going. */
9503 catch (const gdb_exception_error
&)
9506 /* If this is the last sal, error out. */
9507 if (num_failures
== lsal
.sals
.size ())
9513 /* Create a private copy of condition string. */
9515 cond_string_copy
.reset (xstrdup (cond_string
));
9516 /* Create a private copy of any extra string. */
9518 extra_string_copy
.reset (xstrdup (extra_string
));
9521 ops
->create_breakpoints_sal (gdbarch
, &canonical
,
9522 std::move (cond_string_copy
),
9523 std::move (extra_string_copy
),
9525 tempflag
? disp_del
: disp_donttouch
,
9526 thread
, task
, ignore_count
, ops
,
9527 from_tty
, enabled
, internal
, flags
);
9531 std::unique_ptr
<breakpoint
> b
= new_breakpoint_from_type (type_wanted
);
9533 init_raw_breakpoint_without_location (b
.get (), gdbarch
, type_wanted
, ops
);
9534 b
->location
= copy_event_location (location
);
9537 b
->cond_string
= NULL
;
9540 /* Create a private copy of condition string. */
9541 b
->cond_string
= cond_string
!= NULL
? xstrdup (cond_string
) : NULL
;
9545 /* Create a private copy of any extra string. */
9546 b
->extra_string
= extra_string
!= NULL
? xstrdup (extra_string
) : NULL
;
9547 b
->ignore_count
= ignore_count
;
9548 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
9549 b
->condition_not_parsed
= 1;
9550 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
9551 if ((type_wanted
!= bp_breakpoint
9552 && type_wanted
!= bp_hardware_breakpoint
) || thread
!= -1)
9553 b
->pspace
= current_program_space
;
9555 install_breakpoint (internal
, std::move (b
), 0);
9558 if (canonical
.lsals
.size () > 1)
9560 warning (_("Multiple breakpoints were set.\nUse the "
9561 "\"delete\" command to delete unwanted breakpoints."));
9562 prev_breakpoint_count
= prev_bkpt_count
;
9565 update_global_location_list (UGLL_MAY_INSERT
);
9570 /* Set a breakpoint.
9571 ARG is a string describing breakpoint address,
9572 condition, and thread.
9573 FLAG specifies if a breakpoint is hardware on,
9574 and if breakpoint is temporary, using BP_HARDWARE_FLAG
9578 break_command_1 (const char *arg
, int flag
, int from_tty
)
9580 int tempflag
= flag
& BP_TEMPFLAG
;
9581 enum bptype type_wanted
= (flag
& BP_HARDWAREFLAG
9582 ? bp_hardware_breakpoint
9585 event_location_up location
= string_to_event_location (&arg
, current_language
);
9586 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
9587 (location
.get (), false /* is_tracepoint */);
9589 create_breakpoint (get_current_arch (),
9591 NULL
, 0, arg
, false, 1 /* parse arg */,
9592 tempflag
, type_wanted
,
9593 0 /* Ignore count */,
9594 pending_break_support
,
9602 /* Helper function for break_command_1 and disassemble_command. */
9605 resolve_sal_pc (struct symtab_and_line
*sal
)
9609 if (sal
->pc
== 0 && sal
->symtab
!= NULL
)
9611 if (!find_line_pc (sal
->symtab
, sal
->line
, &pc
))
9612 error (_("No line %d in file \"%s\"."),
9613 sal
->line
, symtab_to_filename_for_display (sal
->symtab
));
9616 /* If this SAL corresponds to a breakpoint inserted using a line
9617 number, then skip the function prologue if necessary. */
9618 if (sal
->explicit_line
)
9619 skip_prologue_sal (sal
);
9622 if (sal
->section
== 0 && sal
->symtab
!= NULL
)
9624 const struct blockvector
*bv
;
9625 const struct block
*b
;
9628 bv
= blockvector_for_pc_sect (sal
->pc
, 0, &b
,
9629 SYMTAB_COMPUNIT (sal
->symtab
));
9632 sym
= block_linkage_function (b
);
9635 fixup_symbol_section (sym
, SYMTAB_OBJFILE (sal
->symtab
));
9636 sal
->section
= sym
->obj_section (SYMTAB_OBJFILE (sal
->symtab
));
9640 /* It really is worthwhile to have the section, so we'll
9641 just have to look harder. This case can be executed
9642 if we have line numbers but no functions (as can
9643 happen in assembly source). */
9645 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
9646 switch_to_program_space_and_thread (sal
->pspace
);
9648 bound_minimal_symbol msym
= lookup_minimal_symbol_by_pc (sal
->pc
);
9650 sal
->section
= msym
.obj_section ();
9657 break_command (const char *arg
, int from_tty
)
9659 break_command_1 (arg
, 0, from_tty
);
9663 tbreak_command (const char *arg
, int from_tty
)
9665 break_command_1 (arg
, BP_TEMPFLAG
, from_tty
);
9669 hbreak_command (const char *arg
, int from_tty
)
9671 break_command_1 (arg
, BP_HARDWAREFLAG
, from_tty
);
9675 thbreak_command (const char *arg
, int from_tty
)
9677 break_command_1 (arg
, (BP_TEMPFLAG
| BP_HARDWAREFLAG
), from_tty
);
9681 stop_command (const char *arg
, int from_tty
)
9683 printf_filtered (_("Specify the type of breakpoint to set.\n\
9684 Usage: stop in <function | address>\n\
9685 stop at <line>\n"));
9689 stopin_command (const char *arg
, int from_tty
)
9695 else if (*arg
!= '*')
9697 const char *argptr
= arg
;
9700 /* Look for a ':'. If this is a line number specification, then
9701 say it is bad, otherwise, it should be an address or
9702 function/method name. */
9703 while (*argptr
&& !hasColon
)
9705 hasColon
= (*argptr
== ':');
9710 badInput
= (*argptr
!= ':'); /* Not a class::method */
9712 badInput
= isdigit (*arg
); /* a simple line number */
9716 printf_filtered (_("Usage: stop in <function | address>\n"));
9718 break_command_1 (arg
, 0, from_tty
);
9722 stopat_command (const char *arg
, int from_tty
)
9726 if (arg
== NULL
|| *arg
== '*') /* no line number */
9730 const char *argptr
= arg
;
9733 /* Look for a ':'. If there is a '::' then get out, otherwise
9734 it is probably a line number. */
9735 while (*argptr
&& !hasColon
)
9737 hasColon
= (*argptr
== ':');
9742 badInput
= (*argptr
== ':'); /* we have class::method */
9744 badInput
= !isdigit (*arg
); /* not a line number */
9748 printf_filtered (_("Usage: stop at LINE\n"));
9750 break_command_1 (arg
, 0, from_tty
);
9753 /* The dynamic printf command is mostly like a regular breakpoint, but
9754 with a prewired command list consisting of a single output command,
9755 built from extra arguments supplied on the dprintf command
9759 dprintf_command (const char *arg
, int from_tty
)
9761 event_location_up location
= string_to_event_location (&arg
, current_language
);
9763 /* If non-NULL, ARG should have been advanced past the location;
9764 the next character must be ','. */
9767 if (arg
[0] != ',' || arg
[1] == '\0')
9768 error (_("Format string required"));
9771 /* Skip the comma. */
9776 create_breakpoint (get_current_arch (),
9778 NULL
, 0, arg
, false, 1 /* parse arg */,
9780 0 /* Ignore count */,
9781 pending_break_support
,
9782 &dprintf_breakpoint_ops
,
9790 agent_printf_command (const char *arg
, int from_tty
)
9792 error (_("May only run agent-printf on the target"));
9795 /* Implement the "breakpoint_hit" breakpoint_ops method for
9796 ranged breakpoints. */
9799 breakpoint_hit_ranged_breakpoint (const struct bp_location
*bl
,
9800 const address_space
*aspace
,
9802 const struct target_waitstatus
*ws
)
9804 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
9805 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
9808 return breakpoint_address_match_range (bl
->pspace
->aspace
, bl
->address
,
9809 bl
->length
, aspace
, bp_addr
);
9812 /* Implement the "resources_needed" breakpoint_ops method for
9813 ranged breakpoints. */
9816 resources_needed_ranged_breakpoint (const struct bp_location
*bl
)
9818 return target_ranged_break_num_registers ();
9821 /* Implement the "print_it" breakpoint_ops method for
9822 ranged breakpoints. */
9824 static enum print_stop_action
9825 print_it_ranged_breakpoint (bpstat bs
)
9827 struct breakpoint
*b
= bs
->breakpoint_at
;
9828 struct bp_location
*bl
= b
->loc
;
9829 struct ui_out
*uiout
= current_uiout
;
9831 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9833 /* Ranged breakpoints have only one location. */
9834 gdb_assert (bl
&& bl
->next
== NULL
);
9836 annotate_breakpoint (b
->number
);
9838 maybe_print_thread_hit_breakpoint (uiout
);
9840 if (b
->disposition
== disp_del
)
9841 uiout
->text ("Temporary ranged breakpoint ");
9843 uiout
->text ("Ranged breakpoint ");
9844 if (uiout
->is_mi_like_p ())
9846 uiout
->field_string ("reason",
9847 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
9848 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
9850 uiout
->field_signed ("bkptno", b
->number
);
9853 return PRINT_SRC_AND_LOC
;
9856 /* Implement the "print_one" breakpoint_ops method for
9857 ranged breakpoints. */
9860 print_one_ranged_breakpoint (struct breakpoint
*b
,
9861 struct bp_location
**last_loc
)
9863 struct bp_location
*bl
= b
->loc
;
9864 struct value_print_options opts
;
9865 struct ui_out
*uiout
= current_uiout
;
9867 /* Ranged breakpoints have only one location. */
9868 gdb_assert (bl
&& bl
->next
== NULL
);
9870 get_user_print_options (&opts
);
9872 if (opts
.addressprint
)
9873 /* We don't print the address range here, it will be printed later
9874 by print_one_detail_ranged_breakpoint. */
9875 uiout
->field_skip ("addr");
9877 print_breakpoint_location (b
, bl
);
9881 /* Implement the "print_one_detail" breakpoint_ops method for
9882 ranged breakpoints. */
9885 print_one_detail_ranged_breakpoint (const struct breakpoint
*b
,
9886 struct ui_out
*uiout
)
9888 CORE_ADDR address_start
, address_end
;
9889 struct bp_location
*bl
= b
->loc
;
9894 address_start
= bl
->address
;
9895 address_end
= address_start
+ bl
->length
- 1;
9897 uiout
->text ("\taddress range: ");
9898 stb
.printf ("[%s, %s]",
9899 print_core_address (bl
->gdbarch
, address_start
),
9900 print_core_address (bl
->gdbarch
, address_end
));
9901 uiout
->field_stream ("addr", stb
);
9905 /* Implement the "print_mention" breakpoint_ops method for
9906 ranged breakpoints. */
9909 print_mention_ranged_breakpoint (struct breakpoint
*b
)
9911 struct bp_location
*bl
= b
->loc
;
9912 struct ui_out
*uiout
= current_uiout
;
9915 gdb_assert (b
->type
== bp_hardware_breakpoint
);
9917 uiout
->message (_("Hardware assisted ranged breakpoint %d from %s to %s."),
9918 b
->number
, paddress (bl
->gdbarch
, bl
->address
),
9919 paddress (bl
->gdbarch
, bl
->address
+ bl
->length
- 1));
9922 /* Implement the "print_recreate" breakpoint_ops method for
9923 ranged breakpoints. */
9926 print_recreate_ranged_breakpoint (struct breakpoint
*b
, struct ui_file
*fp
)
9928 fprintf_unfiltered (fp
, "break-range %s, %s",
9929 event_location_to_string (b
->location
.get ()),
9930 event_location_to_string (b
->location_range_end
.get ()));
9931 print_recreate_thread (b
, fp
);
9934 /* The breakpoint_ops structure to be used in ranged breakpoints. */
9936 static struct breakpoint_ops ranged_breakpoint_ops
;
9938 /* Find the address where the end of the breakpoint range should be
9939 placed, given the SAL of the end of the range. This is so that if
9940 the user provides a line number, the end of the range is set to the
9941 last instruction of the given line. */
9944 find_breakpoint_range_end (struct symtab_and_line sal
)
9948 /* If the user provided a PC value, use it. Otherwise,
9949 find the address of the end of the given location. */
9950 if (sal
.explicit_pc
)
9957 ret
= find_line_pc_range (sal
, &start
, &end
);
9959 error (_("Could not find location of the end of the range."));
9961 /* find_line_pc_range returns the start of the next line. */
9968 /* Implement the "break-range" CLI command. */
9971 break_range_command (const char *arg
, int from_tty
)
9973 const char *arg_start
;
9974 struct linespec_result canonical_start
, canonical_end
;
9975 int bp_count
, can_use_bp
, length
;
9977 struct breakpoint
*b
;
9979 /* We don't support software ranged breakpoints. */
9980 if (target_ranged_break_num_registers () < 0)
9981 error (_("This target does not support hardware ranged breakpoints."));
9983 bp_count
= hw_breakpoint_used_count ();
9984 bp_count
+= target_ranged_break_num_registers ();
9985 can_use_bp
= target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
9988 error (_("Hardware breakpoints used exceeds limit."));
9990 arg
= skip_spaces (arg
);
9991 if (arg
== NULL
|| arg
[0] == '\0')
9992 error(_("No address range specified."));
9995 event_location_up start_location
= string_to_event_location (&arg
,
9997 parse_breakpoint_sals (start_location
.get (), &canonical_start
);
10000 error (_("Too few arguments."));
10001 else if (canonical_start
.lsals
.empty ())
10002 error (_("Could not find location of the beginning of the range."));
10004 const linespec_sals
&lsal_start
= canonical_start
.lsals
[0];
10006 if (canonical_start
.lsals
.size () > 1
10007 || lsal_start
.sals
.size () != 1)
10008 error (_("Cannot create a ranged breakpoint with multiple locations."));
10010 const symtab_and_line
&sal_start
= lsal_start
.sals
[0];
10011 std::string
addr_string_start (arg_start
, arg
- arg_start
);
10013 arg
++; /* Skip the comma. */
10014 arg
= skip_spaces (arg
);
10016 /* Parse the end location. */
10020 /* We call decode_line_full directly here instead of using
10021 parse_breakpoint_sals because we need to specify the start location's
10022 symtab and line as the default symtab and line for the end of the
10023 range. This makes it possible to have ranges like "foo.c:27, +14",
10024 where +14 means 14 lines from the start location. */
10025 event_location_up end_location
= string_to_event_location (&arg
,
10027 decode_line_full (end_location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
10028 sal_start
.symtab
, sal_start
.line
,
10029 &canonical_end
, NULL
, NULL
);
10031 if (canonical_end
.lsals
.empty ())
10032 error (_("Could not find location of the end of the range."));
10034 const linespec_sals
&lsal_end
= canonical_end
.lsals
[0];
10035 if (canonical_end
.lsals
.size () > 1
10036 || lsal_end
.sals
.size () != 1)
10037 error (_("Cannot create a ranged breakpoint with multiple locations."));
10039 const symtab_and_line
&sal_end
= lsal_end
.sals
[0];
10041 end
= find_breakpoint_range_end (sal_end
);
10042 if (sal_start
.pc
> end
)
10043 error (_("Invalid address range, end precedes start."));
10045 length
= end
- sal_start
.pc
+ 1;
10047 /* Length overflowed. */
10048 error (_("Address range too large."));
10049 else if (length
== 1)
10051 /* This range is simple enough to be handled by
10052 the `hbreak' command. */
10053 hbreak_command (&addr_string_start
[0], 1);
10058 /* Now set up the breakpoint. */
10059 b
= set_raw_breakpoint (get_current_arch (), sal_start
,
10060 bp_hardware_breakpoint
, &ranged_breakpoint_ops
);
10061 set_breakpoint_count (breakpoint_count
+ 1);
10062 b
->number
= breakpoint_count
;
10063 b
->disposition
= disp_donttouch
;
10064 b
->location
= std::move (start_location
);
10065 b
->location_range_end
= std::move (end_location
);
10066 b
->loc
->length
= length
;
10069 gdb::observers::breakpoint_created
.notify (b
);
10070 update_global_location_list (UGLL_MAY_INSERT
);
10073 /* Return non-zero if EXP is verified as constant. Returned zero
10074 means EXP is variable. Also the constant detection may fail for
10075 some constant expressions and in such case still falsely return
10079 watchpoint_exp_is_const (const struct expression
*exp
)
10081 return exp
->op
->constant_p ();
10084 /* Watchpoint destructor. */
10086 watchpoint::~watchpoint ()
10088 xfree (this->exp_string
);
10089 xfree (this->exp_string_reparse
);
10092 /* Implement the "re_set" breakpoint_ops method for watchpoints. */
10095 re_set_watchpoint (struct breakpoint
*b
)
10097 struct watchpoint
*w
= (struct watchpoint
*) b
;
10099 /* Watchpoint can be either on expression using entirely global
10100 variables, or it can be on local variables.
10102 Watchpoints of the first kind are never auto-deleted, and even
10103 persist across program restarts. Since they can use variables
10104 from shared libraries, we need to reparse expression as libraries
10105 are loaded and unloaded.
10107 Watchpoints on local variables can also change meaning as result
10108 of solib event. For example, if a watchpoint uses both a local
10109 and a global variables in expression, it's a local watchpoint,
10110 but unloading of a shared library will make the expression
10111 invalid. This is not a very common use case, but we still
10112 re-evaluate expression, to avoid surprises to the user.
10114 Note that for local watchpoints, we re-evaluate it only if
10115 watchpoints frame id is still valid. If it's not, it means the
10116 watchpoint is out of scope and will be deleted soon. In fact,
10117 I'm not sure we'll ever be called in this case.
10119 If a local watchpoint's frame id is still valid, then
10120 w->exp_valid_block is likewise valid, and we can safely use it.
10122 Don't do anything about disabled watchpoints, since they will be
10123 reevaluated again when enabled. */
10124 update_watchpoint (w
, 1 /* reparse */);
10127 /* Implement the "insert" breakpoint_ops method for hardware watchpoints. */
10130 insert_watchpoint (struct bp_location
*bl
)
10132 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10133 int length
= w
->exact
? 1 : bl
->length
;
10135 return target_insert_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10136 w
->cond_exp
.get ());
10139 /* Implement the "remove" breakpoint_ops method for hardware watchpoints. */
10142 remove_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10144 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10145 int length
= w
->exact
? 1 : bl
->length
;
10147 return target_remove_watchpoint (bl
->address
, length
, bl
->watchpoint_type
,
10148 w
->cond_exp
.get ());
10152 breakpoint_hit_watchpoint (const struct bp_location
*bl
,
10153 const address_space
*aspace
, CORE_ADDR bp_addr
,
10154 const struct target_waitstatus
*ws
)
10156 struct breakpoint
*b
= bl
->owner
;
10157 struct watchpoint
*w
= (struct watchpoint
*) b
;
10159 /* Continuable hardware watchpoints are treated as non-existent if the
10160 reason we stopped wasn't a hardware watchpoint (we didn't stop on
10161 some data address). Otherwise gdb won't stop on a break instruction
10162 in the code (not from a breakpoint) when a hardware watchpoint has
10163 been defined. Also skip watchpoints which we know did not trigger
10164 (did not match the data address). */
10165 if (is_hardware_watchpoint (b
)
10166 && w
->watchpoint_triggered
== watch_triggered_no
)
10173 check_status_watchpoint (bpstat bs
)
10175 gdb_assert (is_watchpoint (bs
->breakpoint_at
));
10177 bpstat_check_watchpoint (bs
);
10180 /* Implement the "resources_needed" breakpoint_ops method for
10181 hardware watchpoints. */
10184 resources_needed_watchpoint (const struct bp_location
*bl
)
10186 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10187 int length
= w
->exact
? 1 : bl
->length
;
10189 return target_region_ok_for_hw_watchpoint (bl
->address
, length
);
10192 /* Implement the "works_in_software_mode" breakpoint_ops method for
10193 hardware watchpoints. */
10196 works_in_software_mode_watchpoint (const struct breakpoint
*b
)
10198 /* Read and access watchpoints only work with hardware support. */
10199 return b
->type
== bp_watchpoint
|| b
->type
== bp_hardware_watchpoint
;
10202 static enum print_stop_action
10203 print_it_watchpoint (bpstat bs
)
10205 struct breakpoint
*b
;
10206 enum print_stop_action result
;
10207 struct watchpoint
*w
;
10208 struct ui_out
*uiout
= current_uiout
;
10210 gdb_assert (bs
->bp_location_at
!= NULL
);
10212 b
= bs
->breakpoint_at
;
10213 w
= (struct watchpoint
*) b
;
10215 annotate_watchpoint (b
->number
);
10216 maybe_print_thread_hit_breakpoint (uiout
);
10220 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
10223 case bp_watchpoint
:
10224 case bp_hardware_watchpoint
:
10225 if (uiout
->is_mi_like_p ())
10226 uiout
->field_string
10227 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10229 tuple_emitter
.emplace (uiout
, "value");
10230 uiout
->text ("\nOld value = ");
10231 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10232 uiout
->field_stream ("old", stb
);
10233 uiout
->text ("\nNew value = ");
10234 watchpoint_value_print (w
->val
.get (), &stb
);
10235 uiout
->field_stream ("new", stb
);
10236 uiout
->text ("\n");
10237 /* More than one watchpoint may have been triggered. */
10238 result
= PRINT_UNKNOWN
;
10241 case bp_read_watchpoint
:
10242 if (uiout
->is_mi_like_p ())
10243 uiout
->field_string
10244 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10246 tuple_emitter
.emplace (uiout
, "value");
10247 uiout
->text ("\nValue = ");
10248 watchpoint_value_print (w
->val
.get (), &stb
);
10249 uiout
->field_stream ("value", stb
);
10250 uiout
->text ("\n");
10251 result
= PRINT_UNKNOWN
;
10254 case bp_access_watchpoint
:
10255 if (bs
->old_val
!= NULL
)
10257 if (uiout
->is_mi_like_p ())
10258 uiout
->field_string
10260 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10262 tuple_emitter
.emplace (uiout
, "value");
10263 uiout
->text ("\nOld value = ");
10264 watchpoint_value_print (bs
->old_val
.get (), &stb
);
10265 uiout
->field_stream ("old", stb
);
10266 uiout
->text ("\nNew value = ");
10271 if (uiout
->is_mi_like_p ())
10272 uiout
->field_string
10274 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10275 tuple_emitter
.emplace (uiout
, "value");
10276 uiout
->text ("\nValue = ");
10278 watchpoint_value_print (w
->val
.get (), &stb
);
10279 uiout
->field_stream ("new", stb
);
10280 uiout
->text ("\n");
10281 result
= PRINT_UNKNOWN
;
10284 result
= PRINT_UNKNOWN
;
10290 /* Implement the "print_mention" breakpoint_ops method for hardware
10294 print_mention_watchpoint (struct breakpoint
*b
)
10296 struct watchpoint
*w
= (struct watchpoint
*) b
;
10297 struct ui_out
*uiout
= current_uiout
;
10298 const char *tuple_name
;
10302 case bp_watchpoint
:
10303 uiout
->text ("Watchpoint ");
10304 tuple_name
= "wpt";
10306 case bp_hardware_watchpoint
:
10307 uiout
->text ("Hardware watchpoint ");
10308 tuple_name
= "wpt";
10310 case bp_read_watchpoint
:
10311 uiout
->text ("Hardware read watchpoint ");
10312 tuple_name
= "hw-rwpt";
10314 case bp_access_watchpoint
:
10315 uiout
->text ("Hardware access (read/write) watchpoint ");
10316 tuple_name
= "hw-awpt";
10319 internal_error (__FILE__
, __LINE__
,
10320 _("Invalid hardware watchpoint type."));
10323 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10324 uiout
->field_signed ("number", b
->number
);
10325 uiout
->text (": ");
10326 uiout
->field_string ("exp", w
->exp_string
);
10329 /* Implement the "print_recreate" breakpoint_ops method for
10333 print_recreate_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10335 struct watchpoint
*w
= (struct watchpoint
*) b
;
10339 case bp_watchpoint
:
10340 case bp_hardware_watchpoint
:
10341 fprintf_unfiltered (fp
, "watch");
10343 case bp_read_watchpoint
:
10344 fprintf_unfiltered (fp
, "rwatch");
10346 case bp_access_watchpoint
:
10347 fprintf_unfiltered (fp
, "awatch");
10350 internal_error (__FILE__
, __LINE__
,
10351 _("Invalid watchpoint type."));
10354 fprintf_unfiltered (fp
, " %s", w
->exp_string
);
10355 print_recreate_thread (b
, fp
);
10358 /* Implement the "explains_signal" breakpoint_ops method for
10362 explains_signal_watchpoint (struct breakpoint
*b
, enum gdb_signal sig
)
10364 /* A software watchpoint cannot cause a signal other than
10365 GDB_SIGNAL_TRAP. */
10366 if (b
->type
== bp_watchpoint
&& sig
!= GDB_SIGNAL_TRAP
)
10372 /* The breakpoint_ops structure to be used in hardware watchpoints. */
10374 static struct breakpoint_ops watchpoint_breakpoint_ops
;
10376 /* Implement the "insert" breakpoint_ops method for
10377 masked hardware watchpoints. */
10380 insert_masked_watchpoint (struct bp_location
*bl
)
10382 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10384 return target_insert_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10385 bl
->watchpoint_type
);
10388 /* Implement the "remove" breakpoint_ops method for
10389 masked hardware watchpoints. */
10392 remove_masked_watchpoint (struct bp_location
*bl
, enum remove_bp_reason reason
)
10394 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10396 return target_remove_mask_watchpoint (bl
->address
, w
->hw_wp_mask
,
10397 bl
->watchpoint_type
);
10400 /* Implement the "resources_needed" breakpoint_ops method for
10401 masked hardware watchpoints. */
10404 resources_needed_masked_watchpoint (const struct bp_location
*bl
)
10406 struct watchpoint
*w
= (struct watchpoint
*) bl
->owner
;
10408 return target_masked_watch_num_registers (bl
->address
, w
->hw_wp_mask
);
10411 /* Implement the "works_in_software_mode" breakpoint_ops method for
10412 masked hardware watchpoints. */
10415 works_in_software_mode_masked_watchpoint (const struct breakpoint
*b
)
10420 /* Implement the "print_it" breakpoint_ops method for
10421 masked hardware watchpoints. */
10423 static enum print_stop_action
10424 print_it_masked_watchpoint (bpstat bs
)
10426 struct breakpoint
*b
= bs
->breakpoint_at
;
10427 struct ui_out
*uiout
= current_uiout
;
10429 /* Masked watchpoints have only one location. */
10430 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10432 annotate_watchpoint (b
->number
);
10433 maybe_print_thread_hit_breakpoint (uiout
);
10437 case bp_hardware_watchpoint
:
10438 if (uiout
->is_mi_like_p ())
10439 uiout
->field_string
10440 ("reason", async_reason_lookup (EXEC_ASYNC_WATCHPOINT_TRIGGER
));
10443 case bp_read_watchpoint
:
10444 if (uiout
->is_mi_like_p ())
10445 uiout
->field_string
10446 ("reason", async_reason_lookup (EXEC_ASYNC_READ_WATCHPOINT_TRIGGER
));
10449 case bp_access_watchpoint
:
10450 if (uiout
->is_mi_like_p ())
10451 uiout
->field_string
10453 async_reason_lookup (EXEC_ASYNC_ACCESS_WATCHPOINT_TRIGGER
));
10456 internal_error (__FILE__
, __LINE__
,
10457 _("Invalid hardware watchpoint type."));
10461 uiout
->text (_("\n\
10462 Check the underlying instruction at PC for the memory\n\
10463 address and value which triggered this watchpoint.\n"));
10464 uiout
->text ("\n");
10466 /* More than one watchpoint may have been triggered. */
10467 return PRINT_UNKNOWN
;
10470 /* Implement the "print_one_detail" breakpoint_ops method for
10471 masked hardware watchpoints. */
10474 print_one_detail_masked_watchpoint (const struct breakpoint
*b
,
10475 struct ui_out
*uiout
)
10477 struct watchpoint
*w
= (struct watchpoint
*) b
;
10479 /* Masked watchpoints have only one location. */
10480 gdb_assert (b
->loc
&& b
->loc
->next
== NULL
);
10482 uiout
->text ("\tmask ");
10483 uiout
->field_core_addr ("mask", b
->loc
->gdbarch
, w
->hw_wp_mask
);
10484 uiout
->text ("\n");
10487 /* Implement the "print_mention" breakpoint_ops method for
10488 masked hardware watchpoints. */
10491 print_mention_masked_watchpoint (struct breakpoint
*b
)
10493 struct watchpoint
*w
= (struct watchpoint
*) b
;
10494 struct ui_out
*uiout
= current_uiout
;
10495 const char *tuple_name
;
10499 case bp_hardware_watchpoint
:
10500 uiout
->text ("Masked hardware watchpoint ");
10501 tuple_name
= "wpt";
10503 case bp_read_watchpoint
:
10504 uiout
->text ("Masked hardware read watchpoint ");
10505 tuple_name
= "hw-rwpt";
10507 case bp_access_watchpoint
:
10508 uiout
->text ("Masked hardware access (read/write) watchpoint ");
10509 tuple_name
= "hw-awpt";
10512 internal_error (__FILE__
, __LINE__
,
10513 _("Invalid hardware watchpoint type."));
10516 ui_out_emit_tuple
tuple_emitter (uiout
, tuple_name
);
10517 uiout
->field_signed ("number", b
->number
);
10518 uiout
->text (": ");
10519 uiout
->field_string ("exp", w
->exp_string
);
10522 /* Implement the "print_recreate" breakpoint_ops method for
10523 masked hardware watchpoints. */
10526 print_recreate_masked_watchpoint (struct breakpoint
*b
, struct ui_file
*fp
)
10528 struct watchpoint
*w
= (struct watchpoint
*) b
;
10532 case bp_hardware_watchpoint
:
10533 fprintf_unfiltered (fp
, "watch");
10535 case bp_read_watchpoint
:
10536 fprintf_unfiltered (fp
, "rwatch");
10538 case bp_access_watchpoint
:
10539 fprintf_unfiltered (fp
, "awatch");
10542 internal_error (__FILE__
, __LINE__
,
10543 _("Invalid hardware watchpoint type."));
10546 fprintf_unfiltered (fp
, " %s mask 0x%s", w
->exp_string
,
10547 phex (w
->hw_wp_mask
, sizeof (CORE_ADDR
)));
10548 print_recreate_thread (b
, fp
);
10551 /* The breakpoint_ops structure to be used in masked hardware watchpoints. */
10553 static struct breakpoint_ops masked_watchpoint_breakpoint_ops
;
10555 /* Tell whether the given watchpoint is a masked hardware watchpoint. */
10558 is_masked_watchpoint (const struct breakpoint
*b
)
10560 return b
->ops
== &masked_watchpoint_breakpoint_ops
;
10563 /* accessflag: hw_write: watch write,
10564 hw_read: watch read,
10565 hw_access: watch access (read or write) */
10567 watch_command_1 (const char *arg
, int accessflag
, int from_tty
,
10568 bool just_location
, bool internal
)
10570 struct breakpoint
*scope_breakpoint
= NULL
;
10571 const struct block
*exp_valid_block
= NULL
, *cond_exp_valid_block
= NULL
;
10572 struct value
*result
;
10573 int saved_bitpos
= 0, saved_bitsize
= 0;
10574 const char *exp_start
= NULL
;
10575 const char *exp_end
= NULL
;
10576 const char *tok
, *end_tok
;
10578 const char *cond_start
= NULL
;
10579 const char *cond_end
= NULL
;
10580 enum bptype bp_type
;
10582 /* Flag to indicate whether we are going to use masks for
10583 the hardware watchpoint. */
10584 bool use_mask
= false;
10585 CORE_ADDR mask
= 0;
10587 /* Make sure that we actually have parameters to parse. */
10588 if (arg
!= NULL
&& arg
[0] != '\0')
10590 const char *value_start
;
10592 exp_end
= arg
+ strlen (arg
);
10594 /* Look for "parameter value" pairs at the end
10595 of the arguments string. */
10596 for (tok
= exp_end
- 1; tok
> arg
; tok
--)
10598 /* Skip whitespace at the end of the argument list. */
10599 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10602 /* Find the beginning of the last token.
10603 This is the value of the parameter. */
10604 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10606 value_start
= tok
+ 1;
10608 /* Skip whitespace. */
10609 while (tok
> arg
&& (*tok
== ' ' || *tok
== '\t'))
10614 /* Find the beginning of the second to last token.
10615 This is the parameter itself. */
10616 while (tok
> arg
&& (*tok
!= ' ' && *tok
!= '\t'))
10619 toklen
= end_tok
- tok
+ 1;
10621 if (toklen
== 6 && startswith (tok
, "thread"))
10623 struct thread_info
*thr
;
10624 /* At this point we've found a "thread" token, which means
10625 the user is trying to set a watchpoint that triggers
10626 only in a specific thread. */
10630 error(_("You can specify only one thread."));
10632 /* Extract the thread ID from the next token. */
10633 thr
= parse_thread_id (value_start
, &endp
);
10635 /* Check if the user provided a valid thread ID. */
10636 if (*endp
!= ' ' && *endp
!= '\t' && *endp
!= '\0')
10637 invalid_thread_id_error (value_start
);
10639 thread
= thr
->global_num
;
10641 else if (toklen
== 4 && startswith (tok
, "mask"))
10643 /* We've found a "mask" token, which means the user wants to
10644 create a hardware watchpoint that is going to have the mask
10646 struct value
*mask_value
, *mark
;
10649 error(_("You can specify only one mask."));
10651 use_mask
= just_location
= true;
10653 mark
= value_mark ();
10654 mask_value
= parse_to_comma_and_eval (&value_start
);
10655 mask
= value_as_address (mask_value
);
10656 value_free_to_mark (mark
);
10659 /* We didn't recognize what we found. We should stop here. */
10662 /* Truncate the string and get rid of the "parameter value" pair before
10663 the arguments string is parsed by the parse_exp_1 function. */
10670 /* Parse the rest of the arguments. From here on out, everything
10671 is in terms of a newly allocated string instead of the original
10673 std::string
expression (arg
, exp_end
- arg
);
10674 exp_start
= arg
= expression
.c_str ();
10675 innermost_block_tracker tracker
;
10676 expression_up exp
= parse_exp_1 (&arg
, 0, 0, 0, &tracker
);
10678 /* Remove trailing whitespace from the expression before saving it.
10679 This makes the eventual display of the expression string a bit
10681 while (exp_end
> exp_start
&& (exp_end
[-1] == ' ' || exp_end
[-1] == '\t'))
10684 /* Checking if the expression is not constant. */
10685 if (watchpoint_exp_is_const (exp
.get ()))
10689 len
= exp_end
- exp_start
;
10690 while (len
> 0 && isspace (exp_start
[len
- 1]))
10692 error (_("Cannot watch constant value `%.*s'."), len
, exp_start
);
10695 exp_valid_block
= tracker
.block ();
10696 struct value
*mark
= value_mark ();
10697 struct value
*val_as_value
= nullptr;
10698 fetch_subexp_value (exp
.get (), exp
->op
.get (), &val_as_value
, &result
, NULL
,
10701 if (val_as_value
!= NULL
&& just_location
)
10703 saved_bitpos
= value_bitpos (val_as_value
);
10704 saved_bitsize
= value_bitsize (val_as_value
);
10712 exp_valid_block
= NULL
;
10713 val
= release_value (value_addr (result
));
10714 value_free_to_mark (mark
);
10718 ret
= target_masked_watch_num_registers (value_as_address (val
.get ()),
10721 error (_("This target does not support masked watchpoints."));
10722 else if (ret
== -2)
10723 error (_("Invalid mask or memory region."));
10726 else if (val_as_value
!= NULL
)
10727 val
= release_value (val_as_value
);
10729 tok
= skip_spaces (arg
);
10730 end_tok
= skip_to_space (tok
);
10732 toklen
= end_tok
- tok
;
10733 if (toklen
>= 1 && strncmp (tok
, "if", toklen
) == 0)
10735 tok
= cond_start
= end_tok
+ 1;
10736 innermost_block_tracker if_tracker
;
10737 parse_exp_1 (&tok
, 0, 0, 0, &if_tracker
);
10739 /* The watchpoint expression may not be local, but the condition
10740 may still be. E.g.: `watch global if local > 0'. */
10741 cond_exp_valid_block
= if_tracker
.block ();
10746 error (_("Junk at end of command."));
10748 frame_info
*wp_frame
= block_innermost_frame (exp_valid_block
);
10750 /* Save this because create_internal_breakpoint below invalidates
10752 frame_id watchpoint_frame
= get_frame_id (wp_frame
);
10754 /* If the expression is "local", then set up a "watchpoint scope"
10755 breakpoint at the point where we've left the scope of the watchpoint
10756 expression. Create the scope breakpoint before the watchpoint, so
10757 that we will encounter it first in bpstat_stop_status. */
10758 if (exp_valid_block
!= NULL
&& wp_frame
!= NULL
)
10760 frame_id caller_frame_id
= frame_unwind_caller_id (wp_frame
);
10762 if (frame_id_p (caller_frame_id
))
10764 gdbarch
*caller_arch
= frame_unwind_caller_arch (wp_frame
);
10765 CORE_ADDR caller_pc
= frame_unwind_caller_pc (wp_frame
);
10768 = create_internal_breakpoint (caller_arch
, caller_pc
,
10769 bp_watchpoint_scope
,
10770 &momentary_breakpoint_ops
);
10772 /* create_internal_breakpoint could invalidate WP_FRAME. */
10775 scope_breakpoint
->enable_state
= bp_enabled
;
10777 /* Automatically delete the breakpoint when it hits. */
10778 scope_breakpoint
->disposition
= disp_del
;
10780 /* Only break in the proper frame (help with recursion). */
10781 scope_breakpoint
->frame_id
= caller_frame_id
;
10783 /* Set the address at which we will stop. */
10784 scope_breakpoint
->loc
->gdbarch
= caller_arch
;
10785 scope_breakpoint
->loc
->requested_address
= caller_pc
;
10786 scope_breakpoint
->loc
->address
10787 = adjust_breakpoint_address (scope_breakpoint
->loc
->gdbarch
,
10788 scope_breakpoint
->loc
->requested_address
,
10789 scope_breakpoint
->type
);
10793 /* Now set up the breakpoint. We create all watchpoints as hardware
10794 watchpoints here even if hardware watchpoints are turned off, a call
10795 to update_watchpoint later in this function will cause the type to
10796 drop back to bp_watchpoint (software watchpoint) if required. */
10798 if (accessflag
== hw_read
)
10799 bp_type
= bp_read_watchpoint
;
10800 else if (accessflag
== hw_access
)
10801 bp_type
= bp_access_watchpoint
;
10803 bp_type
= bp_hardware_watchpoint
;
10805 std::unique_ptr
<watchpoint
> w (new watchpoint ());
10808 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10809 &masked_watchpoint_breakpoint_ops
);
10811 init_raw_breakpoint_without_location (w
.get (), NULL
, bp_type
,
10812 &watchpoint_breakpoint_ops
);
10813 w
->thread
= thread
;
10814 w
->disposition
= disp_donttouch
;
10815 w
->pspace
= current_program_space
;
10816 w
->exp
= std::move (exp
);
10817 w
->exp_valid_block
= exp_valid_block
;
10818 w
->cond_exp_valid_block
= cond_exp_valid_block
;
10821 struct type
*t
= value_type (val
.get ());
10822 CORE_ADDR addr
= value_as_address (val
.get ());
10824 w
->exp_string_reparse
10825 = current_language
->watch_location_expression (t
, addr
).release ();
10827 w
->exp_string
= xstrprintf ("-location %.*s",
10828 (int) (exp_end
- exp_start
), exp_start
);
10831 w
->exp_string
= savestring (exp_start
, exp_end
- exp_start
);
10835 w
->hw_wp_mask
= mask
;
10840 w
->val_bitpos
= saved_bitpos
;
10841 w
->val_bitsize
= saved_bitsize
;
10842 w
->val_valid
= true;
10846 w
->cond_string
= savestring (cond_start
, cond_end
- cond_start
);
10848 w
->cond_string
= 0;
10850 if (frame_id_p (watchpoint_frame
))
10852 w
->watchpoint_frame
= watchpoint_frame
;
10853 w
->watchpoint_thread
= inferior_ptid
;
10857 w
->watchpoint_frame
= null_frame_id
;
10858 w
->watchpoint_thread
= null_ptid
;
10861 if (scope_breakpoint
!= NULL
)
10863 /* The scope breakpoint is related to the watchpoint. We will
10864 need to act on them together. */
10865 w
->related_breakpoint
= scope_breakpoint
;
10866 scope_breakpoint
->related_breakpoint
= w
.get ();
10869 if (!just_location
)
10870 value_free_to_mark (mark
);
10872 /* Finally update the new watchpoint. This creates the locations
10873 that should be inserted. */
10874 update_watchpoint (w
.get (), 1);
10876 install_breakpoint (internal
, std::move (w
), 1);
10879 /* Return count of debug registers needed to watch the given expression.
10880 If the watchpoint cannot be handled in hardware return zero. */
10883 can_use_hardware_watchpoint (const std::vector
<value_ref_ptr
> &vals
)
10885 int found_memory_cnt
= 0;
10887 /* Did the user specifically forbid us to use hardware watchpoints? */
10888 if (!can_use_hw_watchpoints
)
10891 gdb_assert (!vals
.empty ());
10892 struct value
*head
= vals
[0].get ();
10894 /* Make sure that the value of the expression depends only upon
10895 memory contents, and values computed from them within GDB. If we
10896 find any register references or function calls, we can't use a
10897 hardware watchpoint.
10899 The idea here is that evaluating an expression generates a series
10900 of values, one holding the value of every subexpression. (The
10901 expression a*b+c has five subexpressions: a, b, a*b, c, and
10902 a*b+c.) GDB's values hold almost enough information to establish
10903 the criteria given above --- they identify memory lvalues,
10904 register lvalues, computed values, etcetera. So we can evaluate
10905 the expression, and then scan the chain of values that leaves
10906 behind to decide whether we can detect any possible change to the
10907 expression's final value using only hardware watchpoints.
10909 However, I don't think that the values returned by inferior
10910 function calls are special in any way. So this function may not
10911 notice that an expression involving an inferior function call
10912 can't be watched with hardware watchpoints. FIXME. */
10913 for (const value_ref_ptr
&iter
: vals
)
10915 struct value
*v
= iter
.get ();
10917 if (VALUE_LVAL (v
) == lval_memory
)
10919 if (v
!= head
&& value_lazy (v
))
10920 /* A lazy memory lvalue in the chain is one that GDB never
10921 needed to fetch; we either just used its address (e.g.,
10922 `a' in `a.b') or we never needed it at all (e.g., `a'
10923 in `a,b'). This doesn't apply to HEAD; if that is
10924 lazy then it was not readable, but watch it anyway. */
10928 /* Ahh, memory we actually used! Check if we can cover
10929 it with hardware watchpoints. */
10930 struct type
*vtype
= check_typedef (value_type (v
));
10932 /* We only watch structs and arrays if user asked for it
10933 explicitly, never if they just happen to appear in a
10934 middle of some value chain. */
10936 || (vtype
->code () != TYPE_CODE_STRUCT
10937 && vtype
->code () != TYPE_CODE_ARRAY
))
10939 CORE_ADDR vaddr
= value_address (v
);
10943 len
= (target_exact_watchpoints
10944 && is_scalar_type_recursive (vtype
))?
10945 1 : TYPE_LENGTH (value_type (v
));
10947 num_regs
= target_region_ok_for_hw_watchpoint (vaddr
, len
);
10951 found_memory_cnt
+= num_regs
;
10955 else if (VALUE_LVAL (v
) != not_lval
10956 && deprecated_value_modifiable (v
) == 0)
10957 return 0; /* These are values from the history (e.g., $1). */
10958 else if (VALUE_LVAL (v
) == lval_register
)
10959 return 0; /* Cannot watch a register with a HW watchpoint. */
10962 /* The expression itself looks suitable for using a hardware
10963 watchpoint, but give the target machine a chance to reject it. */
10964 return found_memory_cnt
;
10968 watch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
10970 watch_command_1 (arg
, hw_write
, from_tty
, 0, internal
);
10973 /* Options for the watch, awatch, and rwatch commands. */
10975 struct watch_options
10977 /* For -location. */
10978 bool location
= false;
10981 /* Definitions of options for the "watch", "awatch", and "rwatch" commands.
10983 Historically GDB always accepted both '-location' and '-l' flags for
10984 these commands (both flags being synonyms). When converting to the
10985 newer option scheme only '-location' is added here. That's fine (for
10986 backward compatibility) as any non-ambiguous prefix of a flag will be
10987 accepted, so '-l', '-loc', are now all accepted.
10989 What this means is that, if in the future, we add any new flag here
10990 that starts with '-l' then this will break backward compatibility, so
10991 please, don't do that! */
10993 static const gdb::option::option_def watch_option_defs
[] = {
10994 gdb::option::flag_option_def
<watch_options
> {
10996 [] (watch_options
*opt
) { return &opt
->location
; },
10998 This evaluates EXPRESSION and watches the memory to which is refers.\n\
10999 -l can be used as a short form of -location."),
11003 /* Returns the option group used by 'watch', 'awatch', and 'rwatch'
11006 static gdb::option::option_def_group
11007 make_watch_options_def_group (watch_options
*opts
)
11009 return {{watch_option_defs
}, opts
};
11012 /* A helper function that looks for the "-location" argument and then
11013 calls watch_command_1. */
11016 watch_maybe_just_location (const char *arg
, int accessflag
, int from_tty
)
11018 watch_options opts
;
11019 auto grp
= make_watch_options_def_group (&opts
);
11020 gdb::option::process_options
11021 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
11022 if (arg
!= nullptr && *arg
== '\0')
11025 watch_command_1 (arg
, accessflag
, from_tty
, opts
.location
, false);
11028 /* Command completion for 'watch', 'awatch', and 'rwatch' commands. */
11030 watch_command_completer (struct cmd_list_element
*ignore
,
11031 completion_tracker
&tracker
,
11032 const char *text
, const char * /*word*/)
11034 const auto group
= make_watch_options_def_group (nullptr);
11035 if (gdb::option::complete_options
11036 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
11039 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
11040 expression_completer (ignore
, tracker
, text
, word
);
11044 watch_command (const char *arg
, int from_tty
)
11046 watch_maybe_just_location (arg
, hw_write
, from_tty
);
11050 rwatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
11052 watch_command_1 (arg
, hw_read
, from_tty
, 0, internal
);
11056 rwatch_command (const char *arg
, int from_tty
)
11058 watch_maybe_just_location (arg
, hw_read
, from_tty
);
11062 awatch_command_wrapper (const char *arg
, int from_tty
, bool internal
)
11064 watch_command_1 (arg
, hw_access
, from_tty
, 0, internal
);
11068 awatch_command (const char *arg
, int from_tty
)
11070 watch_maybe_just_location (arg
, hw_access
, from_tty
);
11074 /* Data for the FSM that manages the until(location)/advance commands
11075 in infcmd.c. Here because it uses the mechanisms of
11078 struct until_break_fsm
: public thread_fsm
11080 /* The thread that was current when the command was executed. */
11083 /* The breakpoint set at the return address in the caller frame,
11084 plus breakpoints at all the destination locations. */
11085 std::vector
<breakpoint_up
> breakpoints
;
11087 until_break_fsm (struct interp
*cmd_interp
, int thread
,
11088 std::vector
<breakpoint_up
> &&breakpoints
)
11089 : thread_fsm (cmd_interp
),
11091 breakpoints (std::move (breakpoints
))
11095 void clean_up (struct thread_info
*thread
) override
;
11096 bool should_stop (struct thread_info
*thread
) override
;
11097 enum async_reply_reason
do_async_reply_reason () override
;
11100 /* Implementation of the 'should_stop' FSM method for the
11101 until(location)/advance commands. */
11104 until_break_fsm::should_stop (struct thread_info
*tp
)
11106 for (const breakpoint_up
&bp
: breakpoints
)
11107 if (bpstat_find_breakpoint (tp
->control
.stop_bpstat
,
11108 bp
.get ()) != NULL
)
11117 /* Implementation of the 'clean_up' FSM method for the
11118 until(location)/advance commands. */
11121 until_break_fsm::clean_up (struct thread_info
*)
11123 /* Clean up our temporary breakpoints. */
11124 breakpoints
.clear ();
11125 delete_longjmp_breakpoint (thread
);
11128 /* Implementation of the 'async_reply_reason' FSM method for the
11129 until(location)/advance commands. */
11131 enum async_reply_reason
11132 until_break_fsm::do_async_reply_reason ()
11134 return EXEC_ASYNC_LOCATION_REACHED
;
11138 until_break_command (const char *arg
, int from_tty
, int anywhere
)
11140 struct frame_info
*frame
;
11141 struct gdbarch
*frame_gdbarch
;
11142 struct frame_id stack_frame_id
;
11143 struct frame_id caller_frame_id
;
11145 struct thread_info
*tp
;
11147 clear_proceed_status (0);
11149 /* Set a breakpoint where the user wants it and at return from
11152 event_location_up location
= string_to_event_location (&arg
, current_language
);
11154 std::vector
<symtab_and_line
> sals
11155 = (last_displayed_sal_is_valid ()
11156 ? decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
, NULL
,
11157 get_last_displayed_symtab (),
11158 get_last_displayed_line ())
11159 : decode_line_1 (location
.get (), DECODE_LINE_FUNFIRSTLINE
,
11163 error (_("Couldn't get information on specified line."));
11166 error (_("Junk at end of arguments."));
11168 tp
= inferior_thread ();
11169 thread
= tp
->global_num
;
11171 /* Note linespec handling above invalidates the frame chain.
11172 Installing a breakpoint also invalidates the frame chain (as it
11173 may need to switch threads), so do any frame handling before
11176 frame
= get_selected_frame (NULL
);
11177 frame_gdbarch
= get_frame_arch (frame
);
11178 stack_frame_id
= get_stack_frame_id (frame
);
11179 caller_frame_id
= frame_unwind_caller_id (frame
);
11181 /* Keep within the current frame, or in frames called by the current
11184 std::vector
<breakpoint_up
> breakpoints
;
11186 gdb::optional
<delete_longjmp_breakpoint_cleanup
> lj_deleter
;
11188 if (frame_id_p (caller_frame_id
))
11190 struct symtab_and_line sal2
;
11191 struct gdbarch
*caller_gdbarch
;
11193 sal2
= find_pc_line (frame_unwind_caller_pc (frame
), 0);
11194 sal2
.pc
= frame_unwind_caller_pc (frame
);
11195 caller_gdbarch
= frame_unwind_caller_arch (frame
);
11197 breakpoint_up caller_breakpoint
11198 = set_momentary_breakpoint (caller_gdbarch
, sal2
,
11199 caller_frame_id
, bp_until
);
11200 breakpoints
.emplace_back (std::move (caller_breakpoint
));
11202 set_longjmp_breakpoint (tp
, caller_frame_id
);
11203 lj_deleter
.emplace (thread
);
11206 /* set_momentary_breakpoint could invalidate FRAME. */
11209 /* If the user told us to continue until a specified location, we
11210 don't specify a frame at which we need to stop. Otherwise,
11211 specify the selected frame, because we want to stop only at the
11212 very same frame. */
11213 frame_id stop_frame_id
= anywhere
? null_frame_id
: stack_frame_id
;
11215 for (symtab_and_line
&sal
: sals
)
11217 resolve_sal_pc (&sal
);
11219 breakpoint_up location_breakpoint
11220 = set_momentary_breakpoint (frame_gdbarch
, sal
,
11221 stop_frame_id
, bp_until
);
11222 breakpoints
.emplace_back (std::move (location_breakpoint
));
11225 tp
->thread_fsm
= new until_break_fsm (command_interp (), tp
->global_num
,
11226 std::move (breakpoints
));
11229 lj_deleter
->release ();
11231 proceed (-1, GDB_SIGNAL_DEFAULT
);
11234 /* This function attempts to parse an optional "if <cond>" clause
11235 from the arg string. If one is not found, it returns NULL.
11237 Else, it returns a pointer to the condition string. (It does not
11238 attempt to evaluate the string against a particular block.) And,
11239 it updates arg to point to the first character following the parsed
11240 if clause in the arg string. */
11243 ep_parse_optional_if_clause (const char **arg
)
11245 const char *cond_string
;
11247 if (((*arg
)[0] != 'i') || ((*arg
)[1] != 'f') || !isspace ((*arg
)[2]))
11250 /* Skip the "if" keyword. */
11253 /* Skip any extra leading whitespace, and record the start of the
11254 condition string. */
11255 *arg
= skip_spaces (*arg
);
11256 cond_string
= *arg
;
11258 /* Assume that the condition occupies the remainder of the arg
11260 (*arg
) += strlen (cond_string
);
11262 return cond_string
;
11265 /* Commands to deal with catching events, such as signals, exceptions,
11266 process start/exit, etc. */
11270 catch_fork_temporary
, catch_vfork_temporary
,
11271 catch_fork_permanent
, catch_vfork_permanent
11276 catch_fork_command_1 (const char *arg
, int from_tty
,
11277 struct cmd_list_element
*command
)
11279 struct gdbarch
*gdbarch
= get_current_arch ();
11280 const char *cond_string
= NULL
;
11281 catch_fork_kind fork_kind
;
11283 fork_kind
= (catch_fork_kind
) (uintptr_t) get_cmd_context (command
);
11284 bool temp
= (fork_kind
== catch_fork_temporary
11285 || fork_kind
== catch_vfork_temporary
);
11289 arg
= skip_spaces (arg
);
11291 /* The allowed syntax is:
11293 catch [v]fork if <cond>
11295 First, check if there's an if clause. */
11296 cond_string
= ep_parse_optional_if_clause (&arg
);
11298 if ((*arg
!= '\0') && !isspace (*arg
))
11299 error (_("Junk at end of arguments."));
11301 /* If this target supports it, create a fork or vfork catchpoint
11302 and enable reporting of such events. */
11305 case catch_fork_temporary
:
11306 case catch_fork_permanent
:
11307 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11308 &catch_fork_breakpoint_ops
);
11310 case catch_vfork_temporary
:
11311 case catch_vfork_permanent
:
11312 create_fork_vfork_event_catchpoint (gdbarch
, temp
, cond_string
,
11313 &catch_vfork_breakpoint_ops
);
11316 error (_("unsupported or unknown fork kind; cannot catch it"));
11322 catch_exec_command_1 (const char *arg
, int from_tty
,
11323 struct cmd_list_element
*command
)
11325 struct gdbarch
*gdbarch
= get_current_arch ();
11326 const char *cond_string
= NULL
;
11327 bool temp
= get_cmd_context (command
) == CATCH_TEMPORARY
;
11331 arg
= skip_spaces (arg
);
11333 /* The allowed syntax is:
11335 catch exec if <cond>
11337 First, check if there's an if clause. */
11338 cond_string
= ep_parse_optional_if_clause (&arg
);
11340 if ((*arg
!= '\0') && !isspace (*arg
))
11341 error (_("Junk at end of arguments."));
11343 std::unique_ptr
<exec_catchpoint
> c (new exec_catchpoint ());
11344 init_catchpoint (c
.get (), gdbarch
, temp
, cond_string
,
11345 &catch_exec_breakpoint_ops
);
11346 c
->exec_pathname
= NULL
;
11348 install_breakpoint (0, std::move (c
), 1);
11352 init_ada_exception_breakpoint (struct breakpoint
*b
,
11353 struct gdbarch
*gdbarch
,
11354 struct symtab_and_line sal
,
11355 const char *addr_string
,
11356 const struct breakpoint_ops
*ops
,
11363 struct gdbarch
*loc_gdbarch
= get_sal_arch (sal
);
11365 loc_gdbarch
= gdbarch
;
11367 describe_other_breakpoints (loc_gdbarch
,
11368 sal
.pspace
, sal
.pc
, sal
.section
, -1);
11369 /* FIXME: brobecker/2006-12-28: Actually, re-implement a special
11370 version for exception catchpoints, because two catchpoints
11371 used for different exception names will use the same address.
11372 In this case, a "breakpoint ... also set at..." warning is
11373 unproductive. Besides, the warning phrasing is also a bit
11374 inappropriate, we should use the word catchpoint, and tell
11375 the user what type of catchpoint it is. The above is good
11376 enough for now, though. */
11379 init_raw_breakpoint (b
, gdbarch
, sal
, bp_catchpoint
, ops
);
11381 b
->enable_state
= enabled
? bp_enabled
: bp_disabled
;
11382 b
->disposition
= tempflag
? disp_del
: disp_donttouch
;
11383 b
->location
= string_to_event_location (&addr_string
,
11384 language_def (language_ada
));
11385 b
->language
= language_ada
;
11390 /* Compare two breakpoints and return a strcmp-like result. */
11393 compare_breakpoints (const breakpoint
*a
, const breakpoint
*b
)
11395 uintptr_t ua
= (uintptr_t) a
;
11396 uintptr_t ub
= (uintptr_t) b
;
11398 if (a
->number
< b
->number
)
11400 else if (a
->number
> b
->number
)
11403 /* Now sort by address, in case we see, e..g, two breakpoints with
11407 return ua
> ub
? 1 : 0;
11410 /* Delete breakpoints by address or line. */
11413 clear_command (const char *arg
, int from_tty
)
11417 std::vector
<symtab_and_line
> decoded_sals
;
11418 symtab_and_line last_sal
;
11419 gdb::array_view
<symtab_and_line
> sals
;
11423 = decode_line_with_current_source (arg
,
11424 (DECODE_LINE_FUNFIRSTLINE
11425 | DECODE_LINE_LIST_MODE
));
11427 sals
= decoded_sals
;
11431 /* Set sal's line, symtab, pc, and pspace to the values
11432 corresponding to the last call to print_frame_info. If the
11433 codepoint is not valid, this will set all the fields to 0. */
11434 last_sal
= get_last_displayed_sal ();
11435 if (last_sal
.symtab
== 0)
11436 error (_("No source file specified."));
11442 /* We don't call resolve_sal_pc here. That's not as bad as it
11443 seems, because all existing breakpoints typically have both
11444 file/line and pc set. So, if clear is given file/line, we can
11445 match this to existing breakpoint without obtaining pc at all.
11447 We only support clearing given the address explicitly
11448 present in breakpoint table. Say, we've set breakpoint
11449 at file:line. There were several PC values for that file:line,
11450 due to optimization, all in one block.
11452 We've picked one PC value. If "clear" is issued with another
11453 PC corresponding to the same file:line, the breakpoint won't
11454 be cleared. We probably can still clear the breakpoint, but
11455 since the other PC value is never presented to user, user
11456 can only find it by guessing, and it does not seem important
11457 to support that. */
11459 /* For each line spec given, delete bps which correspond to it. Do
11460 it in two passes, solely to preserve the current behavior that
11461 from_tty is forced true if we delete more than one
11464 std::vector
<struct breakpoint
*> found
;
11465 for (const auto &sal
: sals
)
11467 const char *sal_fullname
;
11469 /* If exact pc given, clear bpts at that pc.
11470 If line given (pc == 0), clear all bpts on specified line.
11471 If defaulting, clear all bpts on default line
11474 defaulting sal.pc != 0 tests to do
11479 1 0 <can't happen> */
11481 sal_fullname
= (sal
.symtab
== NULL
11482 ? NULL
: symtab_to_fullname (sal
.symtab
));
11484 /* Find all matching breakpoints and add them to 'found'. */
11485 for (breakpoint
*b
: all_breakpoints ())
11488 /* Are we going to delete b? */
11489 if (b
->type
!= bp_none
&& !is_watchpoint (b
))
11491 for (bp_location
*loc
: b
->locations ())
11493 /* If the user specified file:line, don't allow a PC
11494 match. This matches historical gdb behavior. */
11495 int pc_match
= (!sal
.explicit_line
11497 && (loc
->pspace
== sal
.pspace
)
11498 && (loc
->address
== sal
.pc
)
11499 && (!section_is_overlay (loc
->section
)
11500 || loc
->section
== sal
.section
));
11501 int line_match
= 0;
11503 if ((default_match
|| sal
.explicit_line
)
11504 && loc
->symtab
!= NULL
11505 && sal_fullname
!= NULL
11506 && sal
.pspace
== loc
->pspace
11507 && loc
->line_number
== sal
.line
11508 && filename_cmp (symtab_to_fullname (loc
->symtab
),
11509 sal_fullname
) == 0)
11512 if (pc_match
|| line_match
)
11521 found
.push_back (b
);
11525 /* Now go thru the 'found' chain and delete them. */
11526 if (found
.empty ())
11529 error (_("No breakpoint at %s."), arg
);
11531 error (_("No breakpoint at this line."));
11534 /* Remove duplicates from the vec. */
11535 std::sort (found
.begin (), found
.end (),
11536 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11538 return compare_breakpoints (bp_a
, bp_b
) < 0;
11540 found
.erase (std::unique (found
.begin (), found
.end (),
11541 [] (const breakpoint
*bp_a
, const breakpoint
*bp_b
)
11543 return compare_breakpoints (bp_a
, bp_b
) == 0;
11547 if (found
.size () > 1)
11548 from_tty
= 1; /* Always report if deleted more than one. */
11551 if (found
.size () == 1)
11552 printf_unfiltered (_("Deleted breakpoint "));
11554 printf_unfiltered (_("Deleted breakpoints "));
11557 for (breakpoint
*iter
: found
)
11560 printf_unfiltered ("%d ", iter
->number
);
11561 delete_breakpoint (iter
);
11564 putchar_unfiltered ('\n');
11567 /* Delete breakpoint in BS if they are `delete' breakpoints and
11568 all breakpoints that are marked for deletion, whether hit or not.
11569 This is called after any breakpoint is hit, or after errors. */
11572 breakpoint_auto_delete (bpstat bs
)
11574 for (; bs
; bs
= bs
->next
)
11575 if (bs
->breakpoint_at
11576 && bs
->breakpoint_at
->disposition
== disp_del
11578 delete_breakpoint (bs
->breakpoint_at
);
11580 for (breakpoint
*b
: all_breakpoints_safe ())
11581 if (b
->disposition
== disp_del_at_next_stop
)
11582 delete_breakpoint (b
);
11585 /* A comparison function for bp_location AP and BP being interfaced to
11586 std::sort. Sort elements primarily by their ADDRESS (no matter what
11587 bl_address_is_meaningful says), secondarily by ordering first
11588 permanent elements and terciarily just ensuring the array is sorted
11589 stable way despite std::sort being an unstable algorithm. */
11592 bp_location_is_less_than (const bp_location
*a
, const bp_location
*b
)
11594 if (a
->address
!= b
->address
)
11595 return a
->address
< b
->address
;
11597 /* Sort locations at the same address by their pspace number, keeping
11598 locations of the same inferior (in a multi-inferior environment)
11601 if (a
->pspace
->num
!= b
->pspace
->num
)
11602 return a
->pspace
->num
< b
->pspace
->num
;
11604 /* Sort permanent breakpoints first. */
11605 if (a
->permanent
!= b
->permanent
)
11606 return a
->permanent
> b
->permanent
;
11608 /* Sort by type in order to make duplicate determination easier.
11609 See update_global_location_list. This is kept in sync with
11610 breakpoint_locations_match. */
11611 if (a
->loc_type
< b
->loc_type
)
11614 /* Likewise, for range-breakpoints, sort by length. */
11615 if (a
->loc_type
== bp_loc_hardware_breakpoint
11616 && b
->loc_type
== bp_loc_hardware_breakpoint
11617 && a
->length
< b
->length
)
11620 /* Make the internal GDB representation stable across GDB runs
11621 where A and B memory inside GDB can differ. Breakpoint locations of
11622 the same type at the same address can be sorted in arbitrary order. */
11624 if (a
->owner
->number
!= b
->owner
->number
)
11625 return a
->owner
->number
< b
->owner
->number
;
11630 /* Set bp_locations_placed_address_before_address_max and
11631 bp_locations_shadow_len_after_address_max according to the current
11632 content of the bp_locations array. */
11635 bp_locations_target_extensions_update (void)
11637 bp_locations_placed_address_before_address_max
= 0;
11638 bp_locations_shadow_len_after_address_max
= 0;
11640 for (bp_location
*bl
: all_bp_locations ())
11642 CORE_ADDR start
, end
, addr
;
11644 if (!bp_location_has_shadow (bl
))
11647 start
= bl
->target_info
.placed_address
;
11648 end
= start
+ bl
->target_info
.shadow_len
;
11650 gdb_assert (bl
->address
>= start
);
11651 addr
= bl
->address
- start
;
11652 if (addr
> bp_locations_placed_address_before_address_max
)
11653 bp_locations_placed_address_before_address_max
= addr
;
11655 /* Zero SHADOW_LEN would not pass bp_location_has_shadow. */
11657 gdb_assert (bl
->address
< end
);
11658 addr
= end
- bl
->address
;
11659 if (addr
> bp_locations_shadow_len_after_address_max
)
11660 bp_locations_shadow_len_after_address_max
= addr
;
11664 /* Download tracepoint locations if they haven't been. */
11667 download_tracepoint_locations (void)
11669 enum tribool can_download_tracepoint
= TRIBOOL_UNKNOWN
;
11671 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
11673 for (breakpoint
*b
: all_tracepoints ())
11675 struct tracepoint
*t
;
11676 int bp_location_downloaded
= 0;
11678 if ((b
->type
== bp_fast_tracepoint
11679 ? !may_insert_fast_tracepoints
11680 : !may_insert_tracepoints
))
11683 if (can_download_tracepoint
== TRIBOOL_UNKNOWN
)
11685 if (target_can_download_tracepoint ())
11686 can_download_tracepoint
= TRIBOOL_TRUE
;
11688 can_download_tracepoint
= TRIBOOL_FALSE
;
11691 if (can_download_tracepoint
== TRIBOOL_FALSE
)
11694 for (bp_location
*bl
: b
->locations ())
11696 /* In tracepoint, locations are _never_ duplicated, so
11697 should_be_inserted is equivalent to
11698 unduplicated_should_be_inserted. */
11699 if (!should_be_inserted (bl
) || bl
->inserted
)
11702 switch_to_program_space_and_thread (bl
->pspace
);
11704 target_download_tracepoint (bl
);
11707 bp_location_downloaded
= 1;
11709 t
= (struct tracepoint
*) b
;
11710 t
->number_on_target
= b
->number
;
11711 if (bp_location_downloaded
)
11712 gdb::observers::breakpoint_modified
.notify (b
);
11716 /* Swap the insertion/duplication state between two locations. */
11719 swap_insertion (struct bp_location
*left
, struct bp_location
*right
)
11721 const int left_inserted
= left
->inserted
;
11722 const int left_duplicate
= left
->duplicate
;
11723 const int left_needs_update
= left
->needs_update
;
11724 const struct bp_target_info left_target_info
= left
->target_info
;
11726 /* Locations of tracepoints can never be duplicated. */
11727 if (is_tracepoint (left
->owner
))
11728 gdb_assert (!left
->duplicate
);
11729 if (is_tracepoint (right
->owner
))
11730 gdb_assert (!right
->duplicate
);
11732 left
->inserted
= right
->inserted
;
11733 left
->duplicate
= right
->duplicate
;
11734 left
->needs_update
= right
->needs_update
;
11735 left
->target_info
= right
->target_info
;
11736 right
->inserted
= left_inserted
;
11737 right
->duplicate
= left_duplicate
;
11738 right
->needs_update
= left_needs_update
;
11739 right
->target_info
= left_target_info
;
11742 /* Force the re-insertion of the locations at ADDRESS. This is called
11743 once a new/deleted/modified duplicate location is found and we are evaluating
11744 conditions on the target's side. Such conditions need to be updated on
11748 force_breakpoint_reinsertion (struct bp_location
*bl
)
11750 CORE_ADDR address
= 0;
11753 address
= bl
->address
;
11754 pspace_num
= bl
->pspace
->num
;
11756 /* This is only meaningful if the target is
11757 evaluating conditions and if the user has
11758 opted for condition evaluation on the target's
11760 if (gdb_evaluates_breakpoint_condition_p ()
11761 || !target_supports_evaluation_of_breakpoint_conditions ())
11764 /* Flag all breakpoint locations with this address and
11765 the same program space as the location
11766 as "its condition has changed". We need to
11767 update the conditions on the target's side. */
11768 for (bp_location
*loc
: all_bp_locations_at_addr (address
))
11770 if (!is_breakpoint (loc
->owner
)
11771 || pspace_num
!= loc
->pspace
->num
)
11774 /* Flag the location appropriately. We use a different state to
11775 let everyone know that we already updated the set of locations
11776 with addr bl->address and program space bl->pspace. This is so
11777 we don't have to keep calling these functions just to mark locations
11778 that have already been marked. */
11779 loc
->condition_changed
= condition_updated
;
11781 /* Free the agent expression bytecode as well. We will compute
11783 loc
->cond_bytecode
.reset ();
11787 /* Called whether new breakpoints are created, or existing breakpoints
11788 deleted, to update the global location list and recompute which
11789 locations are duplicate of which.
11791 The INSERT_MODE flag determines whether locations may not, may, or
11792 shall be inserted now. See 'enum ugll_insert_mode' for more
11796 update_global_location_list (enum ugll_insert_mode insert_mode
)
11798 /* Last breakpoint location address that was marked for update. */
11799 CORE_ADDR last_addr
= 0;
11800 /* Last breakpoint location program space that was marked for update. */
11801 int last_pspace_num
= -1;
11803 /* Used in the duplicates detection below. When iterating over all
11804 bp_locations, points to the first bp_location of a given address.
11805 Breakpoints and watchpoints of different types are never
11806 duplicates of each other. Keep one pointer for each type of
11807 breakpoint/watchpoint, so we only need to loop over all locations
11809 struct bp_location
*bp_loc_first
; /* breakpoint */
11810 struct bp_location
*wp_loc_first
; /* hardware watchpoint */
11811 struct bp_location
*awp_loc_first
; /* access watchpoint */
11812 struct bp_location
*rwp_loc_first
; /* read watchpoint */
11814 /* Saved former bp_locations array which we compare against the newly
11815 built bp_locations from the current state of ALL_BREAKPOINTS. */
11816 std::vector
<bp_location
*> old_locations
= std::move (bp_locations
);
11817 bp_locations
.clear ();
11819 for (breakpoint
*b
: all_breakpoints ())
11820 for (bp_location
*loc
: b
->locations ())
11821 bp_locations
.push_back (loc
);
11823 /* See if we need to "upgrade" a software breakpoint to a hardware
11824 breakpoint. Do this before deciding whether locations are
11825 duplicates. Also do this before sorting because sorting order
11826 depends on location type. */
11827 for (bp_location
*loc
: bp_locations
)
11828 if (!loc
->inserted
&& should_be_inserted (loc
))
11829 handle_automatic_hardware_breakpoints (loc
);
11831 std::sort (bp_locations
.begin (), bp_locations
.end (),
11832 bp_location_is_less_than
);
11834 bp_locations_target_extensions_update ();
11836 /* Identify bp_location instances that are no longer present in the
11837 new list, and therefore should be freed. Note that it's not
11838 necessary that those locations should be removed from inferior --
11839 if there's another location at the same address (previously
11840 marked as duplicate), we don't need to remove/insert the
11843 LOCP is kept in sync with OLD_LOCP, each pointing to the current
11844 and former bp_location array state respectively. */
11847 for (bp_location
*old_loc
: old_locations
)
11849 /* Tells if 'old_loc' is found among the new locations. If
11850 not, we have to free it. */
11851 int found_object
= 0;
11852 /* Tells if the location should remain inserted in the target. */
11853 int keep_in_target
= 0;
11856 /* Skip LOCP entries which will definitely never be needed.
11857 Stop either at or being the one matching OLD_LOC. */
11858 while (loc_i
< bp_locations
.size ()
11859 && bp_locations
[loc_i
]->address
< old_loc
->address
)
11862 for (size_t loc2_i
= loc_i
;
11863 (loc2_i
< bp_locations
.size ()
11864 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11867 /* Check if this is a new/duplicated location or a duplicated
11868 location that had its condition modified. If so, we want to send
11869 its condition to the target if evaluation of conditions is taking
11871 if (bp_locations
[loc2_i
]->condition_changed
== condition_modified
11872 && (last_addr
!= old_loc
->address
11873 || last_pspace_num
!= old_loc
->pspace
->num
))
11875 force_breakpoint_reinsertion (bp_locations
[loc2_i
]);
11876 last_pspace_num
= old_loc
->pspace
->num
;
11879 if (bp_locations
[loc2_i
] == old_loc
)
11883 /* We have already handled this address, update it so that we don't
11884 have to go through updates again. */
11885 last_addr
= old_loc
->address
;
11887 /* Target-side condition evaluation: Handle deleted locations. */
11889 force_breakpoint_reinsertion (old_loc
);
11891 /* If this location is no longer present, and inserted, look if
11892 there's maybe a new location at the same address. If so,
11893 mark that one inserted, and don't remove this one. This is
11894 needed so that we don't have a time window where a breakpoint
11895 at certain location is not inserted. */
11897 if (old_loc
->inserted
)
11899 /* If the location is inserted now, we might have to remove
11902 if (found_object
&& should_be_inserted (old_loc
))
11904 /* The location is still present in the location list,
11905 and still should be inserted. Don't do anything. */
11906 keep_in_target
= 1;
11910 /* This location still exists, but it won't be kept in the
11911 target since it may have been disabled. We proceed to
11912 remove its target-side condition. */
11914 /* The location is either no longer present, or got
11915 disabled. See if there's another location at the
11916 same address, in which case we don't need to remove
11917 this one from the target. */
11919 /* OLD_LOC comes from existing struct breakpoint. */
11920 if (bl_address_is_meaningful (old_loc
))
11922 for (size_t loc2_i
= loc_i
;
11923 (loc2_i
< bp_locations
.size ()
11924 && bp_locations
[loc2_i
]->address
== old_loc
->address
);
11927 bp_location
*loc2
= bp_locations
[loc2_i
];
11929 if (loc2
== old_loc
)
11932 if (breakpoint_locations_match (loc2
, old_loc
))
11934 /* Read watchpoint locations are switched to
11935 access watchpoints, if the former are not
11936 supported, but the latter are. */
11937 if (is_hardware_watchpoint (old_loc
->owner
))
11939 gdb_assert (is_hardware_watchpoint (loc2
->owner
));
11940 loc2
->watchpoint_type
= old_loc
->watchpoint_type
;
11943 /* loc2 is a duplicated location. We need to check
11944 if it should be inserted in case it will be
11946 if (unduplicated_should_be_inserted (loc2
))
11948 swap_insertion (old_loc
, loc2
);
11949 keep_in_target
= 1;
11957 if (!keep_in_target
)
11959 if (remove_breakpoint (old_loc
))
11961 /* This is just about all we can do. We could keep
11962 this location on the global list, and try to
11963 remove it next time, but there's no particular
11964 reason why we will succeed next time.
11966 Note that at this point, old_loc->owner is still
11967 valid, as delete_breakpoint frees the breakpoint
11968 only after calling us. */
11969 printf_filtered (_("warning: Error removing "
11970 "breakpoint %d\n"),
11971 old_loc
->owner
->number
);
11979 if (removed
&& target_is_non_stop_p ()
11980 && need_moribund_for_location_type (old_loc
))
11982 /* This location was removed from the target. In
11983 non-stop mode, a race condition is possible where
11984 we've removed a breakpoint, but stop events for that
11985 breakpoint are already queued and will arrive later.
11986 We apply an heuristic to be able to distinguish such
11987 SIGTRAPs from other random SIGTRAPs: we keep this
11988 breakpoint location for a bit, and will retire it
11989 after we see some number of events. The theory here
11990 is that reporting of events should, "on the average",
11991 be fair, so after a while we'll see events from all
11992 threads that have anything of interest, and no longer
11993 need to keep this breakpoint location around. We
11994 don't hold locations forever so to reduce chances of
11995 mistaking a non-breakpoint SIGTRAP for a breakpoint
11998 The heuristic failing can be disastrous on
11999 decr_pc_after_break targets.
12001 On decr_pc_after_break targets, like e.g., x86-linux,
12002 if we fail to recognize a late breakpoint SIGTRAP,
12003 because events_till_retirement has reached 0 too
12004 soon, we'll fail to do the PC adjustment, and report
12005 a random SIGTRAP to the user. When the user resumes
12006 the inferior, it will most likely immediately crash
12007 with SIGILL/SIGBUS/SIGSEGV, or worse, get silently
12008 corrupted, because of being resumed e.g., in the
12009 middle of a multi-byte instruction, or skipped a
12010 one-byte instruction. This was actually seen happen
12011 on native x86-linux, and should be less rare on
12012 targets that do not support new thread events, like
12013 remote, due to the heuristic depending on
12016 Mistaking a random SIGTRAP for a breakpoint trap
12017 causes similar symptoms (PC adjustment applied when
12018 it shouldn't), but then again, playing with SIGTRAPs
12019 behind the debugger's back is asking for trouble.
12021 Since hardware watchpoint traps are always
12022 distinguishable from other traps, so we don't need to
12023 apply keep hardware watchpoint moribund locations
12024 around. We simply always ignore hardware watchpoint
12025 traps we can no longer explain. */
12027 process_stratum_target
*proc_target
= nullptr;
12028 for (inferior
*inf
: all_inferiors ())
12029 if (inf
->pspace
== old_loc
->pspace
)
12031 proc_target
= inf
->process_target ();
12034 if (proc_target
!= nullptr)
12035 old_loc
->events_till_retirement
12036 = 3 * (thread_count (proc_target
) + 1);
12038 old_loc
->events_till_retirement
= 1;
12039 old_loc
->owner
= NULL
;
12041 moribund_locations
.push_back (old_loc
);
12045 old_loc
->owner
= NULL
;
12046 decref_bp_location (&old_loc
);
12051 /* Rescan breakpoints at the same address and section, marking the
12052 first one as "first" and any others as "duplicates". This is so
12053 that the bpt instruction is only inserted once. If we have a
12054 permanent breakpoint at the same place as BPT, make that one the
12055 official one, and the rest as duplicates. Permanent breakpoints
12056 are sorted first for the same address.
12058 Do the same for hardware watchpoints, but also considering the
12059 watchpoint's type (regular/access/read) and length. */
12061 bp_loc_first
= NULL
;
12062 wp_loc_first
= NULL
;
12063 awp_loc_first
= NULL
;
12064 rwp_loc_first
= NULL
;
12066 for (bp_location
*loc
: all_bp_locations ())
12068 /* ALL_BP_LOCATIONS bp_location has LOC->OWNER always
12070 struct bp_location
**loc_first_p
;
12071 breakpoint
*b
= loc
->owner
;
12073 if (!unduplicated_should_be_inserted (loc
)
12074 || !bl_address_is_meaningful (loc
)
12075 /* Don't detect duplicate for tracepoint locations because they are
12076 never duplicated. See the comments in field `duplicate' of
12077 `struct bp_location'. */
12078 || is_tracepoint (b
))
12080 /* Clear the condition modification flag. */
12081 loc
->condition_changed
= condition_unchanged
;
12085 if (b
->type
== bp_hardware_watchpoint
)
12086 loc_first_p
= &wp_loc_first
;
12087 else if (b
->type
== bp_read_watchpoint
)
12088 loc_first_p
= &rwp_loc_first
;
12089 else if (b
->type
== bp_access_watchpoint
)
12090 loc_first_p
= &awp_loc_first
;
12092 loc_first_p
= &bp_loc_first
;
12094 if (*loc_first_p
== NULL
12095 || (overlay_debugging
&& loc
->section
!= (*loc_first_p
)->section
)
12096 || !breakpoint_locations_match (loc
, *loc_first_p
))
12098 *loc_first_p
= loc
;
12099 loc
->duplicate
= 0;
12101 if (is_breakpoint (loc
->owner
) && loc
->condition_changed
)
12103 loc
->needs_update
= 1;
12104 /* Clear the condition modification flag. */
12105 loc
->condition_changed
= condition_unchanged
;
12111 /* This and the above ensure the invariant that the first location
12112 is not duplicated, and is the inserted one.
12113 All following are marked as duplicated, and are not inserted. */
12115 swap_insertion (loc
, *loc_first_p
);
12116 loc
->duplicate
= 1;
12118 /* Clear the condition modification flag. */
12119 loc
->condition_changed
= condition_unchanged
;
12122 if (insert_mode
== UGLL_INSERT
|| breakpoints_should_be_inserted_now ())
12124 if (insert_mode
!= UGLL_DONT_INSERT
)
12125 insert_breakpoint_locations ();
12128 /* Even though the caller told us to not insert new
12129 locations, we may still need to update conditions on the
12130 target's side of breakpoints that were already inserted
12131 if the target is evaluating breakpoint conditions. We
12132 only update conditions for locations that are marked
12134 update_inserted_breakpoint_locations ();
12138 if (insert_mode
!= UGLL_DONT_INSERT
)
12139 download_tracepoint_locations ();
12143 breakpoint_retire_moribund (void)
12145 for (int ix
= 0; ix
< moribund_locations
.size (); ++ix
)
12147 struct bp_location
*loc
= moribund_locations
[ix
];
12148 if (--(loc
->events_till_retirement
) == 0)
12150 decref_bp_location (&loc
);
12151 unordered_remove (moribund_locations
, ix
);
12158 update_global_location_list_nothrow (enum ugll_insert_mode insert_mode
)
12163 update_global_location_list (insert_mode
);
12165 catch (const gdb_exception_error
&e
)
12170 /* Clear BKP from a BPS. */
12173 bpstat_remove_bp_location (bpstat bps
, struct breakpoint
*bpt
)
12177 for (bs
= bps
; bs
; bs
= bs
->next
)
12178 if (bs
->breakpoint_at
== bpt
)
12180 bs
->breakpoint_at
= NULL
;
12181 bs
->old_val
= NULL
;
12182 /* bs->commands will be freed later. */
12186 /* Callback for iterate_over_threads. */
12188 bpstat_remove_breakpoint_callback (struct thread_info
*th
, void *data
)
12190 struct breakpoint
*bpt
= (struct breakpoint
*) data
;
12192 bpstat_remove_bp_location (th
->control
.stop_bpstat
, bpt
);
12196 /* Helper for breakpoint and tracepoint breakpoint_ops->mention
12200 say_where (struct breakpoint
*b
)
12202 struct value_print_options opts
;
12204 get_user_print_options (&opts
);
12206 /* i18n: cagney/2005-02-11: Below needs to be merged into a
12208 if (b
->loc
== NULL
)
12210 /* For pending locations, the output differs slightly based
12211 on b->extra_string. If this is non-NULL, it contains either
12212 a condition or dprintf arguments. */
12213 if (b
->extra_string
== NULL
)
12215 printf_filtered (_(" (%s) pending."),
12216 event_location_to_string (b
->location
.get ()));
12218 else if (b
->type
== bp_dprintf
)
12220 printf_filtered (_(" (%s,%s) pending."),
12221 event_location_to_string (b
->location
.get ()),
12226 printf_filtered (_(" (%s %s) pending."),
12227 event_location_to_string (b
->location
.get ()),
12233 if (opts
.addressprint
|| b
->loc
->symtab
== NULL
)
12234 printf_filtered (" at %ps",
12235 styled_string (address_style
.style (),
12236 paddress (b
->loc
->gdbarch
,
12237 b
->loc
->address
)));
12238 if (b
->loc
->symtab
!= NULL
)
12240 /* If there is a single location, we can print the location
12242 if (b
->loc
->next
== NULL
)
12244 const char *filename
12245 = symtab_to_filename_for_display (b
->loc
->symtab
);
12246 printf_filtered (": file %ps, line %d.",
12247 styled_string (file_name_style
.style (),
12249 b
->loc
->line_number
);
12252 /* This is not ideal, but each location may have a
12253 different file name, and this at least reflects the
12254 real situation somewhat. */
12255 printf_filtered (": %s.",
12256 event_location_to_string (b
->location
.get ()));
12261 struct bp_location
*loc
= b
->loc
;
12263 for (; loc
; loc
= loc
->next
)
12265 printf_filtered (" (%d locations)", n
);
12270 bp_location::~bp_location ()
12272 xfree (function_name
);
12275 /* Destructor for the breakpoint base class. */
12277 breakpoint::~breakpoint ()
12279 xfree (this->cond_string
);
12280 xfree (this->extra_string
);
12283 /* See breakpoint.h. */
12285 bp_locations_range
breakpoint::locations ()
12287 return bp_locations_range (this->loc
);
12290 static struct bp_location
*
12291 base_breakpoint_allocate_location (struct breakpoint
*self
)
12293 return new bp_location (self
);
12297 base_breakpoint_re_set (struct breakpoint
*b
)
12299 /* Nothing to re-set. */
12302 #define internal_error_pure_virtual_called() \
12303 gdb_assert_not_reached ("pure virtual function called")
12306 base_breakpoint_insert_location (struct bp_location
*bl
)
12308 internal_error_pure_virtual_called ();
12312 base_breakpoint_remove_location (struct bp_location
*bl
,
12313 enum remove_bp_reason reason
)
12315 internal_error_pure_virtual_called ();
12319 base_breakpoint_breakpoint_hit (const struct bp_location
*bl
,
12320 const address_space
*aspace
,
12322 const struct target_waitstatus
*ws
)
12324 internal_error_pure_virtual_called ();
12328 base_breakpoint_check_status (bpstat bs
)
12333 /* A "works_in_software_mode" breakpoint_ops method that just internal
12337 base_breakpoint_works_in_software_mode (const struct breakpoint
*b
)
12339 internal_error_pure_virtual_called ();
12342 /* A "resources_needed" breakpoint_ops method that just internal
12346 base_breakpoint_resources_needed (const struct bp_location
*bl
)
12348 internal_error_pure_virtual_called ();
12351 static enum print_stop_action
12352 base_breakpoint_print_it (bpstat bs
)
12354 internal_error_pure_virtual_called ();
12358 base_breakpoint_print_one_detail (const struct breakpoint
*self
,
12359 struct ui_out
*uiout
)
12365 base_breakpoint_print_mention (struct breakpoint
*b
)
12367 internal_error_pure_virtual_called ();
12371 base_breakpoint_print_recreate (struct breakpoint
*b
, struct ui_file
*fp
)
12373 internal_error_pure_virtual_called ();
12377 base_breakpoint_create_sals_from_location
12378 (struct event_location
*location
,
12379 struct linespec_result
*canonical
,
12380 enum bptype type_wanted
)
12382 internal_error_pure_virtual_called ();
12386 base_breakpoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12387 struct linespec_result
*c
,
12388 gdb::unique_xmalloc_ptr
<char> cond_string
,
12389 gdb::unique_xmalloc_ptr
<char> extra_string
,
12390 enum bptype type_wanted
,
12391 enum bpdisp disposition
,
12393 int task
, int ignore_count
,
12394 const struct breakpoint_ops
*o
,
12395 int from_tty
, int enabled
,
12396 int internal
, unsigned flags
)
12398 internal_error_pure_virtual_called ();
12401 static std::vector
<symtab_and_line
>
12402 base_breakpoint_decode_location (struct breakpoint
*b
,
12403 struct event_location
*location
,
12404 struct program_space
*search_pspace
)
12406 internal_error_pure_virtual_called ();
12409 /* The default 'explains_signal' method. */
12412 base_breakpoint_explains_signal (struct breakpoint
*b
, enum gdb_signal sig
)
12417 /* The default "after_condition_true" method. */
12420 base_breakpoint_after_condition_true (struct bpstats
*bs
)
12422 /* Nothing to do. */
12425 struct breakpoint_ops base_breakpoint_ops
=
12427 base_breakpoint_allocate_location
,
12428 base_breakpoint_re_set
,
12429 base_breakpoint_insert_location
,
12430 base_breakpoint_remove_location
,
12431 base_breakpoint_breakpoint_hit
,
12432 base_breakpoint_check_status
,
12433 base_breakpoint_resources_needed
,
12434 base_breakpoint_works_in_software_mode
,
12435 base_breakpoint_print_it
,
12437 base_breakpoint_print_one_detail
,
12438 base_breakpoint_print_mention
,
12439 base_breakpoint_print_recreate
,
12440 base_breakpoint_create_sals_from_location
,
12441 base_breakpoint_create_breakpoints_sal
,
12442 base_breakpoint_decode_location
,
12443 base_breakpoint_explains_signal
,
12444 base_breakpoint_after_condition_true
,
12447 /* Default breakpoint_ops methods. */
12450 bkpt_re_set (struct breakpoint
*b
)
12452 /* FIXME: is this still reachable? */
12453 if (breakpoint_event_location_empty_p (b
))
12455 /* Anything without a location can't be re-set. */
12456 delete_breakpoint (b
);
12460 breakpoint_re_set_default (b
);
12464 bkpt_insert_location (struct bp_location
*bl
)
12466 CORE_ADDR addr
= bl
->target_info
.reqstd_address
;
12468 bl
->target_info
.kind
= breakpoint_kind (bl
, &addr
);
12469 bl
->target_info
.placed_address
= addr
;
12471 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12472 return target_insert_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12474 return target_insert_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12478 bkpt_remove_location (struct bp_location
*bl
, enum remove_bp_reason reason
)
12480 if (bl
->loc_type
== bp_loc_hardware_breakpoint
)
12481 return target_remove_hw_breakpoint (bl
->gdbarch
, &bl
->target_info
);
12483 return target_remove_breakpoint (bl
->gdbarch
, &bl
->target_info
, reason
);
12487 bkpt_breakpoint_hit (const struct bp_location
*bl
,
12488 const address_space
*aspace
, CORE_ADDR bp_addr
,
12489 const struct target_waitstatus
*ws
)
12491 if (ws
->kind
!= TARGET_WAITKIND_STOPPED
12492 || ws
->value
.sig
!= GDB_SIGNAL_TRAP
)
12495 if (!breakpoint_address_match (bl
->pspace
->aspace
, bl
->address
,
12499 if (overlay_debugging
/* unmapped overlay section */
12500 && section_is_overlay (bl
->section
)
12501 && !section_is_mapped (bl
->section
))
12508 dprintf_breakpoint_hit (const struct bp_location
*bl
,
12509 const address_space
*aspace
, CORE_ADDR bp_addr
,
12510 const struct target_waitstatus
*ws
)
12512 if (dprintf_style
== dprintf_style_agent
12513 && target_can_run_breakpoint_commands ())
12515 /* An agent-style dprintf never causes a stop. If we see a trap
12516 for this address it must be for a breakpoint that happens to
12517 be set at the same address. */
12521 return bkpt_breakpoint_hit (bl
, aspace
, bp_addr
, ws
);
12525 bkpt_resources_needed (const struct bp_location
*bl
)
12527 gdb_assert (bl
->owner
->type
== bp_hardware_breakpoint
);
12532 static enum print_stop_action
12533 bkpt_print_it (bpstat bs
)
12535 struct breakpoint
*b
;
12536 const struct bp_location
*bl
;
12538 struct ui_out
*uiout
= current_uiout
;
12540 gdb_assert (bs
->bp_location_at
!= NULL
);
12542 bl
= bs
->bp_location_at
.get ();
12543 b
= bs
->breakpoint_at
;
12545 bp_temp
= b
->disposition
== disp_del
;
12546 if (bl
->address
!= bl
->requested_address
)
12547 breakpoint_adjustment_warning (bl
->requested_address
,
12550 annotate_breakpoint (b
->number
);
12551 maybe_print_thread_hit_breakpoint (uiout
);
12553 if (uiout
->is_mi_like_p ())
12555 uiout
->field_string ("reason",
12556 async_reason_lookup (EXEC_ASYNC_BREAKPOINT_HIT
));
12557 uiout
->field_string ("disp", bpdisp_text (b
->disposition
));
12560 uiout
->message ("Temporary breakpoint %pF, ",
12561 signed_field ("bkptno", b
->number
));
12563 uiout
->message ("Breakpoint %pF, ",
12564 signed_field ("bkptno", b
->number
));
12566 return PRINT_SRC_AND_LOC
;
12570 bkpt_print_mention (struct breakpoint
*b
)
12572 if (current_uiout
->is_mi_like_p ())
12577 case bp_breakpoint
:
12578 case bp_gnu_ifunc_resolver
:
12579 if (b
->disposition
== disp_del
)
12580 printf_filtered (_("Temporary breakpoint"));
12582 printf_filtered (_("Breakpoint"));
12583 printf_filtered (_(" %d"), b
->number
);
12584 if (b
->type
== bp_gnu_ifunc_resolver
)
12585 printf_filtered (_(" at gnu-indirect-function resolver"));
12587 case bp_hardware_breakpoint
:
12588 printf_filtered (_("Hardware assisted breakpoint %d"), b
->number
);
12591 printf_filtered (_("Dprintf %d"), b
->number
);
12599 bkpt_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
12601 if (tp
->type
== bp_breakpoint
&& tp
->disposition
== disp_del
)
12602 fprintf_unfiltered (fp
, "tbreak");
12603 else if (tp
->type
== bp_breakpoint
)
12604 fprintf_unfiltered (fp
, "break");
12605 else if (tp
->type
== bp_hardware_breakpoint
12606 && tp
->disposition
== disp_del
)
12607 fprintf_unfiltered (fp
, "thbreak");
12608 else if (tp
->type
== bp_hardware_breakpoint
)
12609 fprintf_unfiltered (fp
, "hbreak");
12611 internal_error (__FILE__
, __LINE__
,
12612 _("unhandled breakpoint type %d"), (int) tp
->type
);
12614 fprintf_unfiltered (fp
, " %s",
12615 event_location_to_string (tp
->location
.get ()));
12617 /* Print out extra_string if this breakpoint is pending. It might
12618 contain, for example, conditions that were set by the user. */
12619 if (tp
->loc
== NULL
&& tp
->extra_string
!= NULL
)
12620 fprintf_unfiltered (fp
, " %s", tp
->extra_string
);
12622 print_recreate_thread (tp
, fp
);
12626 bkpt_create_sals_from_location (struct event_location
*location
,
12627 struct linespec_result
*canonical
,
12628 enum bptype type_wanted
)
12630 create_sals_from_location_default (location
, canonical
, type_wanted
);
12634 bkpt_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12635 struct linespec_result
*canonical
,
12636 gdb::unique_xmalloc_ptr
<char> cond_string
,
12637 gdb::unique_xmalloc_ptr
<char> extra_string
,
12638 enum bptype type_wanted
,
12639 enum bpdisp disposition
,
12641 int task
, int ignore_count
,
12642 const struct breakpoint_ops
*ops
,
12643 int from_tty
, int enabled
,
12644 int internal
, unsigned flags
)
12646 create_breakpoints_sal_default (gdbarch
, canonical
,
12647 std::move (cond_string
),
12648 std::move (extra_string
),
12650 disposition
, thread
, task
,
12651 ignore_count
, ops
, from_tty
,
12652 enabled
, internal
, flags
);
12655 static std::vector
<symtab_and_line
>
12656 bkpt_decode_location (struct breakpoint
*b
,
12657 struct event_location
*location
,
12658 struct program_space
*search_pspace
)
12660 return decode_location_default (b
, location
, search_pspace
);
12663 /* Virtual table for internal breakpoints. */
12666 internal_bkpt_re_set (struct breakpoint
*b
)
12670 /* Delete overlay event and longjmp master breakpoints; they
12671 will be reset later by breakpoint_re_set. */
12672 case bp_overlay_event
:
12673 case bp_longjmp_master
:
12674 case bp_std_terminate_master
:
12675 case bp_exception_master
:
12676 delete_breakpoint (b
);
12679 /* This breakpoint is special, it's set up when the inferior
12680 starts and we really don't want to touch it. */
12681 case bp_shlib_event
:
12683 /* Like bp_shlib_event, this breakpoint type is special. Once
12684 it is set up, we do not want to touch it. */
12685 case bp_thread_event
:
12691 internal_bkpt_check_status (bpstat bs
)
12693 if (bs
->breakpoint_at
->type
== bp_shlib_event
)
12695 /* If requested, stop when the dynamic linker notifies GDB of
12696 events. This allows the user to get control and place
12697 breakpoints in initializer routines for dynamically loaded
12698 objects (among other things). */
12699 bs
->stop
= stop_on_solib_events
;
12700 bs
->print
= stop_on_solib_events
;
12706 static enum print_stop_action
12707 internal_bkpt_print_it (bpstat bs
)
12709 struct breakpoint
*b
;
12711 b
= bs
->breakpoint_at
;
12715 case bp_shlib_event
:
12716 /* Did we stop because the user set the stop_on_solib_events
12717 variable? (If so, we report this as a generic, "Stopped due
12718 to shlib event" message.) */
12719 print_solib_event (0);
12722 case bp_thread_event
:
12723 /* Not sure how we will get here.
12724 GDB should not stop for these breakpoints. */
12725 printf_filtered (_("Thread Event Breakpoint: gdb should not stop!\n"));
12728 case bp_overlay_event
:
12729 /* By analogy with the thread event, GDB should not stop for these. */
12730 printf_filtered (_("Overlay Event Breakpoint: gdb should not stop!\n"));
12733 case bp_longjmp_master
:
12734 /* These should never be enabled. */
12735 printf_filtered (_("Longjmp Master Breakpoint: gdb should not stop!\n"));
12738 case bp_std_terminate_master
:
12739 /* These should never be enabled. */
12740 printf_filtered (_("std::terminate Master Breakpoint: "
12741 "gdb should not stop!\n"));
12744 case bp_exception_master
:
12745 /* These should never be enabled. */
12746 printf_filtered (_("Exception Master Breakpoint: "
12747 "gdb should not stop!\n"));
12751 return PRINT_NOTHING
;
12755 internal_bkpt_print_mention (struct breakpoint
*b
)
12757 /* Nothing to mention. These breakpoints are internal. */
12760 /* Virtual table for momentary breakpoints */
12763 momentary_bkpt_re_set (struct breakpoint
*b
)
12765 /* Keep temporary breakpoints, which can be encountered when we step
12766 over a dlopen call and solib_add is resetting the breakpoints.
12767 Otherwise these should have been blown away via the cleanup chain
12768 or by breakpoint_init_inferior when we rerun the executable. */
12772 momentary_bkpt_check_status (bpstat bs
)
12774 /* Nothing. The point of these breakpoints is causing a stop. */
12777 static enum print_stop_action
12778 momentary_bkpt_print_it (bpstat bs
)
12780 return PRINT_UNKNOWN
;
12784 momentary_bkpt_print_mention (struct breakpoint
*b
)
12786 /* Nothing to mention. These breakpoints are internal. */
12789 /* Ensure INITIATING_FRAME is cleared when no such breakpoint exists.
12791 It gets cleared already on the removal of the first one of such placed
12792 breakpoints. This is OK as they get all removed altogether. */
12794 longjmp_breakpoint::~longjmp_breakpoint ()
12796 thread_info
*tp
= find_thread_global_id (this->thread
);
12799 tp
->initiating_frame
= null_frame_id
;
12802 /* Specific methods for probe breakpoints. */
12805 bkpt_probe_insert_location (struct bp_location
*bl
)
12807 int v
= bkpt_insert_location (bl
);
12811 /* The insertion was successful, now let's set the probe's semaphore
12813 bl
->probe
.prob
->set_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12820 bkpt_probe_remove_location (struct bp_location
*bl
,
12821 enum remove_bp_reason reason
)
12823 /* Let's clear the semaphore before removing the location. */
12824 bl
->probe
.prob
->clear_semaphore (bl
->probe
.objfile
, bl
->gdbarch
);
12826 return bkpt_remove_location (bl
, reason
);
12830 bkpt_probe_create_sals_from_location (struct event_location
*location
,
12831 struct linespec_result
*canonical
,
12832 enum bptype type_wanted
)
12834 struct linespec_sals lsal
;
12836 lsal
.sals
= parse_probes (location
, NULL
, canonical
);
12838 = xstrdup (event_location_to_string (canonical
->location
.get ()));
12839 canonical
->lsals
.push_back (std::move (lsal
));
12842 static std::vector
<symtab_and_line
>
12843 bkpt_probe_decode_location (struct breakpoint
*b
,
12844 struct event_location
*location
,
12845 struct program_space
*search_pspace
)
12847 std::vector
<symtab_and_line
> sals
= parse_probes (location
, search_pspace
, NULL
);
12849 error (_("probe not found"));
12853 /* The breakpoint_ops structure to be used in tracepoints. */
12856 tracepoint_re_set (struct breakpoint
*b
)
12858 breakpoint_re_set_default (b
);
12862 tracepoint_breakpoint_hit (const struct bp_location
*bl
,
12863 const address_space
*aspace
, CORE_ADDR bp_addr
,
12864 const struct target_waitstatus
*ws
)
12866 /* By definition, the inferior does not report stops at
12872 tracepoint_print_one_detail (const struct breakpoint
*self
,
12873 struct ui_out
*uiout
)
12875 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12876 if (!tp
->static_trace_marker_id
.empty ())
12878 gdb_assert (self
->type
== bp_static_tracepoint
);
12880 uiout
->message ("\tmarker id is %pF\n",
12881 string_field ("static-tracepoint-marker-string-id",
12882 tp
->static_trace_marker_id
.c_str ()));
12887 tracepoint_print_mention (struct breakpoint
*b
)
12889 if (current_uiout
->is_mi_like_p ())
12894 case bp_tracepoint
:
12895 printf_filtered (_("Tracepoint"));
12896 printf_filtered (_(" %d"), b
->number
);
12898 case bp_fast_tracepoint
:
12899 printf_filtered (_("Fast tracepoint"));
12900 printf_filtered (_(" %d"), b
->number
);
12902 case bp_static_tracepoint
:
12903 printf_filtered (_("Static tracepoint"));
12904 printf_filtered (_(" %d"), b
->number
);
12907 internal_error (__FILE__
, __LINE__
,
12908 _("unhandled tracepoint type %d"), (int) b
->type
);
12915 tracepoint_print_recreate (struct breakpoint
*self
, struct ui_file
*fp
)
12917 struct tracepoint
*tp
= (struct tracepoint
*) self
;
12919 if (self
->type
== bp_fast_tracepoint
)
12920 fprintf_unfiltered (fp
, "ftrace");
12921 else if (self
->type
== bp_static_tracepoint
)
12922 fprintf_unfiltered (fp
, "strace");
12923 else if (self
->type
== bp_tracepoint
)
12924 fprintf_unfiltered (fp
, "trace");
12926 internal_error (__FILE__
, __LINE__
,
12927 _("unhandled tracepoint type %d"), (int) self
->type
);
12929 fprintf_unfiltered (fp
, " %s",
12930 event_location_to_string (self
->location
.get ()));
12931 print_recreate_thread (self
, fp
);
12933 if (tp
->pass_count
)
12934 fprintf_unfiltered (fp
, " passcount %d\n", tp
->pass_count
);
12938 tracepoint_create_sals_from_location (struct event_location
*location
,
12939 struct linespec_result
*canonical
,
12940 enum bptype type_wanted
)
12942 create_sals_from_location_default (location
, canonical
, type_wanted
);
12946 tracepoint_create_breakpoints_sal (struct gdbarch
*gdbarch
,
12947 struct linespec_result
*canonical
,
12948 gdb::unique_xmalloc_ptr
<char> cond_string
,
12949 gdb::unique_xmalloc_ptr
<char> extra_string
,
12950 enum bptype type_wanted
,
12951 enum bpdisp disposition
,
12953 int task
, int ignore_count
,
12954 const struct breakpoint_ops
*ops
,
12955 int from_tty
, int enabled
,
12956 int internal
, unsigned flags
)
12958 create_breakpoints_sal_default (gdbarch
, canonical
,
12959 std::move (cond_string
),
12960 std::move (extra_string
),
12962 disposition
, thread
, task
,
12963 ignore_count
, ops
, from_tty
,
12964 enabled
, internal
, flags
);
12967 static std::vector
<symtab_and_line
>
12968 tracepoint_decode_location (struct breakpoint
*b
,
12969 struct event_location
*location
,
12970 struct program_space
*search_pspace
)
12972 return decode_location_default (b
, location
, search_pspace
);
12975 struct breakpoint_ops tracepoint_breakpoint_ops
;
12977 /* Virtual table for tracepoints on static probes. */
12980 tracepoint_probe_create_sals_from_location
12981 (struct event_location
*location
,
12982 struct linespec_result
*canonical
,
12983 enum bptype type_wanted
)
12985 /* We use the same method for breakpoint on probes. */
12986 bkpt_probe_create_sals_from_location (location
, canonical
, type_wanted
);
12989 static std::vector
<symtab_and_line
>
12990 tracepoint_probe_decode_location (struct breakpoint
*b
,
12991 struct event_location
*location
,
12992 struct program_space
*search_pspace
)
12994 /* We use the same method for breakpoint on probes. */
12995 return bkpt_probe_decode_location (b
, location
, search_pspace
);
12998 /* Dprintf breakpoint_ops methods. */
13001 dprintf_re_set (struct breakpoint
*b
)
13003 breakpoint_re_set_default (b
);
13005 /* extra_string should never be non-NULL for dprintf. */
13006 gdb_assert (b
->extra_string
!= NULL
);
13008 /* 1 - connect to target 1, that can run breakpoint commands.
13009 2 - create a dprintf, which resolves fine.
13010 3 - disconnect from target 1
13011 4 - connect to target 2, that can NOT run breakpoint commands.
13013 After steps #3/#4, you'll want the dprintf command list to
13014 be updated, because target 1 and 2 may well return different
13015 answers for target_can_run_breakpoint_commands().
13016 Given absence of finer grained resetting, we get to do
13017 it all the time. */
13018 if (b
->extra_string
!= NULL
)
13019 update_dprintf_command_list (b
);
13022 /* Implement the "print_recreate" breakpoint_ops method for dprintf. */
13025 dprintf_print_recreate (struct breakpoint
*tp
, struct ui_file
*fp
)
13027 fprintf_unfiltered (fp
, "dprintf %s,%s",
13028 event_location_to_string (tp
->location
.get ()),
13030 print_recreate_thread (tp
, fp
);
13033 /* Implement the "after_condition_true" breakpoint_ops method for
13036 dprintf's are implemented with regular commands in their command
13037 list, but we run the commands here instead of before presenting the
13038 stop to the user, as dprintf's don't actually cause a stop. This
13039 also makes it so that the commands of multiple dprintfs at the same
13040 address are all handled. */
13043 dprintf_after_condition_true (struct bpstats
*bs
)
13045 struct bpstats tmp_bs
;
13046 struct bpstats
*tmp_bs_p
= &tmp_bs
;
13048 /* dprintf's never cause a stop. This wasn't set in the
13049 check_status hook instead because that would make the dprintf's
13050 condition not be evaluated. */
13053 /* Run the command list here. Take ownership of it instead of
13054 copying. We never want these commands to run later in
13055 bpstat_do_actions, if a breakpoint that causes a stop happens to
13056 be set at same address as this dprintf, or even if running the
13057 commands here throws. */
13058 tmp_bs
.commands
= bs
->commands
;
13059 bs
->commands
= NULL
;
13061 bpstat_do_actions_1 (&tmp_bs_p
);
13063 /* 'tmp_bs.commands' will usually be NULL by now, but
13064 bpstat_do_actions_1 may return early without processing the whole
13068 /* The breakpoint_ops structure to be used on static tracepoints with
13072 strace_marker_create_sals_from_location (struct event_location
*location
,
13073 struct linespec_result
*canonical
,
13074 enum bptype type_wanted
)
13076 struct linespec_sals lsal
;
13077 const char *arg_start
, *arg
;
13079 arg
= arg_start
= get_linespec_location (location
)->spec_string
;
13080 lsal
.sals
= decode_static_tracepoint_spec (&arg
);
13082 std::string
str (arg_start
, arg
- arg_start
);
13083 const char *ptr
= str
.c_str ();
13084 canonical
->location
13085 = new_linespec_location (&ptr
, symbol_name_match_type::FULL
);
13088 = xstrdup (event_location_to_string (canonical
->location
.get ()));
13089 canonical
->lsals
.push_back (std::move (lsal
));
13093 strace_marker_create_breakpoints_sal (struct gdbarch
*gdbarch
,
13094 struct linespec_result
*canonical
,
13095 gdb::unique_xmalloc_ptr
<char> cond_string
,
13096 gdb::unique_xmalloc_ptr
<char> extra_string
,
13097 enum bptype type_wanted
,
13098 enum bpdisp disposition
,
13100 int task
, int ignore_count
,
13101 const struct breakpoint_ops
*ops
,
13102 int from_tty
, int enabled
,
13103 int internal
, unsigned flags
)
13105 const linespec_sals
&lsal
= canonical
->lsals
[0];
13107 /* If the user is creating a static tracepoint by marker id
13108 (strace -m MARKER_ID), then store the sals index, so that
13109 breakpoint_re_set can try to match up which of the newly
13110 found markers corresponds to this one, and, don't try to
13111 expand multiple locations for each sal, given than SALS
13112 already should contain all sals for MARKER_ID. */
13114 for (size_t i
= 0; i
< lsal
.sals
.size (); i
++)
13116 event_location_up location
13117 = copy_event_location (canonical
->location
.get ());
13119 std::unique_ptr
<tracepoint
> tp (new tracepoint ());
13120 init_breakpoint_sal (tp
.get (), gdbarch
, lsal
.sals
[i
],
13121 std::move (location
), NULL
,
13122 std::move (cond_string
),
13123 std::move (extra_string
),
13124 type_wanted
, disposition
,
13125 thread
, task
, ignore_count
, ops
,
13126 from_tty
, enabled
, internal
, flags
,
13127 canonical
->special_display
);
13128 /* Given that its possible to have multiple markers with
13129 the same string id, if the user is creating a static
13130 tracepoint by marker id ("strace -m MARKER_ID"), then
13131 store the sals index, so that breakpoint_re_set can
13132 try to match up which of the newly found markers
13133 corresponds to this one */
13134 tp
->static_trace_marker_id_idx
= i
;
13136 install_breakpoint (internal
, std::move (tp
), 0);
13140 static std::vector
<symtab_and_line
>
13141 strace_marker_decode_location (struct breakpoint
*b
,
13142 struct event_location
*location
,
13143 struct program_space
*search_pspace
)
13145 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13146 const char *s
= get_linespec_location (location
)->spec_string
;
13148 std::vector
<symtab_and_line
> sals
= decode_static_tracepoint_spec (&s
);
13149 if (sals
.size () > tp
->static_trace_marker_id_idx
)
13151 sals
[0] = sals
[tp
->static_trace_marker_id_idx
];
13156 error (_("marker %s not found"), tp
->static_trace_marker_id
.c_str ());
13159 static struct breakpoint_ops strace_marker_breakpoint_ops
;
13162 strace_marker_p (struct breakpoint
*b
)
13164 return b
->ops
== &strace_marker_breakpoint_ops
;
13167 /* Delete a breakpoint and clean up all traces of it in the data
13171 delete_breakpoint (struct breakpoint
*bpt
)
13173 gdb_assert (bpt
!= NULL
);
13175 /* Has this bp already been deleted? This can happen because
13176 multiple lists can hold pointers to bp's. bpstat lists are
13179 One example of this happening is a watchpoint's scope bp. When
13180 the scope bp triggers, we notice that the watchpoint is out of
13181 scope, and delete it. We also delete its scope bp. But the
13182 scope bp is marked "auto-deleting", and is already on a bpstat.
13183 That bpstat is then checked for auto-deleting bp's, which are
13186 A real solution to this problem might involve reference counts in
13187 bp's, and/or giving them pointers back to their referencing
13188 bpstat's, and teaching delete_breakpoint to only free a bp's
13189 storage when no more references were extent. A cheaper bandaid
13191 if (bpt
->type
== bp_none
)
13194 /* At least avoid this stale reference until the reference counting
13195 of breakpoints gets resolved. */
13196 if (bpt
->related_breakpoint
!= bpt
)
13198 struct breakpoint
*related
;
13199 struct watchpoint
*w
;
13201 if (bpt
->type
== bp_watchpoint_scope
)
13202 w
= (struct watchpoint
*) bpt
->related_breakpoint
;
13203 else if (bpt
->related_breakpoint
->type
== bp_watchpoint_scope
)
13204 w
= (struct watchpoint
*) bpt
;
13208 watchpoint_del_at_next_stop (w
);
13210 /* Unlink bpt from the bpt->related_breakpoint ring. */
13211 for (related
= bpt
; related
->related_breakpoint
!= bpt
;
13212 related
= related
->related_breakpoint
);
13213 related
->related_breakpoint
= bpt
->related_breakpoint
;
13214 bpt
->related_breakpoint
= bpt
;
13217 /* watch_command_1 creates a watchpoint but only sets its number if
13218 update_watchpoint succeeds in creating its bp_locations. If there's
13219 a problem in that process, we'll be asked to delete the half-created
13220 watchpoint. In that case, don't announce the deletion. */
13222 gdb::observers::breakpoint_deleted
.notify (bpt
);
13224 if (breakpoint_chain
== bpt
)
13225 breakpoint_chain
= bpt
->next
;
13227 for (breakpoint
*b
: all_breakpoints ())
13228 if (b
->next
== bpt
)
13230 b
->next
= bpt
->next
;
13234 /* Be sure no bpstat's are pointing at the breakpoint after it's
13236 /* FIXME, how can we find all bpstat's? We just check stop_bpstat
13237 in all threads for now. Note that we cannot just remove bpstats
13238 pointing at bpt from the stop_bpstat list entirely, as breakpoint
13239 commands are associated with the bpstat; if we remove it here,
13240 then the later call to bpstat_do_actions (&stop_bpstat); in
13241 event-top.c won't do anything, and temporary breakpoints with
13242 commands won't work. */
13244 iterate_over_threads (bpstat_remove_breakpoint_callback
, bpt
);
13246 /* Now that breakpoint is removed from breakpoint list, update the
13247 global location list. This will remove locations that used to
13248 belong to this breakpoint. Do this before freeing the breakpoint
13249 itself, since remove_breakpoint looks at location's owner. It
13250 might be better design to have location completely
13251 self-contained, but it's not the case now. */
13252 update_global_location_list (UGLL_DONT_INSERT
);
13254 /* On the chance that someone will soon try again to delete this
13255 same bp, we mark it as deleted before freeing its storage. */
13256 bpt
->type
= bp_none
;
13260 /* Iterator function to call a user-provided callback function once
13261 for each of B and its related breakpoints. */
13264 iterate_over_related_breakpoints (struct breakpoint
*b
,
13265 gdb::function_view
<void (breakpoint
*)> function
)
13267 struct breakpoint
*related
;
13272 struct breakpoint
*next
;
13274 /* FUNCTION may delete RELATED. */
13275 next
= related
->related_breakpoint
;
13277 if (next
== related
)
13279 /* RELATED is the last ring entry. */
13280 function (related
);
13282 /* FUNCTION may have deleted it, so we'd never reach back to
13283 B. There's nothing left to do anyway, so just break
13288 function (related
);
13292 while (related
!= b
);
13296 delete_command (const char *arg
, int from_tty
)
13302 int breaks_to_delete
= 0;
13304 /* Delete all breakpoints if no argument. Do not delete
13305 internal breakpoints, these have to be deleted with an
13306 explicit breakpoint number argument. */
13307 for (breakpoint
*b
: all_breakpoints ())
13308 if (user_breakpoint_p (b
))
13310 breaks_to_delete
= 1;
13314 /* Ask user only if there are some breakpoints to delete. */
13316 || (breaks_to_delete
&& query (_("Delete all breakpoints? "))))
13317 for (breakpoint
*b
: all_breakpoints_safe ())
13318 if (user_breakpoint_p (b
))
13319 delete_breakpoint (b
);
13322 map_breakpoint_numbers
13323 (arg
, [&] (breakpoint
*br
)
13325 iterate_over_related_breakpoints (br
, delete_breakpoint
);
13329 /* Return true if all locations of B bound to PSPACE are pending. If
13330 PSPACE is NULL, all locations of all program spaces are
13334 all_locations_are_pending (struct breakpoint
*b
, struct program_space
*pspace
)
13336 for (bp_location
*loc
: b
->locations ())
13337 if ((pspace
== NULL
13338 || loc
->pspace
== pspace
)
13339 && !loc
->shlib_disabled
13340 && !loc
->pspace
->executing_startup
)
13345 /* Subroutine of update_breakpoint_locations to simplify it.
13346 Return non-zero if multiple fns in list LOC have the same name.
13347 Null names are ignored. */
13350 ambiguous_names_p (struct bp_location
*loc
)
13352 struct bp_location
*l
;
13353 htab_up
htab (htab_create_alloc (13, htab_hash_string
, htab_eq_string
, NULL
,
13356 for (l
= loc
; l
!= NULL
; l
= l
->next
)
13359 const char *name
= l
->function_name
;
13361 /* Allow for some names to be NULL, ignore them. */
13365 slot
= (const char **) htab_find_slot (htab
.get (), (const void *) name
,
13367 /* NOTE: We can assume slot != NULL here because xcalloc never
13377 /* When symbols change, it probably means the sources changed as well,
13378 and it might mean the static tracepoint markers are no longer at
13379 the same address or line numbers they used to be at last we
13380 checked. Losing your static tracepoints whenever you rebuild is
13381 undesirable. This function tries to resync/rematch gdb static
13382 tracepoints with the markers on the target, for static tracepoints
13383 that have not been set by marker id. Static tracepoint that have
13384 been set by marker id are reset by marker id in breakpoint_re_set.
13387 1) For a tracepoint set at a specific address, look for a marker at
13388 the old PC. If one is found there, assume to be the same marker.
13389 If the name / string id of the marker found is different from the
13390 previous known name, assume that means the user renamed the marker
13391 in the sources, and output a warning.
13393 2) For a tracepoint set at a given line number, look for a marker
13394 at the new address of the old line number. If one is found there,
13395 assume to be the same marker. If the name / string id of the
13396 marker found is different from the previous known name, assume that
13397 means the user renamed the marker in the sources, and output a
13400 3) If a marker is no longer found at the same address or line, it
13401 may mean the marker no longer exists. But it may also just mean
13402 the code changed a bit. Maybe the user added a few lines of code
13403 that made the marker move up or down (in line number terms). Ask
13404 the target for info about the marker with the string id as we knew
13405 it. If found, update line number and address in the matching
13406 static tracepoint. This will get confused if there's more than one
13407 marker with the same ID (possible in UST, although unadvised
13408 precisely because it confuses tools). */
13410 static struct symtab_and_line
13411 update_static_tracepoint (struct breakpoint
*b
, struct symtab_and_line sal
)
13413 struct tracepoint
*tp
= (struct tracepoint
*) b
;
13414 struct static_tracepoint_marker marker
;
13419 find_line_pc (sal
.symtab
, sal
.line
, &pc
);
13421 if (target_static_tracepoint_marker_at (pc
, &marker
))
13423 if (tp
->static_trace_marker_id
!= marker
.str_id
)
13424 warning (_("static tracepoint %d changed probed marker from %s to %s"),
13425 b
->number
, tp
->static_trace_marker_id
.c_str (),
13426 marker
.str_id
.c_str ());
13428 tp
->static_trace_marker_id
= std::move (marker
.str_id
);
13433 /* Old marker wasn't found on target at lineno. Try looking it up
13435 if (!sal
.explicit_pc
13437 && sal
.symtab
!= NULL
13438 && !tp
->static_trace_marker_id
.empty ())
13440 std::vector
<static_tracepoint_marker
> markers
13441 = target_static_tracepoint_markers_by_strid
13442 (tp
->static_trace_marker_id
.c_str ());
13444 if (!markers
.empty ())
13446 struct symbol
*sym
;
13447 struct static_tracepoint_marker
*tpmarker
;
13448 struct ui_out
*uiout
= current_uiout
;
13449 struct explicit_location explicit_loc
;
13451 tpmarker
= &markers
[0];
13453 tp
->static_trace_marker_id
= std::move (tpmarker
->str_id
);
13455 warning (_("marker for static tracepoint %d (%s) not "
13456 "found at previous line number"),
13457 b
->number
, tp
->static_trace_marker_id
.c_str ());
13459 symtab_and_line sal2
= find_pc_line (tpmarker
->address
, 0);
13460 sym
= find_pc_sect_function (tpmarker
->address
, NULL
);
13461 uiout
->text ("Now in ");
13464 uiout
->field_string ("func", sym
->print_name (),
13465 function_name_style
.style ());
13466 uiout
->text (" at ");
13468 uiout
->field_string ("file",
13469 symtab_to_filename_for_display (sal2
.symtab
),
13470 file_name_style
.style ());
13473 if (uiout
->is_mi_like_p ())
13475 const char *fullname
= symtab_to_fullname (sal2
.symtab
);
13477 uiout
->field_string ("fullname", fullname
);
13480 uiout
->field_signed ("line", sal2
.line
);
13481 uiout
->text ("\n");
13483 b
->loc
->line_number
= sal2
.line
;
13484 b
->loc
->symtab
= sym
!= NULL
? sal2
.symtab
: NULL
;
13486 b
->location
.reset (NULL
);
13487 initialize_explicit_location (&explicit_loc
);
13488 explicit_loc
.source_filename
13489 = ASTRDUP (symtab_to_filename_for_display (sal2
.symtab
));
13490 explicit_loc
.line_offset
.offset
= b
->loc
->line_number
;
13491 explicit_loc
.line_offset
.sign
= LINE_OFFSET_NONE
;
13492 b
->location
= new_explicit_location (&explicit_loc
);
13494 /* Might be nice to check if function changed, and warn if
13501 /* Returns 1 iff locations A and B are sufficiently same that
13502 we don't need to report breakpoint as changed. */
13505 locations_are_equal (struct bp_location
*a
, struct bp_location
*b
)
13509 if (a
->address
!= b
->address
)
13512 if (a
->shlib_disabled
!= b
->shlib_disabled
)
13515 if (a
->enabled
!= b
->enabled
)
13518 if (a
->disabled_by_cond
!= b
->disabled_by_cond
)
13525 if ((a
== NULL
) != (b
== NULL
))
13531 /* Split all locations of B that are bound to PSPACE out of B's
13532 location list to a separate list and return that list's head. If
13533 PSPACE is NULL, hoist out all locations of B. */
13535 static struct bp_location
*
13536 hoist_existing_locations (struct breakpoint
*b
, struct program_space
*pspace
)
13538 struct bp_location head
;
13539 struct bp_location
*i
= b
->loc
;
13540 struct bp_location
**i_link
= &b
->loc
;
13541 struct bp_location
*hoisted
= &head
;
13543 if (pspace
== NULL
)
13554 if (i
->pspace
== pspace
)
13569 /* Create new breakpoint locations for B (a hardware or software
13570 breakpoint) based on SALS and SALS_END. If SALS_END.NELTS is not
13571 zero, then B is a ranged breakpoint. Only recreates locations for
13572 FILTER_PSPACE. Locations of other program spaces are left
13576 update_breakpoint_locations (struct breakpoint
*b
,
13577 struct program_space
*filter_pspace
,
13578 gdb::array_view
<const symtab_and_line
> sals
,
13579 gdb::array_view
<const symtab_and_line
> sals_end
)
13581 struct bp_location
*existing_locations
;
13583 if (!sals_end
.empty () && (sals
.size () != 1 || sals_end
.size () != 1))
13585 /* Ranged breakpoints have only one start location and one end
13587 b
->enable_state
= bp_disabled
;
13588 printf_unfiltered (_("Could not reset ranged breakpoint %d: "
13589 "multiple locations found\n"),
13594 /* If there's no new locations, and all existing locations are
13595 pending, don't do anything. This optimizes the common case where
13596 all locations are in the same shared library, that was unloaded.
13597 We'd like to retain the location, so that when the library is
13598 loaded again, we don't loose the enabled/disabled status of the
13599 individual locations. */
13600 if (all_locations_are_pending (b
, filter_pspace
) && sals
.empty ())
13603 existing_locations
= hoist_existing_locations (b
, filter_pspace
);
13605 for (const auto &sal
: sals
)
13607 struct bp_location
*new_loc
;
13609 switch_to_program_space_and_thread (sal
.pspace
);
13611 new_loc
= add_location_to_breakpoint (b
, &sal
);
13613 /* Reparse conditions, they might contain references to the
13615 if (b
->cond_string
!= NULL
)
13619 s
= b
->cond_string
;
13622 new_loc
->cond
= parse_exp_1 (&s
, sal
.pc
,
13623 block_for_pc (sal
.pc
),
13626 catch (const gdb_exception_error
&e
)
13628 new_loc
->disabled_by_cond
= true;
13632 if (!sals_end
.empty ())
13634 CORE_ADDR end
= find_breakpoint_range_end (sals_end
[0]);
13636 new_loc
->length
= end
- sals
[0].pc
+ 1;
13640 /* If possible, carry over 'disable' status from existing
13643 struct bp_location
*e
= existing_locations
;
13644 /* If there are multiple breakpoints with the same function name,
13645 e.g. for inline functions, comparing function names won't work.
13646 Instead compare pc addresses; this is just a heuristic as things
13647 may have moved, but in practice it gives the correct answer
13648 often enough until a better solution is found. */
13649 int have_ambiguous_names
= ambiguous_names_p (b
->loc
);
13651 for (; e
; e
= e
->next
)
13653 if ((!e
->enabled
|| e
->disabled_by_cond
) && e
->function_name
)
13655 if (have_ambiguous_names
)
13657 for (bp_location
*l
: b
->locations ())
13659 /* Ignore software vs hardware location type at
13660 this point, because with "set breakpoint
13661 auto-hw", after a re-set, locations that were
13662 hardware can end up as software, or vice versa.
13663 As mentioned above, this is an heuristic and in
13664 practice should give the correct answer often
13666 if (breakpoint_locations_match (e
, l
, true))
13668 l
->enabled
= e
->enabled
;
13669 l
->disabled_by_cond
= e
->disabled_by_cond
;
13676 for (bp_location
*l
: b
->locations ())
13677 if (l
->function_name
13678 && strcmp (e
->function_name
, l
->function_name
) == 0)
13680 l
->enabled
= e
->enabled
;
13681 l
->disabled_by_cond
= e
->disabled_by_cond
;
13689 if (!locations_are_equal (existing_locations
, b
->loc
))
13690 gdb::observers::breakpoint_modified
.notify (b
);
13693 /* Find the SaL locations corresponding to the given LOCATION.
13694 On return, FOUND will be 1 if any SaL was found, zero otherwise. */
13696 static std::vector
<symtab_and_line
>
13697 location_to_sals (struct breakpoint
*b
, struct event_location
*location
,
13698 struct program_space
*search_pspace
, int *found
)
13700 struct gdb_exception exception
;
13702 gdb_assert (b
->ops
!= NULL
);
13704 std::vector
<symtab_and_line
> sals
;
13708 sals
= b
->ops
->decode_location (b
, location
, search_pspace
);
13710 catch (gdb_exception_error
&e
)
13712 int not_found_and_ok
= 0;
13714 /* For pending breakpoints, it's expected that parsing will
13715 fail until the right shared library is loaded. User has
13716 already told to create pending breakpoints and don't need
13717 extra messages. If breakpoint is in bp_shlib_disabled
13718 state, then user already saw the message about that
13719 breakpoint being disabled, and don't want to see more
13721 if (e
.error
== NOT_FOUND_ERROR
13722 && (b
->condition_not_parsed
13724 && search_pspace
!= NULL
13725 && b
->loc
->pspace
!= search_pspace
)
13726 || (b
->loc
&& b
->loc
->shlib_disabled
)
13727 || (b
->loc
&& b
->loc
->pspace
->executing_startup
)
13728 || b
->enable_state
== bp_disabled
))
13729 not_found_and_ok
= 1;
13731 if (!not_found_and_ok
)
13733 /* We surely don't want to warn about the same breakpoint
13734 10 times. One solution, implemented here, is disable
13735 the breakpoint on error. Another solution would be to
13736 have separate 'warning emitted' flag. Since this
13737 happens only when a binary has changed, I don't know
13738 which approach is better. */
13739 b
->enable_state
= bp_disabled
;
13743 exception
= std::move (e
);
13746 if (exception
.reason
== 0 || exception
.error
!= NOT_FOUND_ERROR
)
13748 for (auto &sal
: sals
)
13749 resolve_sal_pc (&sal
);
13750 if (b
->condition_not_parsed
&& b
->extra_string
!= NULL
)
13752 char *cond_string
, *extra_string
;
13755 find_condition_and_thread_for_sals (sals
, b
->extra_string
,
13756 &cond_string
, &thread
,
13757 &task
, &extra_string
);
13758 gdb_assert (b
->cond_string
== NULL
);
13760 b
->cond_string
= cond_string
;
13761 b
->thread
= thread
;
13765 xfree (b
->extra_string
);
13766 b
->extra_string
= extra_string
;
13768 b
->condition_not_parsed
= 0;
13771 if (b
->type
== bp_static_tracepoint
&& !strace_marker_p (b
))
13772 sals
[0] = update_static_tracepoint (b
, sals
[0]);
13782 /* The default re_set method, for typical hardware or software
13783 breakpoints. Reevaluate the breakpoint and recreate its
13787 breakpoint_re_set_default (struct breakpoint
*b
)
13789 struct program_space
*filter_pspace
= current_program_space
;
13790 std::vector
<symtab_and_line
> expanded
, expanded_end
;
13793 std::vector
<symtab_and_line
> sals
= location_to_sals (b
, b
->location
.get (),
13794 filter_pspace
, &found
);
13796 expanded
= std::move (sals
);
13798 if (b
->location_range_end
!= NULL
)
13800 std::vector
<symtab_and_line
> sals_end
13801 = location_to_sals (b
, b
->location_range_end
.get (),
13802 filter_pspace
, &found
);
13804 expanded_end
= std::move (sals_end
);
13807 update_breakpoint_locations (b
, filter_pspace
, expanded
, expanded_end
);
13810 /* Default method for creating SALs from an address string. It basically
13811 calls parse_breakpoint_sals. Return 1 for success, zero for failure. */
13814 create_sals_from_location_default (struct event_location
*location
,
13815 struct linespec_result
*canonical
,
13816 enum bptype type_wanted
)
13818 parse_breakpoint_sals (location
, canonical
);
13821 /* Call create_breakpoints_sal for the given arguments. This is the default
13822 function for the `create_breakpoints_sal' method of
13826 create_breakpoints_sal_default (struct gdbarch
*gdbarch
,
13827 struct linespec_result
*canonical
,
13828 gdb::unique_xmalloc_ptr
<char> cond_string
,
13829 gdb::unique_xmalloc_ptr
<char> extra_string
,
13830 enum bptype type_wanted
,
13831 enum bpdisp disposition
,
13833 int task
, int ignore_count
,
13834 const struct breakpoint_ops
*ops
,
13835 int from_tty
, int enabled
,
13836 int internal
, unsigned flags
)
13838 create_breakpoints_sal (gdbarch
, canonical
,
13839 std::move (cond_string
),
13840 std::move (extra_string
),
13841 type_wanted
, disposition
,
13842 thread
, task
, ignore_count
, ops
, from_tty
,
13843 enabled
, internal
, flags
);
13846 /* Decode the line represented by S by calling decode_line_full. This is the
13847 default function for the `decode_location' method of breakpoint_ops. */
13849 static std::vector
<symtab_and_line
>
13850 decode_location_default (struct breakpoint
*b
,
13851 struct event_location
*location
,
13852 struct program_space
*search_pspace
)
13854 struct linespec_result canonical
;
13856 decode_line_full (location
, DECODE_LINE_FUNFIRSTLINE
, search_pspace
,
13857 NULL
, 0, &canonical
, multiple_symbols_all
,
13860 /* We should get 0 or 1 resulting SALs. */
13861 gdb_assert (canonical
.lsals
.size () < 2);
13863 if (!canonical
.lsals
.empty ())
13865 const linespec_sals
&lsal
= canonical
.lsals
[0];
13866 return std::move (lsal
.sals
);
13871 /* Reset a breakpoint. */
13874 breakpoint_re_set_one (breakpoint
*b
)
13876 input_radix
= b
->input_radix
;
13877 set_language (b
->language
);
13879 b
->ops
->re_set (b
);
13882 /* Re-set breakpoint locations for the current program space.
13883 Locations bound to other program spaces are left untouched. */
13886 breakpoint_re_set (void)
13889 scoped_restore_current_language save_language
;
13890 scoped_restore save_input_radix
= make_scoped_restore (&input_radix
);
13891 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
13893 /* breakpoint_re_set_one sets the current_language to the language
13894 of the breakpoint it is resetting (see prepare_re_set_context)
13895 before re-evaluating the breakpoint's location. This change can
13896 unfortunately get undone by accident if the language_mode is set
13897 to auto, and we either switch frames, or more likely in this context,
13898 we select the current frame.
13900 We prevent this by temporarily turning the language_mode to
13901 language_mode_manual. We restore it once all breakpoints
13902 have been reset. */
13903 scoped_restore save_language_mode
= make_scoped_restore (&language_mode
);
13904 language_mode
= language_mode_manual
;
13906 /* Note: we must not try to insert locations until after all
13907 breakpoints have been re-set. Otherwise, e.g., when re-setting
13908 breakpoint 1, we'd insert the locations of breakpoint 2, which
13909 hadn't been re-set yet, and thus may have stale locations. */
13911 for (breakpoint
*b
: all_breakpoints_safe ())
13915 breakpoint_re_set_one (b
);
13917 catch (const gdb_exception
&ex
)
13919 exception_fprintf (gdb_stderr
, ex
,
13920 "Error in re-setting breakpoint %d: ",
13925 jit_breakpoint_re_set ();
13928 create_overlay_event_breakpoint ();
13929 create_longjmp_master_breakpoint ();
13930 create_std_terminate_master_breakpoint ();
13931 create_exception_master_breakpoint ();
13933 /* Now we can insert. */
13934 update_global_location_list (UGLL_MAY_INSERT
);
13937 /* Reset the thread number of this breakpoint:
13939 - If the breakpoint is for all threads, leave it as-is.
13940 - Else, reset it to the current thread for inferior_ptid. */
13942 breakpoint_re_set_thread (struct breakpoint
*b
)
13944 if (b
->thread
!= -1)
13946 b
->thread
= inferior_thread ()->global_num
;
13948 /* We're being called after following a fork. The new fork is
13949 selected as current, and unless this was a vfork will have a
13950 different program space from the original thread. Reset that
13952 b
->loc
->pspace
= current_program_space
;
13956 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
13957 If from_tty is nonzero, it prints a message to that effect,
13958 which ends with a period (no newline). */
13961 set_ignore_count (int bptnum
, int count
, int from_tty
)
13966 for (breakpoint
*b
: all_breakpoints ())
13967 if (b
->number
== bptnum
)
13969 if (is_tracepoint (b
))
13971 if (from_tty
&& count
!= 0)
13972 printf_filtered (_("Ignore count ignored for tracepoint %d."),
13977 b
->ignore_count
= count
;
13981 printf_filtered (_("Will stop next time "
13982 "breakpoint %d is reached."),
13984 else if (count
== 1)
13985 printf_filtered (_("Will ignore next crossing of breakpoint %d."),
13988 printf_filtered (_("Will ignore next %d "
13989 "crossings of breakpoint %d."),
13992 gdb::observers::breakpoint_modified
.notify (b
);
13996 error (_("No breakpoint number %d."), bptnum
);
13999 /* Command to set ignore-count of breakpoint N to COUNT. */
14002 ignore_command (const char *args
, int from_tty
)
14004 const char *p
= args
;
14008 error_no_arg (_("a breakpoint number"));
14010 num
= get_number (&p
);
14012 error (_("bad breakpoint number: '%s'"), args
);
14014 error (_("Second argument (specified ignore-count) is missing."));
14016 set_ignore_count (num
,
14017 longest_to_int (value_as_long (parse_and_eval (p
))),
14020 printf_filtered ("\n");
14024 /* Call FUNCTION on each of the breakpoints with numbers in the range
14025 defined by BP_NUM_RANGE (an inclusive range). */
14028 map_breakpoint_number_range (std::pair
<int, int> bp_num_range
,
14029 gdb::function_view
<void (breakpoint
*)> function
)
14031 if (bp_num_range
.first
== 0)
14033 warning (_("bad breakpoint number at or near '%d'"),
14034 bp_num_range
.first
);
14038 for (int i
= bp_num_range
.first
; i
<= bp_num_range
.second
; i
++)
14040 bool match
= false;
14042 for (breakpoint
*b
: all_breakpoints_safe ())
14043 if (b
->number
== i
)
14050 printf_unfiltered (_("No breakpoint number %d.\n"), i
);
14055 /* Call FUNCTION on each of the breakpoints whose numbers are given in
14059 map_breakpoint_numbers (const char *args
,
14060 gdb::function_view
<void (breakpoint
*)> function
)
14062 if (args
== NULL
|| *args
== '\0')
14063 error_no_arg (_("one or more breakpoint numbers"));
14065 number_or_range_parser
parser (args
);
14067 while (!parser
.finished ())
14069 int num
= parser
.get_number ();
14070 map_breakpoint_number_range (std::make_pair (num
, num
), function
);
14074 /* Return the breakpoint location structure corresponding to the
14075 BP_NUM and LOC_NUM values. */
14077 static struct bp_location
*
14078 find_location_by_number (int bp_num
, int loc_num
)
14080 breakpoint
*b
= get_breakpoint (bp_num
);
14082 if (!b
|| b
->number
!= bp_num
)
14083 error (_("Bad breakpoint number '%d'"), bp_num
);
14086 error (_("Bad breakpoint location number '%d'"), loc_num
);
14089 for (bp_location
*loc
: b
->locations ())
14090 if (++n
== loc_num
)
14093 error (_("Bad breakpoint location number '%d'"), loc_num
);
14096 /* Modes of operation for extract_bp_num. */
14097 enum class extract_bp_kind
14099 /* Extracting a breakpoint number. */
14102 /* Extracting a location number. */
14106 /* Extract a breakpoint or location number (as determined by KIND)
14107 from the string starting at START. TRAILER is a character which
14108 can be found after the number. If you don't want a trailer, use
14109 '\0'. If END_OUT is not NULL, it is set to point after the parsed
14110 string. This always returns a positive integer. */
14113 extract_bp_num (extract_bp_kind kind
, const char *start
,
14114 int trailer
, const char **end_out
= NULL
)
14116 const char *end
= start
;
14117 int num
= get_number_trailer (&end
, trailer
);
14119 error (kind
== extract_bp_kind::bp
14120 ? _("Negative breakpoint number '%.*s'")
14121 : _("Negative breakpoint location number '%.*s'"),
14122 int (end
- start
), start
);
14124 error (kind
== extract_bp_kind::bp
14125 ? _("Bad breakpoint number '%.*s'")
14126 : _("Bad breakpoint location number '%.*s'"),
14127 int (end
- start
), start
);
14129 if (end_out
!= NULL
)
14134 /* Extract a breakpoint or location range (as determined by KIND) in
14135 the form NUM1-NUM2 stored at &ARG[arg_offset]. Returns a std::pair
14136 representing the (inclusive) range. The returned pair's elements
14137 are always positive integers. */
14139 static std::pair
<int, int>
14140 extract_bp_or_bp_range (extract_bp_kind kind
,
14141 const std::string
&arg
,
14142 std::string::size_type arg_offset
)
14144 std::pair
<int, int> range
;
14145 const char *bp_loc
= &arg
[arg_offset
];
14146 std::string::size_type dash
= arg
.find ('-', arg_offset
);
14147 if (dash
!= std::string::npos
)
14149 /* bp_loc is a range (x-z). */
14150 if (arg
.length () == dash
+ 1)
14151 error (kind
== extract_bp_kind::bp
14152 ? _("Bad breakpoint number at or near: '%s'")
14153 : _("Bad breakpoint location number at or near: '%s'"),
14157 const char *start_first
= bp_loc
;
14158 const char *start_second
= &arg
[dash
+ 1];
14159 range
.first
= extract_bp_num (kind
, start_first
, '-');
14160 range
.second
= extract_bp_num (kind
, start_second
, '\0', &end
);
14162 if (range
.first
> range
.second
)
14163 error (kind
== extract_bp_kind::bp
14164 ? _("Inverted breakpoint range at '%.*s'")
14165 : _("Inverted breakpoint location range at '%.*s'"),
14166 int (end
- start_first
), start_first
);
14170 /* bp_loc is a single value. */
14171 range
.first
= extract_bp_num (kind
, bp_loc
, '\0');
14172 range
.second
= range
.first
;
14177 /* Extract the breakpoint/location range specified by ARG. Returns
14178 the breakpoint range in BP_NUM_RANGE, and the location range in
14181 ARG may be in any of the following forms:
14183 x where 'x' is a breakpoint number.
14184 x-y where 'x' and 'y' specify a breakpoint numbers range.
14185 x.y where 'x' is a breakpoint number and 'y' a location number.
14186 x.y-z where 'x' is a breakpoint number and 'y' and 'z' specify a
14187 location number range.
14191 extract_bp_number_and_location (const std::string
&arg
,
14192 std::pair
<int, int> &bp_num_range
,
14193 std::pair
<int, int> &bp_loc_range
)
14195 std::string::size_type dot
= arg
.find ('.');
14197 if (dot
!= std::string::npos
)
14199 /* Handle 'x.y' and 'x.y-z' cases. */
14201 if (arg
.length () == dot
+ 1 || dot
== 0)
14202 error (_("Bad breakpoint number at or near: '%s'"), arg
.c_str ());
14205 = extract_bp_num (extract_bp_kind::bp
, arg
.c_str (), '.');
14206 bp_num_range
.second
= bp_num_range
.first
;
14208 bp_loc_range
= extract_bp_or_bp_range (extract_bp_kind::loc
,
14213 /* Handle x and x-y cases. */
14215 bp_num_range
= extract_bp_or_bp_range (extract_bp_kind::bp
, arg
, 0);
14216 bp_loc_range
.first
= 0;
14217 bp_loc_range
.second
= 0;
14221 /* Enable or disable a breakpoint location BP_NUM.LOC_NUM. ENABLE
14222 specifies whether to enable or disable. */
14225 enable_disable_bp_num_loc (int bp_num
, int loc_num
, bool enable
)
14227 struct bp_location
*loc
= find_location_by_number (bp_num
, loc_num
);
14230 if (loc
->disabled_by_cond
&& enable
)
14231 error (_("Breakpoint %d's condition is invalid at location %d, "
14232 "cannot enable."), bp_num
, loc_num
);
14234 if (loc
->enabled
!= enable
)
14236 loc
->enabled
= enable
;
14237 mark_breakpoint_location_modified (loc
);
14239 if (target_supports_enable_disable_tracepoint ()
14240 && current_trace_status ()->running
&& loc
->owner
14241 && is_tracepoint (loc
->owner
))
14242 target_disable_tracepoint (loc
);
14244 update_global_location_list (UGLL_DONT_INSERT
);
14246 gdb::observers::breakpoint_modified
.notify (loc
->owner
);
14249 /* Enable or disable a range of breakpoint locations. BP_NUM is the
14250 number of the breakpoint, and BP_LOC_RANGE specifies the
14251 (inclusive) range of location numbers of that breakpoint to
14252 enable/disable. ENABLE specifies whether to enable or disable the
14256 enable_disable_breakpoint_location_range (int bp_num
,
14257 std::pair
<int, int> &bp_loc_range
,
14260 for (int i
= bp_loc_range
.first
; i
<= bp_loc_range
.second
; i
++)
14261 enable_disable_bp_num_loc (bp_num
, i
, enable
);
14264 /* Set ignore-count of breakpoint number BPTNUM to COUNT.
14265 If from_tty is nonzero, it prints a message to that effect,
14266 which ends with a period (no newline). */
14269 disable_breakpoint (struct breakpoint
*bpt
)
14271 /* Never disable a watchpoint scope breakpoint; we want to
14272 hit them when we leave scope so we can delete both the
14273 watchpoint and its scope breakpoint at that time. */
14274 if (bpt
->type
== bp_watchpoint_scope
)
14277 bpt
->enable_state
= bp_disabled
;
14279 /* Mark breakpoint locations modified. */
14280 mark_breakpoint_modified (bpt
);
14282 if (target_supports_enable_disable_tracepoint ()
14283 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14285 for (bp_location
*location
: bpt
->locations ())
14286 target_disable_tracepoint (location
);
14289 update_global_location_list (UGLL_DONT_INSERT
);
14291 gdb::observers::breakpoint_modified
.notify (bpt
);
14294 /* Enable or disable the breakpoint(s) or breakpoint location(s)
14295 specified in ARGS. ARGS may be in any of the formats handled by
14296 extract_bp_number_and_location. ENABLE specifies whether to enable
14297 or disable the breakpoints/locations. */
14300 enable_disable_command (const char *args
, int from_tty
, bool enable
)
14304 for (breakpoint
*bpt
: all_breakpoints ())
14305 if (user_breakpoint_p (bpt
))
14308 enable_breakpoint (bpt
);
14310 disable_breakpoint (bpt
);
14315 std::string num
= extract_arg (&args
);
14317 while (!num
.empty ())
14319 std::pair
<int, int> bp_num_range
, bp_loc_range
;
14321 extract_bp_number_and_location (num
, bp_num_range
, bp_loc_range
);
14323 if (bp_loc_range
.first
== bp_loc_range
.second
14324 && bp_loc_range
.first
== 0)
14326 /* Handle breakpoint ids with formats 'x' or 'x-z'. */
14327 map_breakpoint_number_range (bp_num_range
,
14329 ? enable_breakpoint
14330 : disable_breakpoint
);
14334 /* Handle breakpoint ids with formats 'x.y' or
14336 enable_disable_breakpoint_location_range
14337 (bp_num_range
.first
, bp_loc_range
, enable
);
14339 num
= extract_arg (&args
);
14344 /* The disable command disables the specified breakpoints/locations
14345 (or all defined breakpoints) so they're no longer effective in
14346 stopping the inferior. ARGS may be in any of the forms defined in
14347 extract_bp_number_and_location. */
14350 disable_command (const char *args
, int from_tty
)
14352 enable_disable_command (args
, from_tty
, false);
14356 enable_breakpoint_disp (struct breakpoint
*bpt
, enum bpdisp disposition
,
14359 int target_resources_ok
;
14361 if (bpt
->type
== bp_hardware_breakpoint
)
14364 i
= hw_breakpoint_used_count ();
14365 target_resources_ok
=
14366 target_can_use_hardware_watchpoint (bp_hardware_breakpoint
,
14368 if (target_resources_ok
== 0)
14369 error (_("No hardware breakpoint support in the target."));
14370 else if (target_resources_ok
< 0)
14371 error (_("Hardware breakpoints used exceeds limit."));
14374 if (is_watchpoint (bpt
))
14376 /* Initialize it just to avoid a GCC false warning. */
14377 enum enable_state orig_enable_state
= bp_disabled
;
14381 struct watchpoint
*w
= (struct watchpoint
*) bpt
;
14383 orig_enable_state
= bpt
->enable_state
;
14384 bpt
->enable_state
= bp_enabled
;
14385 update_watchpoint (w
, 1 /* reparse */);
14387 catch (const gdb_exception
&e
)
14389 bpt
->enable_state
= orig_enable_state
;
14390 exception_fprintf (gdb_stderr
, e
, _("Cannot enable watchpoint %d: "),
14396 bpt
->enable_state
= bp_enabled
;
14398 /* Mark breakpoint locations modified. */
14399 mark_breakpoint_modified (bpt
);
14401 if (target_supports_enable_disable_tracepoint ()
14402 && current_trace_status ()->running
&& is_tracepoint (bpt
))
14404 for (bp_location
*location
: bpt
->locations ())
14405 target_enable_tracepoint (location
);
14408 bpt
->disposition
= disposition
;
14409 bpt
->enable_count
= count
;
14410 update_global_location_list (UGLL_MAY_INSERT
);
14412 gdb::observers::breakpoint_modified
.notify (bpt
);
14417 enable_breakpoint (struct breakpoint
*bpt
)
14419 enable_breakpoint_disp (bpt
, bpt
->disposition
, 0);
14422 /* The enable command enables the specified breakpoints/locations (or
14423 all defined breakpoints) so they once again become (or continue to
14424 be) effective in stopping the inferior. ARGS may be in any of the
14425 forms defined in extract_bp_number_and_location. */
14428 enable_command (const char *args
, int from_tty
)
14430 enable_disable_command (args
, from_tty
, true);
14434 enable_once_command (const char *args
, int from_tty
)
14436 map_breakpoint_numbers
14437 (args
, [&] (breakpoint
*b
)
14439 iterate_over_related_breakpoints
14440 (b
, [&] (breakpoint
*bpt
)
14442 enable_breakpoint_disp (bpt
, disp_disable
, 1);
14448 enable_count_command (const char *args
, int from_tty
)
14453 error_no_arg (_("hit count"));
14455 count
= get_number (&args
);
14457 map_breakpoint_numbers
14458 (args
, [&] (breakpoint
*b
)
14460 iterate_over_related_breakpoints
14461 (b
, [&] (breakpoint
*bpt
)
14463 enable_breakpoint_disp (bpt
, disp_disable
, count
);
14469 enable_delete_command (const char *args
, int from_tty
)
14471 map_breakpoint_numbers
14472 (args
, [&] (breakpoint
*b
)
14474 iterate_over_related_breakpoints
14475 (b
, [&] (breakpoint
*bpt
)
14477 enable_breakpoint_disp (bpt
, disp_del
, 1);
14482 /* Invalidate last known value of any hardware watchpoint if
14483 the memory which that value represents has been written to by
14487 invalidate_bp_value_on_memory_change (struct inferior
*inferior
,
14488 CORE_ADDR addr
, ssize_t len
,
14489 const bfd_byte
*data
)
14491 for (breakpoint
*bp
: all_breakpoints ())
14492 if (bp
->enable_state
== bp_enabled
14493 && bp
->type
== bp_hardware_watchpoint
)
14495 struct watchpoint
*wp
= (struct watchpoint
*) bp
;
14497 if (wp
->val_valid
&& wp
->val
!= nullptr)
14499 for (bp_location
*loc
: bp
->locations ())
14500 if (loc
->loc_type
== bp_loc_hardware_watchpoint
14501 && loc
->address
+ loc
->length
> addr
14502 && addr
+ len
> loc
->address
)
14505 wp
->val_valid
= false;
14511 /* Create and insert a breakpoint for software single step. */
14514 insert_single_step_breakpoint (struct gdbarch
*gdbarch
,
14515 const address_space
*aspace
,
14518 struct thread_info
*tp
= inferior_thread ();
14519 struct symtab_and_line sal
;
14520 CORE_ADDR pc
= next_pc
;
14522 if (tp
->control
.single_step_breakpoints
== NULL
)
14524 tp
->control
.single_step_breakpoints
14525 = new_single_step_breakpoint (tp
->global_num
, gdbarch
);
14528 sal
= find_pc_line (pc
, 0);
14530 sal
.section
= find_pc_overlay (pc
);
14531 sal
.explicit_pc
= 1;
14532 add_location_to_breakpoint (tp
->control
.single_step_breakpoints
, &sal
);
14534 update_global_location_list (UGLL_INSERT
);
14537 /* Insert single step breakpoints according to the current state. */
14540 insert_single_step_breakpoints (struct gdbarch
*gdbarch
)
14542 struct regcache
*regcache
= get_current_regcache ();
14543 std::vector
<CORE_ADDR
> next_pcs
;
14545 next_pcs
= gdbarch_software_single_step (gdbarch
, regcache
);
14547 if (!next_pcs
.empty ())
14549 struct frame_info
*frame
= get_current_frame ();
14550 const address_space
*aspace
= get_frame_address_space (frame
);
14552 for (CORE_ADDR pc
: next_pcs
)
14553 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
14561 /* See breakpoint.h. */
14564 breakpoint_has_location_inserted_here (struct breakpoint
*bp
,
14565 const address_space
*aspace
,
14568 for (bp_location
*loc
: bp
->locations ())
14570 && breakpoint_location_address_match (loc
, aspace
, pc
))
14576 /* Check whether a software single-step breakpoint is inserted at
14580 single_step_breakpoint_inserted_here_p (const address_space
*aspace
,
14583 for (breakpoint
*bpt
: all_breakpoints ())
14585 if (bpt
->type
== bp_single_step
14586 && breakpoint_has_location_inserted_here (bpt
, aspace
, pc
))
14592 /* Tracepoint-specific operations. */
14594 /* Set tracepoint count to NUM. */
14596 set_tracepoint_count (int num
)
14598 tracepoint_count
= num
;
14599 set_internalvar_integer (lookup_internalvar ("tpnum"), num
);
14603 trace_command (const char *arg
, int from_tty
)
14605 event_location_up location
= string_to_event_location (&arg
,
14607 const struct breakpoint_ops
*ops
= breakpoint_ops_for_event_location
14608 (location
.get (), true /* is_tracepoint */);
14610 create_breakpoint (get_current_arch (),
14612 NULL
, 0, arg
, false, 1 /* parse arg */,
14614 bp_tracepoint
/* type_wanted */,
14615 0 /* Ignore count */,
14616 pending_break_support
,
14620 0 /* internal */, 0);
14624 ftrace_command (const char *arg
, int from_tty
)
14626 event_location_up location
= string_to_event_location (&arg
,
14628 create_breakpoint (get_current_arch (),
14630 NULL
, 0, arg
, false, 1 /* parse arg */,
14632 bp_fast_tracepoint
/* type_wanted */,
14633 0 /* Ignore count */,
14634 pending_break_support
,
14635 &tracepoint_breakpoint_ops
,
14638 0 /* internal */, 0);
14641 /* strace command implementation. Creates a static tracepoint. */
14644 strace_command (const char *arg
, int from_tty
)
14646 struct breakpoint_ops
*ops
;
14647 event_location_up location
;
14649 /* Decide if we are dealing with a static tracepoint marker (`-m'),
14650 or with a normal static tracepoint. */
14651 if (arg
&& startswith (arg
, "-m") && isspace (arg
[2]))
14653 ops
= &strace_marker_breakpoint_ops
;
14654 location
= new_linespec_location (&arg
, symbol_name_match_type::FULL
);
14658 ops
= &tracepoint_breakpoint_ops
;
14659 location
= string_to_event_location (&arg
, current_language
);
14662 create_breakpoint (get_current_arch (),
14664 NULL
, 0, arg
, false, 1 /* parse arg */,
14666 bp_static_tracepoint
/* type_wanted */,
14667 0 /* Ignore count */,
14668 pending_break_support
,
14672 0 /* internal */, 0);
14675 /* Set up a fake reader function that gets command lines from a linked
14676 list that was acquired during tracepoint uploading. */
14678 static struct uploaded_tp
*this_utp
;
14679 static int next_cmd
;
14682 read_uploaded_action (void)
14684 char *rslt
= nullptr;
14686 if (next_cmd
< this_utp
->cmd_strings
.size ())
14688 rslt
= this_utp
->cmd_strings
[next_cmd
].get ();
14695 /* Given information about a tracepoint as recorded on a target (which
14696 can be either a live system or a trace file), attempt to create an
14697 equivalent GDB tracepoint. This is not a reliable process, since
14698 the target does not necessarily have all the information used when
14699 the tracepoint was originally defined. */
14701 struct tracepoint
*
14702 create_tracepoint_from_upload (struct uploaded_tp
*utp
)
14704 const char *addr_str
;
14705 char small_buf
[100];
14706 struct tracepoint
*tp
;
14708 if (utp
->at_string
)
14709 addr_str
= utp
->at_string
.get ();
14712 /* In the absence of a source location, fall back to raw
14713 address. Since there is no way to confirm that the address
14714 means the same thing as when the trace was started, warn the
14716 warning (_("Uploaded tracepoint %d has no "
14717 "source location, using raw address"),
14719 xsnprintf (small_buf
, sizeof (small_buf
), "*%s", hex_string (utp
->addr
));
14720 addr_str
= small_buf
;
14723 /* There's not much we can do with a sequence of bytecodes. */
14724 if (utp
->cond
&& !utp
->cond_string
)
14725 warning (_("Uploaded tracepoint %d condition "
14726 "has no source form, ignoring it"),
14729 event_location_up location
= string_to_event_location (&addr_str
,
14731 if (!create_breakpoint (get_current_arch (),
14733 utp
->cond_string
.get (), -1, addr_str
,
14734 false /* force_condition */,
14735 0 /* parse cond/thread */,
14737 utp
->type
/* type_wanted */,
14738 0 /* Ignore count */,
14739 pending_break_support
,
14740 &tracepoint_breakpoint_ops
,
14742 utp
->enabled
/* enabled */,
14744 CREATE_BREAKPOINT_FLAGS_INSERTED
))
14747 /* Get the tracepoint we just created. */
14748 tp
= get_tracepoint (tracepoint_count
);
14749 gdb_assert (tp
!= NULL
);
14753 xsnprintf (small_buf
, sizeof (small_buf
), "%d %d", utp
->pass
,
14756 trace_pass_command (small_buf
, 0);
14759 /* If we have uploaded versions of the original commands, set up a
14760 special-purpose "reader" function and call the usual command line
14761 reader, then pass the result to the breakpoint command-setting
14763 if (!utp
->cmd_strings
.empty ())
14765 counted_command_line cmd_list
;
14770 cmd_list
= read_command_lines_1 (read_uploaded_action
, 1, NULL
);
14772 breakpoint_set_commands (tp
, std::move (cmd_list
));
14774 else if (!utp
->actions
.empty ()
14775 || !utp
->step_actions
.empty ())
14776 warning (_("Uploaded tracepoint %d actions "
14777 "have no source form, ignoring them"),
14780 /* Copy any status information that might be available. */
14781 tp
->hit_count
= utp
->hit_count
;
14782 tp
->traceframe_usage
= utp
->traceframe_usage
;
14787 /* Print information on tracepoint number TPNUM_EXP, or all if
14791 info_tracepoints_command (const char *args
, int from_tty
)
14793 struct ui_out
*uiout
= current_uiout
;
14796 num_printed
= breakpoint_1 (args
, false, is_tracepoint
);
14798 if (num_printed
== 0)
14800 if (args
== NULL
|| *args
== '\0')
14801 uiout
->message ("No tracepoints.\n");
14803 uiout
->message ("No tracepoint matching '%s'.\n", args
);
14806 default_collect_info ();
14809 /* The 'enable trace' command enables tracepoints.
14810 Not supported by all targets. */
14812 enable_trace_command (const char *args
, int from_tty
)
14814 enable_command (args
, from_tty
);
14817 /* The 'disable trace' command disables tracepoints.
14818 Not supported by all targets. */
14820 disable_trace_command (const char *args
, int from_tty
)
14822 disable_command (args
, from_tty
);
14825 /* Remove a tracepoint (or all if no argument). */
14827 delete_trace_command (const char *arg
, int from_tty
)
14833 int breaks_to_delete
= 0;
14835 /* Delete all breakpoints if no argument.
14836 Do not delete internal or call-dummy breakpoints, these
14837 have to be deleted with an explicit breakpoint number
14839 for (breakpoint
*tp
: all_tracepoints ())
14840 if (is_tracepoint (tp
) && user_breakpoint_p (tp
))
14842 breaks_to_delete
= 1;
14846 /* Ask user only if there are some breakpoints to delete. */
14848 || (breaks_to_delete
&& query (_("Delete all tracepoints? "))))
14850 for (breakpoint
*b
: all_breakpoints_safe ())
14851 if (is_tracepoint (b
) && user_breakpoint_p (b
))
14852 delete_breakpoint (b
);
14856 map_breakpoint_numbers
14857 (arg
, [&] (breakpoint
*br
)
14859 iterate_over_related_breakpoints (br
, delete_breakpoint
);
14863 /* Helper function for trace_pass_command. */
14866 trace_pass_set_count (struct tracepoint
*tp
, int count
, int from_tty
)
14868 tp
->pass_count
= count
;
14869 gdb::observers::breakpoint_modified
.notify (tp
);
14871 printf_filtered (_("Setting tracepoint %d's passcount to %d\n"),
14872 tp
->number
, count
);
14875 /* Set passcount for tracepoint.
14877 First command argument is passcount, second is tracepoint number.
14878 If tracepoint number omitted, apply to most recently defined.
14879 Also accepts special argument "all". */
14882 trace_pass_command (const char *args
, int from_tty
)
14884 struct tracepoint
*t1
;
14887 if (args
== 0 || *args
== 0)
14888 error (_("passcount command requires an "
14889 "argument (count + optional TP num)"));
14891 count
= strtoulst (args
, &args
, 10); /* Count comes first, then TP num. */
14893 args
= skip_spaces (args
);
14894 if (*args
&& strncasecmp (args
, "all", 3) == 0)
14896 args
+= 3; /* Skip special argument "all". */
14898 error (_("Junk at end of arguments."));
14900 for (breakpoint
*b
: all_tracepoints ())
14902 t1
= (struct tracepoint
*) b
;
14903 trace_pass_set_count (t1
, count
, from_tty
);
14906 else if (*args
== '\0')
14908 t1
= get_tracepoint_by_number (&args
, NULL
);
14910 trace_pass_set_count (t1
, count
, from_tty
);
14914 number_or_range_parser
parser (args
);
14915 while (!parser
.finished ())
14917 t1
= get_tracepoint_by_number (&args
, &parser
);
14919 trace_pass_set_count (t1
, count
, from_tty
);
14924 struct tracepoint
*
14925 get_tracepoint (int num
)
14927 for (breakpoint
*t
: all_tracepoints ())
14928 if (t
->number
== num
)
14929 return (struct tracepoint
*) t
;
14934 /* Find the tracepoint with the given target-side number (which may be
14935 different from the tracepoint number after disconnecting and
14938 struct tracepoint
*
14939 get_tracepoint_by_number_on_target (int num
)
14941 for (breakpoint
*b
: all_tracepoints ())
14943 struct tracepoint
*t
= (struct tracepoint
*) b
;
14945 if (t
->number_on_target
== num
)
14952 /* Utility: parse a tracepoint number and look it up in the list.
14953 If STATE is not NULL, use, get_number_or_range_state and ignore ARG.
14954 If the argument is missing, the most recent tracepoint
14955 (tracepoint_count) is returned. */
14957 struct tracepoint
*
14958 get_tracepoint_by_number (const char **arg
,
14959 number_or_range_parser
*parser
)
14962 const char *instring
= arg
== NULL
? NULL
: *arg
;
14964 if (parser
!= NULL
)
14966 gdb_assert (!parser
->finished ());
14967 tpnum
= parser
->get_number ();
14969 else if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
14970 tpnum
= tracepoint_count
;
14972 tpnum
= get_number (arg
);
14976 if (instring
&& *instring
)
14977 printf_filtered (_("bad tracepoint number at or near '%s'\n"),
14980 printf_filtered (_("No previous tracepoint\n"));
14984 for (breakpoint
*t
: all_tracepoints ())
14985 if (t
->number
== tpnum
)
14986 return (struct tracepoint
*) t
;
14988 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
14993 print_recreate_thread (struct breakpoint
*b
, struct ui_file
*fp
)
14995 if (b
->thread
!= -1)
14996 fprintf_unfiltered (fp
, " thread %d", b
->thread
);
14999 fprintf_unfiltered (fp
, " task %d", b
->task
);
15001 fprintf_unfiltered (fp
, "\n");
15004 /* Save information on user settable breakpoints (watchpoints, etc) to
15005 a new script file named FILENAME. If FILTER is non-NULL, call it
15006 on each breakpoint and only include the ones for which it returns
15010 save_breakpoints (const char *filename
, int from_tty
,
15011 bool (*filter
) (const struct breakpoint
*))
15014 int extra_trace_bits
= 0;
15016 if (filename
== 0 || *filename
== 0)
15017 error (_("Argument required (file name in which to save)"));
15019 /* See if we have anything to save. */
15020 for (breakpoint
*tp
: all_breakpoints ())
15022 /* Skip internal and momentary breakpoints. */
15023 if (!user_breakpoint_p (tp
))
15026 /* If we have a filter, only save the breakpoints it accepts. */
15027 if (filter
&& !filter (tp
))
15032 if (is_tracepoint (tp
))
15034 extra_trace_bits
= 1;
15036 /* We can stop searching. */
15043 warning (_("Nothing to save."));
15047 gdb::unique_xmalloc_ptr
<char> expanded_filename (tilde_expand (filename
));
15051 if (!fp
.open (expanded_filename
.get (), "w"))
15052 error (_("Unable to open file '%s' for saving (%s)"),
15053 expanded_filename
.get (), safe_strerror (errno
));
15055 if (extra_trace_bits
)
15056 save_trace_state_variables (&fp
);
15058 for (breakpoint
*tp
: all_breakpoints ())
15060 /* Skip internal and momentary breakpoints. */
15061 if (!user_breakpoint_p (tp
))
15064 /* If we have a filter, only save the breakpoints it accepts. */
15065 if (filter
&& !filter (tp
))
15068 tp
->ops
->print_recreate (tp
, &fp
);
15070 /* Note, we can't rely on tp->number for anything, as we can't
15071 assume the recreated breakpoint numbers will match. Use $bpnum
15074 if (tp
->cond_string
)
15075 fp
.printf (" condition $bpnum %s\n", tp
->cond_string
);
15077 if (tp
->ignore_count
)
15078 fp
.printf (" ignore $bpnum %d\n", tp
->ignore_count
);
15080 if (tp
->type
!= bp_dprintf
&& tp
->commands
)
15082 fp
.puts (" commands\n");
15084 current_uiout
->redirect (&fp
);
15087 print_command_lines (current_uiout
, tp
->commands
.get (), 2);
15089 catch (const gdb_exception
&ex
)
15091 current_uiout
->redirect (NULL
);
15095 current_uiout
->redirect (NULL
);
15096 fp
.puts (" end\n");
15099 if (tp
->enable_state
== bp_disabled
)
15100 fp
.puts ("disable $bpnum\n");
15102 /* If this is a multi-location breakpoint, check if the locations
15103 should be individually disabled. Watchpoint locations are
15104 special, and not user visible. */
15105 if (!is_watchpoint (tp
) && tp
->loc
&& tp
->loc
->next
)
15109 for (bp_location
*loc
: tp
->locations ())
15112 fp
.printf ("disable $bpnum.%d\n", n
);
15119 if (extra_trace_bits
&& *default_collect
)
15120 fp
.printf ("set default-collect %s\n", default_collect
);
15123 printf_filtered (_("Saved to file '%s'.\n"), expanded_filename
.get ());
15126 /* The `save breakpoints' command. */
15129 save_breakpoints_command (const char *args
, int from_tty
)
15131 save_breakpoints (args
, from_tty
, NULL
);
15134 /* The `save tracepoints' command. */
15137 save_tracepoints_command (const char *args
, int from_tty
)
15139 save_breakpoints (args
, from_tty
, is_tracepoint
);
15143 /* This help string is used to consolidate all the help string for specifying
15144 locations used by several commands. */
15146 #define LOCATION_HELP_STRING \
15147 "Linespecs are colon-separated lists of location parameters, such as\n\
15148 source filename, function name, label name, and line number.\n\
15149 Example: To specify the start of a label named \"the_top\" in the\n\
15150 function \"fact\" in the file \"factorial.c\", use\n\
15151 \"factorial.c:fact:the_top\".\n\
15153 Address locations begin with \"*\" and specify an exact address in the\n\
15154 program. Example: To specify the fourth byte past the start function\n\
15155 \"main\", use \"*main + 4\".\n\
15157 Explicit locations are similar to linespecs but use an option/argument\n\
15158 syntax to specify location parameters.\n\
15159 Example: To specify the start of the label named \"the_top\" in the\n\
15160 function \"fact\" in the file \"factorial.c\", use \"-source factorial.c\n\
15161 -function fact -label the_top\".\n\
15163 By default, a specified function is matched against the program's\n\
15164 functions in all scopes. For C++, this means in all namespaces and\n\
15165 classes. For Ada, this means in all packages. E.g., in C++,\n\
15166 \"func()\" matches \"A::func()\", \"A::B::func()\", etc. The\n\
15167 \"-qualified\" flag overrides this behavior, making GDB interpret the\n\
15168 specified name as a complete fully-qualified name instead."
15170 /* This help string is used for the break, hbreak, tbreak and thbreak
15171 commands. It is defined as a macro to prevent duplication.
15172 COMMAND should be a string constant containing the name of the
15175 #define BREAK_ARGS_HELP(command) \
15176 command" [PROBE_MODIFIER] [LOCATION] [thread THREADNUM]\n\
15177 \t[-force-condition] [if CONDITION]\n\
15178 PROBE_MODIFIER shall be present if the command is to be placed in a\n\
15179 probe point. Accepted values are `-probe' (for a generic, automatically\n\
15180 guessed probe type), `-probe-stap' (for a SystemTap probe) or \n\
15181 `-probe-dtrace' (for a DTrace probe).\n\
15182 LOCATION may be a linespec, address, or explicit location as described\n\
15185 With no LOCATION, uses current execution address of the selected\n\
15186 stack frame. This is useful for breaking on return to a stack frame.\n\
15188 THREADNUM is the number from \"info threads\".\n\
15189 CONDITION is a boolean expression.\n\
15191 With the \"-force-condition\" flag, the condition is defined even when\n\
15192 it is invalid for all current locations.\n\
15193 \n" LOCATION_HELP_STRING "\n\n\
15194 Multiple breakpoints at one place are permitted, and useful if their\n\
15195 conditions are different.\n\
15197 Do \"help breakpoints\" for info on other commands dealing with breakpoints."
15199 /* List of subcommands for "catch". */
15200 static struct cmd_list_element
*catch_cmdlist
;
15202 /* List of subcommands for "tcatch". */
15203 static struct cmd_list_element
*tcatch_cmdlist
;
15206 add_catch_command (const char *name
, const char *docstring
,
15207 cmd_const_sfunc_ftype
*sfunc
,
15208 completer_ftype
*completer
,
15209 void *user_data_catch
,
15210 void *user_data_tcatch
)
15212 struct cmd_list_element
*command
;
15214 command
= add_cmd (name
, class_breakpoint
, docstring
,
15216 set_cmd_sfunc (command
, sfunc
);
15217 set_cmd_context (command
, user_data_catch
);
15218 set_cmd_completer (command
, completer
);
15220 command
= add_cmd (name
, class_breakpoint
, docstring
,
15222 set_cmd_sfunc (command
, sfunc
);
15223 set_cmd_context (command
, user_data_tcatch
);
15224 set_cmd_completer (command
, completer
);
15227 /* Zero if any of the breakpoint's locations could be a location where
15228 functions have been inlined, nonzero otherwise. */
15231 is_non_inline_function (struct breakpoint
*b
)
15233 /* The shared library event breakpoint is set on the address of a
15234 non-inline function. */
15235 if (b
->type
== bp_shlib_event
)
15241 /* Nonzero if the specified PC cannot be a location where functions
15242 have been inlined. */
15245 pc_at_non_inline_function (const address_space
*aspace
, CORE_ADDR pc
,
15246 const struct target_waitstatus
*ws
)
15248 for (breakpoint
*b
: all_breakpoints ())
15250 if (!is_non_inline_function (b
))
15253 for (bp_location
*bl
: b
->locations ())
15255 if (!bl
->shlib_disabled
15256 && bpstat_check_location (bl
, aspace
, pc
, ws
))
15264 /* Remove any references to OBJFILE which is going to be freed. */
15267 breakpoint_free_objfile (struct objfile
*objfile
)
15269 for (bp_location
*loc
: all_bp_locations ())
15270 if (loc
->symtab
!= NULL
&& SYMTAB_OBJFILE (loc
->symtab
) == objfile
)
15271 loc
->symtab
= NULL
;
15275 initialize_breakpoint_ops (void)
15277 static int initialized
= 0;
15279 struct breakpoint_ops
*ops
;
15285 /* The breakpoint_ops structure to be inherit by all kinds of
15286 breakpoints (real breakpoints, i.e., user "break" breakpoints,
15287 internal and momentary breakpoints, etc.). */
15288 ops
= &bkpt_base_breakpoint_ops
;
15289 *ops
= base_breakpoint_ops
;
15290 ops
->re_set
= bkpt_re_set
;
15291 ops
->insert_location
= bkpt_insert_location
;
15292 ops
->remove_location
= bkpt_remove_location
;
15293 ops
->breakpoint_hit
= bkpt_breakpoint_hit
;
15294 ops
->create_sals_from_location
= bkpt_create_sals_from_location
;
15295 ops
->create_breakpoints_sal
= bkpt_create_breakpoints_sal
;
15296 ops
->decode_location
= bkpt_decode_location
;
15298 /* The breakpoint_ops structure to be used in regular breakpoints. */
15299 ops
= &bkpt_breakpoint_ops
;
15300 *ops
= bkpt_base_breakpoint_ops
;
15301 ops
->re_set
= bkpt_re_set
;
15302 ops
->resources_needed
= bkpt_resources_needed
;
15303 ops
->print_it
= bkpt_print_it
;
15304 ops
->print_mention
= bkpt_print_mention
;
15305 ops
->print_recreate
= bkpt_print_recreate
;
15307 /* Ranged breakpoints. */
15308 ops
= &ranged_breakpoint_ops
;
15309 *ops
= bkpt_breakpoint_ops
;
15310 ops
->breakpoint_hit
= breakpoint_hit_ranged_breakpoint
;
15311 ops
->resources_needed
= resources_needed_ranged_breakpoint
;
15312 ops
->print_it
= print_it_ranged_breakpoint
;
15313 ops
->print_one
= print_one_ranged_breakpoint
;
15314 ops
->print_one_detail
= print_one_detail_ranged_breakpoint
;
15315 ops
->print_mention
= print_mention_ranged_breakpoint
;
15316 ops
->print_recreate
= print_recreate_ranged_breakpoint
;
15318 /* Internal breakpoints. */
15319 ops
= &internal_breakpoint_ops
;
15320 *ops
= bkpt_base_breakpoint_ops
;
15321 ops
->re_set
= internal_bkpt_re_set
;
15322 ops
->check_status
= internal_bkpt_check_status
;
15323 ops
->print_it
= internal_bkpt_print_it
;
15324 ops
->print_mention
= internal_bkpt_print_mention
;
15326 /* Momentary breakpoints. */
15327 ops
= &momentary_breakpoint_ops
;
15328 *ops
= bkpt_base_breakpoint_ops
;
15329 ops
->re_set
= momentary_bkpt_re_set
;
15330 ops
->check_status
= momentary_bkpt_check_status
;
15331 ops
->print_it
= momentary_bkpt_print_it
;
15332 ops
->print_mention
= momentary_bkpt_print_mention
;
15334 /* Probe breakpoints. */
15335 ops
= &bkpt_probe_breakpoint_ops
;
15336 *ops
= bkpt_breakpoint_ops
;
15337 ops
->insert_location
= bkpt_probe_insert_location
;
15338 ops
->remove_location
= bkpt_probe_remove_location
;
15339 ops
->create_sals_from_location
= bkpt_probe_create_sals_from_location
;
15340 ops
->decode_location
= bkpt_probe_decode_location
;
15343 ops
= &watchpoint_breakpoint_ops
;
15344 *ops
= base_breakpoint_ops
;
15345 ops
->re_set
= re_set_watchpoint
;
15346 ops
->insert_location
= insert_watchpoint
;
15347 ops
->remove_location
= remove_watchpoint
;
15348 ops
->breakpoint_hit
= breakpoint_hit_watchpoint
;
15349 ops
->check_status
= check_status_watchpoint
;
15350 ops
->resources_needed
= resources_needed_watchpoint
;
15351 ops
->works_in_software_mode
= works_in_software_mode_watchpoint
;
15352 ops
->print_it
= print_it_watchpoint
;
15353 ops
->print_mention
= print_mention_watchpoint
;
15354 ops
->print_recreate
= print_recreate_watchpoint
;
15355 ops
->explains_signal
= explains_signal_watchpoint
;
15357 /* Masked watchpoints. */
15358 ops
= &masked_watchpoint_breakpoint_ops
;
15359 *ops
= watchpoint_breakpoint_ops
;
15360 ops
->insert_location
= insert_masked_watchpoint
;
15361 ops
->remove_location
= remove_masked_watchpoint
;
15362 ops
->resources_needed
= resources_needed_masked_watchpoint
;
15363 ops
->works_in_software_mode
= works_in_software_mode_masked_watchpoint
;
15364 ops
->print_it
= print_it_masked_watchpoint
;
15365 ops
->print_one_detail
= print_one_detail_masked_watchpoint
;
15366 ops
->print_mention
= print_mention_masked_watchpoint
;
15367 ops
->print_recreate
= print_recreate_masked_watchpoint
;
15370 ops
= &tracepoint_breakpoint_ops
;
15371 *ops
= base_breakpoint_ops
;
15372 ops
->re_set
= tracepoint_re_set
;
15373 ops
->breakpoint_hit
= tracepoint_breakpoint_hit
;
15374 ops
->print_one_detail
= tracepoint_print_one_detail
;
15375 ops
->print_mention
= tracepoint_print_mention
;
15376 ops
->print_recreate
= tracepoint_print_recreate
;
15377 ops
->create_sals_from_location
= tracepoint_create_sals_from_location
;
15378 ops
->create_breakpoints_sal
= tracepoint_create_breakpoints_sal
;
15379 ops
->decode_location
= tracepoint_decode_location
;
15381 /* Probe tracepoints. */
15382 ops
= &tracepoint_probe_breakpoint_ops
;
15383 *ops
= tracepoint_breakpoint_ops
;
15384 ops
->create_sals_from_location
= tracepoint_probe_create_sals_from_location
;
15385 ops
->decode_location
= tracepoint_probe_decode_location
;
15387 /* Static tracepoints with marker (`-m'). */
15388 ops
= &strace_marker_breakpoint_ops
;
15389 *ops
= tracepoint_breakpoint_ops
;
15390 ops
->create_sals_from_location
= strace_marker_create_sals_from_location
;
15391 ops
->create_breakpoints_sal
= strace_marker_create_breakpoints_sal
;
15392 ops
->decode_location
= strace_marker_decode_location
;
15394 /* Fork catchpoints. */
15395 ops
= &catch_fork_breakpoint_ops
;
15396 *ops
= base_breakpoint_ops
;
15397 ops
->insert_location
= insert_catch_fork
;
15398 ops
->remove_location
= remove_catch_fork
;
15399 ops
->breakpoint_hit
= breakpoint_hit_catch_fork
;
15400 ops
->print_it
= print_it_catch_fork
;
15401 ops
->print_one
= print_one_catch_fork
;
15402 ops
->print_mention
= print_mention_catch_fork
;
15403 ops
->print_recreate
= print_recreate_catch_fork
;
15405 /* Vfork catchpoints. */
15406 ops
= &catch_vfork_breakpoint_ops
;
15407 *ops
= base_breakpoint_ops
;
15408 ops
->insert_location
= insert_catch_vfork
;
15409 ops
->remove_location
= remove_catch_vfork
;
15410 ops
->breakpoint_hit
= breakpoint_hit_catch_vfork
;
15411 ops
->print_it
= print_it_catch_vfork
;
15412 ops
->print_one
= print_one_catch_vfork
;
15413 ops
->print_mention
= print_mention_catch_vfork
;
15414 ops
->print_recreate
= print_recreate_catch_vfork
;
15416 /* Exec catchpoints. */
15417 ops
= &catch_exec_breakpoint_ops
;
15418 *ops
= base_breakpoint_ops
;
15419 ops
->insert_location
= insert_catch_exec
;
15420 ops
->remove_location
= remove_catch_exec
;
15421 ops
->breakpoint_hit
= breakpoint_hit_catch_exec
;
15422 ops
->print_it
= print_it_catch_exec
;
15423 ops
->print_one
= print_one_catch_exec
;
15424 ops
->print_mention
= print_mention_catch_exec
;
15425 ops
->print_recreate
= print_recreate_catch_exec
;
15427 /* Solib-related catchpoints. */
15428 ops
= &catch_solib_breakpoint_ops
;
15429 *ops
= base_breakpoint_ops
;
15430 ops
->insert_location
= insert_catch_solib
;
15431 ops
->remove_location
= remove_catch_solib
;
15432 ops
->breakpoint_hit
= breakpoint_hit_catch_solib
;
15433 ops
->check_status
= check_status_catch_solib
;
15434 ops
->print_it
= print_it_catch_solib
;
15435 ops
->print_one
= print_one_catch_solib
;
15436 ops
->print_mention
= print_mention_catch_solib
;
15437 ops
->print_recreate
= print_recreate_catch_solib
;
15439 ops
= &dprintf_breakpoint_ops
;
15440 *ops
= bkpt_base_breakpoint_ops
;
15441 ops
->re_set
= dprintf_re_set
;
15442 ops
->resources_needed
= bkpt_resources_needed
;
15443 ops
->print_it
= bkpt_print_it
;
15444 ops
->print_mention
= bkpt_print_mention
;
15445 ops
->print_recreate
= dprintf_print_recreate
;
15446 ops
->after_condition_true
= dprintf_after_condition_true
;
15447 ops
->breakpoint_hit
= dprintf_breakpoint_hit
;
15450 /* Chain containing all defined "enable breakpoint" subcommands. */
15452 static struct cmd_list_element
*enablebreaklist
= NULL
;
15454 /* See breakpoint.h. */
15456 cmd_list_element
*commands_cmd_element
= nullptr;
15458 void _initialize_breakpoint ();
15460 _initialize_breakpoint ()
15462 struct cmd_list_element
*c
;
15464 initialize_breakpoint_ops ();
15466 gdb::observers::solib_unloaded
.attach (disable_breakpoints_in_unloaded_shlib
,
15468 gdb::observers::free_objfile
.attach (disable_breakpoints_in_freed_objfile
,
15470 gdb::observers::memory_changed
.attach (invalidate_bp_value_on_memory_change
,
15473 breakpoint_chain
= 0;
15474 /* Don't bother to call set_breakpoint_count. $bpnum isn't useful
15475 before a breakpoint is set. */
15476 breakpoint_count
= 0;
15478 tracepoint_count
= 0;
15480 add_com ("ignore", class_breakpoint
, ignore_command
, _("\
15481 Set ignore-count of breakpoint number N to COUNT.\n\
15482 Usage is `ignore N COUNT'."));
15484 commands_cmd_element
= add_com ("commands", class_breakpoint
,
15485 commands_command
, _("\
15486 Set commands to be executed when the given breakpoints are hit.\n\
15487 Give a space-separated breakpoint list as argument after \"commands\".\n\
15488 A list element can be a breakpoint number (e.g. `5') or a range of numbers\n\
15490 With no argument, the targeted breakpoint is the last one set.\n\
15491 The commands themselves follow starting on the next line.\n\
15492 Type a line containing \"end\" to indicate the end of them.\n\
15493 Give \"silent\" as the first line to make the breakpoint silent;\n\
15494 then no output is printed when it is hit, except what the commands print."));
15496 const auto cc_opts
= make_condition_command_options_def_group (nullptr);
15497 static std::string condition_command_help
15498 = gdb::option::build_help (_("\
15499 Specify breakpoint number N to break only if COND is true.\n\
15500 Usage is `condition [OPTION] N COND', where N is an integer and COND\n\
15501 is an expression to be evaluated whenever breakpoint N is reached.\n\
15504 %OPTIONS%"), cc_opts
);
15506 c
= add_com ("condition", class_breakpoint
, condition_command
,
15507 condition_command_help
.c_str ());
15508 set_cmd_completer_handle_brkchars (c
, condition_completer
);
15510 c
= add_com ("tbreak", class_breakpoint
, tbreak_command
, _("\
15511 Set a temporary breakpoint.\n\
15512 Like \"break\" except the breakpoint is only temporary,\n\
15513 so it will be deleted when hit. Equivalent to \"break\" followed\n\
15514 by using \"enable delete\" on the breakpoint number.\n\
15516 BREAK_ARGS_HELP ("tbreak")));
15517 set_cmd_completer (c
, location_completer
);
15519 c
= add_com ("hbreak", class_breakpoint
, hbreak_command
, _("\
15520 Set a hardware assisted breakpoint.\n\
15521 Like \"break\" except the breakpoint requires hardware support,\n\
15522 some target hardware may not have this support.\n\
15524 BREAK_ARGS_HELP ("hbreak")));
15525 set_cmd_completer (c
, location_completer
);
15527 c
= add_com ("thbreak", class_breakpoint
, thbreak_command
, _("\
15528 Set a temporary hardware assisted breakpoint.\n\
15529 Like \"hbreak\" except the breakpoint is only temporary,\n\
15530 so it will be deleted when hit.\n\
15532 BREAK_ARGS_HELP ("thbreak")));
15533 set_cmd_completer (c
, location_completer
);
15535 cmd_list_element
*enable_cmd
15536 = add_prefix_cmd ("enable", class_breakpoint
, enable_command
, _("\
15537 Enable all or some breakpoints.\n\
15538 Usage: enable [BREAKPOINTNUM]...\n\
15539 Give breakpoint numbers (separated by spaces) as arguments.\n\
15540 With no subcommand, breakpoints are enabled until you command otherwise.\n\
15541 This is used to cancel the effect of the \"disable\" command.\n\
15542 With a subcommand you can enable temporarily."),
15543 &enablelist
, 1, &cmdlist
);
15545 add_com_alias ("en", enable_cmd
, class_breakpoint
, 1);
15547 add_prefix_cmd ("breakpoints", class_breakpoint
, enable_command
, _("\
15548 Enable all or some breakpoints.\n\
15549 Usage: enable breakpoints [BREAKPOINTNUM]...\n\
15550 Give breakpoint numbers (separated by spaces) as arguments.\n\
15551 This is used to cancel the effect of the \"disable\" command.\n\
15552 May be abbreviated to simply \"enable\"."),
15553 &enablebreaklist
, 1, &enablelist
);
15555 add_cmd ("once", no_class
, enable_once_command
, _("\
15556 Enable some breakpoints for one hit.\n\
15557 Usage: enable breakpoints once BREAKPOINTNUM...\n\
15558 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15561 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15562 Enable some breakpoints and delete when hit.\n\
15563 Usage: enable breakpoints delete BREAKPOINTNUM...\n\
15564 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15567 add_cmd ("count", no_class
, enable_count_command
, _("\
15568 Enable some breakpoints for COUNT hits.\n\
15569 Usage: enable breakpoints count COUNT BREAKPOINTNUM...\n\
15570 If a breakpoint is hit while enabled in this fashion,\n\
15571 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15574 add_cmd ("delete", no_class
, enable_delete_command
, _("\
15575 Enable some breakpoints and delete when hit.\n\
15576 Usage: enable delete BREAKPOINTNUM...\n\
15577 If a breakpoint is hit while enabled in this fashion, it is deleted."),
15580 add_cmd ("once", no_class
, enable_once_command
, _("\
15581 Enable some breakpoints for one hit.\n\
15582 Usage: enable once BREAKPOINTNUM...\n\
15583 If a breakpoint is hit while enabled in this fashion, it becomes disabled."),
15586 add_cmd ("count", no_class
, enable_count_command
, _("\
15587 Enable some breakpoints for COUNT hits.\n\
15588 Usage: enable count COUNT BREAKPOINTNUM...\n\
15589 If a breakpoint is hit while enabled in this fashion,\n\
15590 the count is decremented; when it reaches zero, the breakpoint is disabled."),
15593 cmd_list_element
*disable_cmd
15594 = add_prefix_cmd ("disable", class_breakpoint
, disable_command
, _("\
15595 Disable all or some breakpoints.\n\
15596 Usage: disable [BREAKPOINTNUM]...\n\
15597 Arguments are breakpoint numbers with spaces in between.\n\
15598 To disable all breakpoints, give no argument.\n\
15599 A disabled breakpoint is not forgotten, but has no effect until re-enabled."),
15600 &disablelist
, 1, &cmdlist
);
15601 add_com_alias ("dis", disable_cmd
, class_breakpoint
, 1);
15602 add_com_alias ("disa", disable_cmd
, class_breakpoint
, 1);
15604 add_cmd ("breakpoints", class_breakpoint
, disable_command
, _("\
15605 Disable all or some breakpoints.\n\
15606 Usage: disable breakpoints [BREAKPOINTNUM]...\n\
15607 Arguments are breakpoint numbers with spaces in between.\n\
15608 To disable all breakpoints, give no argument.\n\
15609 A disabled breakpoint is not forgotten, but has no effect until re-enabled.\n\
15610 This command may be abbreviated \"disable\"."),
15613 cmd_list_element
*delete_cmd
15614 = add_prefix_cmd ("delete", class_breakpoint
, delete_command
, _("\
15615 Delete all or some breakpoints.\n\
15616 Usage: delete [BREAKPOINTNUM]...\n\
15617 Arguments are breakpoint numbers with spaces in between.\n\
15618 To delete all breakpoints, give no argument.\n\
15620 Also a prefix command for deletion of other GDB objects."),
15621 &deletelist
, 1, &cmdlist
);
15622 add_com_alias ("d", delete_cmd
, class_breakpoint
, 1);
15623 add_com_alias ("del", delete_cmd
, class_breakpoint
, 1);
15625 add_cmd ("breakpoints", class_breakpoint
, delete_command
, _("\
15626 Delete all or some breakpoints or auto-display expressions.\n\
15627 Usage: delete breakpoints [BREAKPOINTNUM]...\n\
15628 Arguments are breakpoint numbers with spaces in between.\n\
15629 To delete all breakpoints, give no argument.\n\
15630 This command may be abbreviated \"delete\"."),
15633 cmd_list_element
*clear_cmd
15634 = add_com ("clear", class_breakpoint
, clear_command
, _("\
15635 Clear breakpoint at specified location.\n\
15636 Argument may be a linespec, explicit, or address location as described below.\n\
15638 With no argument, clears all breakpoints in the line that the selected frame\n\
15639 is executing in.\n"
15640 "\n" LOCATION_HELP_STRING
"\n\n\
15641 See also the \"delete\" command which clears breakpoints by number."));
15642 add_com_alias ("cl", clear_cmd
, class_breakpoint
, 1);
15644 cmd_list_element
*break_cmd
15645 = add_com ("break", class_breakpoint
, break_command
, _("\
15646 Set breakpoint at specified location.\n"
15647 BREAK_ARGS_HELP ("break")));
15648 set_cmd_completer (break_cmd
, location_completer
);
15650 add_com_alias ("b", break_cmd
, class_run
, 1);
15651 add_com_alias ("br", break_cmd
, class_run
, 1);
15652 add_com_alias ("bre", break_cmd
, class_run
, 1);
15653 add_com_alias ("brea", break_cmd
, class_run
, 1);
15657 add_abbrev_prefix_cmd ("stop", class_breakpoint
, stop_command
, _("\
15658 Break in function/address or break at a line in the current file."),
15659 &stoplist
, 1, &cmdlist
);
15660 add_cmd ("in", class_breakpoint
, stopin_command
,
15661 _("Break in function or address."), &stoplist
);
15662 add_cmd ("at", class_breakpoint
, stopat_command
,
15663 _("Break at a line in the current file."), &stoplist
);
15664 add_com ("status", class_info
, info_breakpoints_command
, _("\
15665 Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
15666 The \"Type\" column indicates one of:\n\
15667 \tbreakpoint - normal breakpoint\n\
15668 \twatchpoint - watchpoint\n\
15669 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15670 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15671 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15672 address and file/line number respectively.\n\
15674 Convenience variable \"$_\" and default examine address for \"x\"\n\
15675 are set to the address of the last breakpoint listed unless the command\n\
15676 is prefixed with \"server \".\n\n\
15677 Convenience variable \"$bpnum\" contains the number of the last\n\
15678 breakpoint set."));
15681 cmd_list_element
*info_breakpoints_cmd
15682 = add_info ("breakpoints", info_breakpoints_command
, _("\
15683 Status of specified breakpoints (all user-settable breakpoints if no argument).\n\
15684 The \"Type\" column indicates one of:\n\
15685 \tbreakpoint - normal breakpoint\n\
15686 \twatchpoint - watchpoint\n\
15687 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15688 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15689 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15690 address and file/line number respectively.\n\
15692 Convenience variable \"$_\" and default examine address for \"x\"\n\
15693 are set to the address of the last breakpoint listed unless the command\n\
15694 is prefixed with \"server \".\n\n\
15695 Convenience variable \"$bpnum\" contains the number of the last\n\
15696 breakpoint set."));
15698 add_info_alias ("b", info_breakpoints_cmd
, 1);
15700 add_cmd ("breakpoints", class_maintenance
, maintenance_info_breakpoints
, _("\
15701 Status of all breakpoints, or breakpoint number NUMBER.\n\
15702 The \"Type\" column indicates one of:\n\
15703 \tbreakpoint - normal breakpoint\n\
15704 \twatchpoint - watchpoint\n\
15705 \tlongjmp - internal breakpoint used to step through longjmp()\n\
15706 \tlongjmp resume - internal breakpoint at the target of longjmp()\n\
15707 \tuntil - internal breakpoint used by the \"until\" command\n\
15708 \tfinish - internal breakpoint used by the \"finish\" command\n\
15709 The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
15710 the disposition of the breakpoint after it gets hit. \"dis\" means that the\n\
15711 breakpoint will be disabled. The \"Address\" and \"What\" columns indicate the\n\
15712 address and file/line number respectively.\n\
15714 Convenience variable \"$_\" and default examine address for \"x\"\n\
15715 are set to the address of the last breakpoint listed unless the command\n\
15716 is prefixed with \"server \".\n\n\
15717 Convenience variable \"$bpnum\" contains the number of the last\n\
15719 &maintenanceinfolist
);
15721 add_basic_prefix_cmd ("catch", class_breakpoint
, _("\
15722 Set catchpoints to catch events."),
15724 0/*allow-unknown*/, &cmdlist
);
15726 add_basic_prefix_cmd ("tcatch", class_breakpoint
, _("\
15727 Set temporary catchpoints to catch events."),
15729 0/*allow-unknown*/, &cmdlist
);
15731 add_catch_command ("fork", _("Catch calls to fork."),
15732 catch_fork_command_1
,
15734 (void *) (uintptr_t) catch_fork_permanent
,
15735 (void *) (uintptr_t) catch_fork_temporary
);
15736 add_catch_command ("vfork", _("Catch calls to vfork."),
15737 catch_fork_command_1
,
15739 (void *) (uintptr_t) catch_vfork_permanent
,
15740 (void *) (uintptr_t) catch_vfork_temporary
);
15741 add_catch_command ("exec", _("Catch calls to exec."),
15742 catch_exec_command_1
,
15746 add_catch_command ("load", _("Catch loads of shared libraries.\n\
15747 Usage: catch load [REGEX]\n\
15748 If REGEX is given, only stop for libraries matching the regular expression."),
15749 catch_load_command_1
,
15753 add_catch_command ("unload", _("Catch unloads of shared libraries.\n\
15754 Usage: catch unload [REGEX]\n\
15755 If REGEX is given, only stop for libraries matching the regular expression."),
15756 catch_unload_command_1
,
15761 const auto opts
= make_watch_options_def_group (nullptr);
15763 static const std::string watch_help
= gdb::option::build_help (_("\
15764 Set a watchpoint for EXPRESSION.\n\
15765 Usage: watch [-location] EXPRESSION\n\
15770 A watchpoint stops execution of your program whenever the value of\n\
15771 an expression changes."), opts
);
15772 c
= add_com ("watch", class_breakpoint
, watch_command
,
15773 watch_help
.c_str ());
15774 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
15776 static const std::string rwatch_help
= gdb::option::build_help (_("\
15777 Set a read watchpoint for EXPRESSION.\n\
15778 Usage: rwatch [-location] EXPRESSION\n\
15783 A read watchpoint stops execution of your program whenever the value of\n\
15784 an expression is read."), opts
);
15785 c
= add_com ("rwatch", class_breakpoint
, rwatch_command
,
15786 rwatch_help
.c_str ());
15787 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
15789 static const std::string awatch_help
= gdb::option::build_help (_("\
15790 Set an access watchpoint for EXPRESSION.\n\
15791 Usage: awatch [-location] EXPRESSION\n\
15796 An access watchpoint stops execution of your program whenever the value\n\
15797 of an expression is either read or written."), opts
);
15798 c
= add_com ("awatch", class_breakpoint
, awatch_command
,
15799 awatch_help
.c_str ());
15800 set_cmd_completer_handle_brkchars (c
, watch_command_completer
);
15802 add_info ("watchpoints", info_watchpoints_command
, _("\
15803 Status of specified watchpoints (all watchpoints if no argument)."));
15805 /* XXX: cagney/2005-02-23: This should be a boolean, and should
15806 respond to changes - contrary to the description. */
15807 add_setshow_zinteger_cmd ("can-use-hw-watchpoints", class_support
,
15808 &can_use_hw_watchpoints
, _("\
15809 Set debugger's willingness to use watchpoint hardware."), _("\
15810 Show debugger's willingness to use watchpoint hardware."), _("\
15811 If zero, gdb will not use hardware for new watchpoints, even if\n\
15812 such is available. (However, any hardware watchpoints that were\n\
15813 created before setting this to nonzero, will continue to use watchpoint\n\
15816 show_can_use_hw_watchpoints
,
15817 &setlist
, &showlist
);
15819 can_use_hw_watchpoints
= 1;
15821 /* Tracepoint manipulation commands. */
15823 cmd_list_element
*trace_cmd
15824 = add_com ("trace", class_breakpoint
, trace_command
, _("\
15825 Set a tracepoint at specified location.\n\
15827 BREAK_ARGS_HELP ("trace") "\n\
15828 Do \"help tracepoints\" for info on other tracepoint commands."));
15829 set_cmd_completer (trace_cmd
, location_completer
);
15831 add_com_alias ("tp", trace_cmd
, class_breakpoint
, 0);
15832 add_com_alias ("tr", trace_cmd
, class_breakpoint
, 1);
15833 add_com_alias ("tra", trace_cmd
, class_breakpoint
, 1);
15834 add_com_alias ("trac", trace_cmd
, class_breakpoint
, 1);
15836 c
= add_com ("ftrace", class_breakpoint
, ftrace_command
, _("\
15837 Set a fast tracepoint at specified location.\n\
15839 BREAK_ARGS_HELP ("ftrace") "\n\
15840 Do \"help tracepoints\" for info on other tracepoint commands."));
15841 set_cmd_completer (c
, location_completer
);
15843 c
= add_com ("strace", class_breakpoint
, strace_command
, _("\
15844 Set a static tracepoint at location or marker.\n\
15846 strace [LOCATION] [if CONDITION]\n\
15847 LOCATION may be a linespec, explicit, or address location (described below) \n\
15848 or -m MARKER_ID.\n\n\
15849 If a marker id is specified, probe the marker with that name. With\n\
15850 no LOCATION, uses current execution address of the selected stack frame.\n\
15851 Static tracepoints accept an extra collect action -- ``collect $_sdata''.\n\
15852 This collects arbitrary user data passed in the probe point call to the\n\
15853 tracing library. You can inspect it when analyzing the trace buffer,\n\
15854 by printing the $_sdata variable like any other convenience variable.\n\
15856 CONDITION is a boolean expression.\n\
15857 \n" LOCATION_HELP_STRING
"\n\n\
15858 Multiple tracepoints at one place are permitted, and useful if their\n\
15859 conditions are different.\n\
15861 Do \"help breakpoints\" for info on other commands dealing with breakpoints.\n\
15862 Do \"help tracepoints\" for info on other tracepoint commands."));
15863 set_cmd_completer (c
, location_completer
);
15865 cmd_list_element
*info_tracepoints_cmd
15866 = add_info ("tracepoints", info_tracepoints_command
, _("\
15867 Status of specified tracepoints (all tracepoints if no argument).\n\
15868 Convenience variable \"$tpnum\" contains the number of the\n\
15869 last tracepoint set."));
15871 add_info_alias ("tp", info_tracepoints_cmd
, 1);
15873 cmd_list_element
*delete_tracepoints_cmd
15874 = add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
15875 Delete specified tracepoints.\n\
15876 Arguments are tracepoint numbers, separated by spaces.\n\
15877 No argument means delete all tracepoints."),
15879 add_alias_cmd ("tr", delete_tracepoints_cmd
, class_trace
, 1, &deletelist
);
15881 c
= add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
15882 Disable specified tracepoints.\n\
15883 Arguments are tracepoint numbers, separated by spaces.\n\
15884 No argument means disable all tracepoints."),
15886 deprecate_cmd (c
, "disable");
15888 c
= add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
15889 Enable specified tracepoints.\n\
15890 Arguments are tracepoint numbers, separated by spaces.\n\
15891 No argument means enable all tracepoints."),
15893 deprecate_cmd (c
, "enable");
15895 add_com ("passcount", class_trace
, trace_pass_command
, _("\
15896 Set the passcount for a tracepoint.\n\
15897 The trace will end when the tracepoint has been passed 'count' times.\n\
15898 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
15899 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
15901 add_basic_prefix_cmd ("save", class_breakpoint
,
15902 _("Save breakpoint definitions as a script."),
15904 0/*allow-unknown*/, &cmdlist
);
15906 c
= add_cmd ("breakpoints", class_breakpoint
, save_breakpoints_command
, _("\
15907 Save current breakpoint definitions as a script.\n\
15908 This includes all types of breakpoints (breakpoints, watchpoints,\n\
15909 catchpoints, tracepoints). Use the 'source' command in another debug\n\
15910 session to restore them."),
15912 set_cmd_completer (c
, filename_completer
);
15914 cmd_list_element
*save_tracepoints_cmd
15915 = add_cmd ("tracepoints", class_trace
, save_tracepoints_command
, _("\
15916 Save current tracepoint definitions as a script.\n\
15917 Use the 'source' command in another debug session to restore them."),
15919 set_cmd_completer (save_tracepoints_cmd
, filename_completer
);
15921 c
= add_com_alias ("save-tracepoints", save_tracepoints_cmd
, class_trace
, 0);
15922 deprecate_cmd (c
, "save tracepoints");
15924 add_basic_prefix_cmd ("breakpoint", class_maintenance
, _("\
15925 Breakpoint specific settings.\n\
15926 Configure various breakpoint-specific variables such as\n\
15927 pending breakpoint behavior."),
15928 &breakpoint_set_cmdlist
,
15929 0/*allow-unknown*/, &setlist
);
15930 add_show_prefix_cmd ("breakpoint", class_maintenance
, _("\
15931 Breakpoint specific settings.\n\
15932 Configure various breakpoint-specific variables such as\n\
15933 pending breakpoint behavior."),
15934 &breakpoint_show_cmdlist
,
15935 0/*allow-unknown*/, &showlist
);
15937 add_setshow_auto_boolean_cmd ("pending", no_class
,
15938 &pending_break_support
, _("\
15939 Set debugger's behavior regarding pending breakpoints."), _("\
15940 Show debugger's behavior regarding pending breakpoints."), _("\
15941 If on, an unrecognized breakpoint location will cause gdb to create a\n\
15942 pending breakpoint. If off, an unrecognized breakpoint location results in\n\
15943 an error. If auto, an unrecognized breakpoint location results in a\n\
15944 user-query to see if a pending breakpoint should be created."),
15946 show_pending_break_support
,
15947 &breakpoint_set_cmdlist
,
15948 &breakpoint_show_cmdlist
);
15950 pending_break_support
= AUTO_BOOLEAN_AUTO
;
15952 add_setshow_boolean_cmd ("auto-hw", no_class
,
15953 &automatic_hardware_breakpoints
, _("\
15954 Set automatic usage of hardware breakpoints."), _("\
15955 Show automatic usage of hardware breakpoints."), _("\
15956 If set, the debugger will automatically use hardware breakpoints for\n\
15957 breakpoints set with \"break\" but falling in read-only memory. If not set,\n\
15958 a warning will be emitted for such breakpoints."),
15960 show_automatic_hardware_breakpoints
,
15961 &breakpoint_set_cmdlist
,
15962 &breakpoint_show_cmdlist
);
15964 add_setshow_boolean_cmd ("always-inserted", class_support
,
15965 &always_inserted_mode
, _("\
15966 Set mode for inserting breakpoints."), _("\
15967 Show mode for inserting breakpoints."), _("\
15968 When this mode is on, breakpoints are inserted immediately as soon as\n\
15969 they're created, kept inserted even when execution stops, and removed\n\
15970 only when the user deletes them. When this mode is off (the default),\n\
15971 breakpoints are inserted only when execution continues, and removed\n\
15972 when execution stops."),
15974 &show_always_inserted_mode
,
15975 &breakpoint_set_cmdlist
,
15976 &breakpoint_show_cmdlist
);
15978 add_setshow_enum_cmd ("condition-evaluation", class_breakpoint
,
15979 condition_evaluation_enums
,
15980 &condition_evaluation_mode_1
, _("\
15981 Set mode of breakpoint condition evaluation."), _("\
15982 Show mode of breakpoint condition evaluation."), _("\
15983 When this is set to \"host\", breakpoint conditions will be\n\
15984 evaluated on the host's side by GDB. When it is set to \"target\",\n\
15985 breakpoint conditions will be downloaded to the target (if the target\n\
15986 supports such feature) and conditions will be evaluated on the target's side.\n\
15987 If this is set to \"auto\" (default), this will be automatically set to\n\
15988 \"target\" if it supports condition evaluation, otherwise it will\n\
15989 be set to \"host\"."),
15990 &set_condition_evaluation_mode
,
15991 &show_condition_evaluation_mode
,
15992 &breakpoint_set_cmdlist
,
15993 &breakpoint_show_cmdlist
);
15995 add_com ("break-range", class_breakpoint
, break_range_command
, _("\
15996 Set a breakpoint for an address range.\n\
15997 break-range START-LOCATION, END-LOCATION\n\
15998 where START-LOCATION and END-LOCATION can be one of the following:\n\
15999 LINENUM, for that line in the current file,\n\
16000 FILE:LINENUM, for that line in that file,\n\
16001 +OFFSET, for that number of lines after the current line\n\
16002 or the start of the range\n\
16003 FUNCTION, for the first line in that function,\n\
16004 FILE:FUNCTION, to distinguish among like-named static functions.\n\
16005 *ADDRESS, for the instruction at that address.\n\
16007 The breakpoint will stop execution of the inferior whenever it executes\n\
16008 an instruction at any address within the [START-LOCATION, END-LOCATION]\n\
16009 range (including START-LOCATION and END-LOCATION)."));
16011 c
= add_com ("dprintf", class_breakpoint
, dprintf_command
, _("\
16012 Set a dynamic printf at specified location.\n\
16013 dprintf location,format string,arg1,arg2,...\n\
16014 location may be a linespec, explicit, or address location.\n"
16015 "\n" LOCATION_HELP_STRING
));
16016 set_cmd_completer (c
, location_completer
);
16018 add_setshow_enum_cmd ("dprintf-style", class_support
,
16019 dprintf_style_enums
, &dprintf_style
, _("\
16020 Set the style of usage for dynamic printf."), _("\
16021 Show the style of usage for dynamic printf."), _("\
16022 This setting chooses how GDB will do a dynamic printf.\n\
16023 If the value is \"gdb\", then the printing is done by GDB to its own\n\
16024 console, as with the \"printf\" command.\n\
16025 If the value is \"call\", the print is done by calling a function in your\n\
16026 program; by default printf(), but you can choose a different function or\n\
16027 output stream by setting dprintf-function and dprintf-channel."),
16028 update_dprintf_commands
, NULL
,
16029 &setlist
, &showlist
);
16031 dprintf_function
= xstrdup ("printf");
16032 add_setshow_string_cmd ("dprintf-function", class_support
,
16033 &dprintf_function
, _("\
16034 Set the function to use for dynamic printf."), _("\
16035 Show the function to use for dynamic printf."), NULL
,
16036 update_dprintf_commands
, NULL
,
16037 &setlist
, &showlist
);
16039 dprintf_channel
= xstrdup ("");
16040 add_setshow_string_cmd ("dprintf-channel", class_support
,
16041 &dprintf_channel
, _("\
16042 Set the channel to use for dynamic printf."), _("\
16043 Show the channel to use for dynamic printf."), NULL
,
16044 update_dprintf_commands
, NULL
,
16045 &setlist
, &showlist
);
16047 add_setshow_boolean_cmd ("disconnected-dprintf", no_class
,
16048 &disconnected_dprintf
, _("\
16049 Set whether dprintf continues after GDB disconnects."), _("\
16050 Show whether dprintf continues after GDB disconnects."), _("\
16051 Use this to let dprintf commands continue to hit and produce output\n\
16052 even if GDB disconnects or detaches from the target."),
16055 &setlist
, &showlist
);
16057 add_com ("agent-printf", class_vars
, agent_printf_command
, _("\
16058 Target agent only formatted printing, like the C \"printf\" function.\n\
16059 Usage: agent-printf \"format string\", ARG1, ARG2, ARG3, ..., ARGN\n\
16060 This supports most C printf format specifications, like %s, %d, etc.\n\
16061 This is useful for formatted output in user-defined commands."));
16063 automatic_hardware_breakpoints
= true;
16065 gdb::observers::about_to_proceed
.attach (breakpoint_about_to_proceed
,
16067 gdb::observers::thread_exit
.attach (remove_threaded_breakpoints
,